class DataProcessor:
    """智能数据处理器"""
    
    def __init__(self):
        self.processing_steps = []
    
    def add_step(self, step_function):
        """添加处理步骤（高阶函数应用）"""
        self.processing_steps.append(step_function)
        return self
    
    def process(self, data):
        """执行所有处理步骤"""
        result = data
        for step in self.processing_steps:
            result = step(result)
        return result

# 创建处理步骤
def clean_data(data):
    """清理数据"""
    return [x for x in data if x is not None and x != ""]

def normalize_data(data):
    """标准化数据"""
    if not data:
        return []
    max_val = max(data)
    return [x / max_val for x in data]

def add_bonus(data, bonus=0.1):
    """添加奖励（闭包应用）"""
    return [x * (1 + bonus) for x in data]

# 使用数据处理管道
processor = DataProcessor()
processor.add_step(clean_data)
processor.add_step(normalize_data)
processor.add_step(lambda x: add_bonus(x, 0.15))

sales_data = [100, 200, None, 150, 300, ""]
processed_data = processor.process(sales_data)
print("处理后的数据:", processed_data)

import time
import functools

def performance_monitor(func_name=None):
    """性能监控装饰器工厂"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            memory_before = len(str(args))  # 简单内存估算
            
            result = func(*args, **kwargs)
            
            end_time = time.time()
            memory_after = len(str(result))
            
            execution_time = end_time - start_time
            memory_used = memory_after - memory_before
            
            print(f"🚀 {func_name or func.__name__} 性能报告:")
            print(f"   执行时间: {execution_time:.4f}秒")
            print(f"   内存变化: {memory_used}字符")
            
            return result
        return wrapper
    return decorator

@performance_monitor("数据分析")
def analyze_sales(sales_data):
    """分析销售数据"""
    total = sum(sales_data)
    average = total / len(sales_data) if sales_data else 0
    max_sale = max(sales_data) if sales_data else 0
    
    return {
        'total': total,
        'average': average,
        'max': max_sale,
        'count': len(sales_data)
    }

# 使用示例
sales = [1000, 1500, 800, 2000, 1200, 1800]
result = analyze_sales(sales)
print("分析结果:", result)

def memoize(func):
    """简单的缓存装饰器"""
    cache = {}
    
    def wrapper(*args):
        if args in cache:
            print(f"从缓存获取: {func.__name__}{args}")
            return cache[args]
        
        result = func(*args)
        cache[args] = result
        print(f"计算并缓存: {func.__name__}{args}")
        return result
    
    return wrapper

@memoize
def expensive_calculation(n):
    """模拟耗时计算"""
    print(f"正在计算 {n}...")
    return n * n + n * 2 + 1

# 使用缓存系统
print(expensive_calculation(5))  # 计算
print(expensive_calculation(5))  # 从缓存获取
print(expensive_calculation(10)) # 计算
print(expensive_calculation(5))  # 从缓存获取