Python装饰器与生成器：进阶编程的核心技术

1. 装饰器与生成器：Python进阶的两大核心武器

第一次接触Python装饰器和生成器时，我完全被它们的神奇特性震撼到了。记得当时为了理解一个简单的@timer装饰器，我整整调试了三个晚上。而现在，这两种特性已经成为我日常开发中不可或缺的工具。装饰器让我能够优雅地扩展函数功能而不修改其源代码，生成器则帮我轻松处理海量数据而不必担心内存爆炸。这两个特性看似简单，实则是Python从"能写"到"会写"的关键分水岭。

2. 装饰器深度解析

2.1 装饰器本质揭秘

装饰器的核心思想是"高阶函数+闭包"。简单来说，装饰器就是一个接受函数作为参数并返回新函数的函数。这种设计模式在Python中通过@语法糖得到了优雅的实现。

python复制def simple_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello!")

say_hello()

这段代码展示了最基本的装饰器结构。当调用say_hello()时，实际上执行的是wrapper()函数，而原始say_hello函数作为参数传入并被包裹在其中。

2.2 实用装饰器案例集锦

2.2.1 性能计时器

python复制import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} executed in {end-start:.4f}s")
        return result
    return wrapper

这个装饰器可以轻松测量任何函数的执行时间，只需在目标函数前加上@timer即可。

2.2.2 函数调用日志

python复制def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

日志装饰器对于调试复杂程序特别有用，可以清晰看到函数的输入输出。

2.3 装饰器进阶技巧

2.3.1 带参数的装饰器

装饰器本身也可以接受参数，这需要再多一层嵌套：

python复制def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Alice")

2.3.2 保留元数据的装饰器

使用装饰器后，原函数的__name__等元信息会被覆盖，可以使用functools.wraps来保留：

python复制from functools import wraps

def preserve_metadata(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

3. 生成器全面剖析

3.1 生成器基础

生成器是一种特殊的迭代器，通过yield语句实现。与普通函数不同，生成器函数在yield处暂停执行并保留状态，下次调用时从暂停处继续。

python复制def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
print(next(gen))  # 输出1
print(next(gen))  # 输出2

3.2 生成器表达式

类似于列表推导式，但使用圆括号且惰性求值：

python复制numbers = (x for x in range(10) if x % 2 == 0)
print(next(numbers))  # 输出0
print(next(numbers))  # 输出2

3.3 生成器高级应用

3.3.1 处理大型文件

python复制def read_large_file(file_path):
    with open(file_path, 'r') as f:
        for line in f:
            yield line.strip()

for line in read_large_file('huge_file.txt'):
    process_line(line)  # 逐行处理，不一次性加载整个文件

3.3.2 无限序列生成

python复制def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
print(next(fib))  # 0
print(next(fib))  # 1
print(next(fib))  # 1
print(next(fib))  # 2

4. 装饰器与生成器的结合应用

4.1 生成器的记忆化装饰器

python复制def memoize_generator(func):
    cache = {}
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = list(func(*args, **kwargs))
        return iter(cache[key])
    return wrapper

@memoize_generator
def expensive_sequence(n):
    for i in range(n):
        yield complex_calculation(i)

4.2 生成器的性能监控装饰器

python复制def monitor_generator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        gen = func(*args, **kwargs)
        count = 0
        start = time.time()
        for item in gen:
            count += 1
            yield item
        end = time.time()
        print(f"Generated {count} items in {end-start:.2f}s")
    return wrapper

5. 常见问题与解决方案

5.1 装饰器常见陷阱

1. 忘记使用functools.wraps：导致原函数元信息丢失
2. 装饰器顺序错误：多个装饰器从下往上应用
3. 错误处理不当：装饰器中未正确处理被装饰函数的异常

5.2 生成器常见问题

1. 已消耗的生成器：生成器只能迭代一次，再次迭代需要重新创建
2. 过早耗尽生成器：意外使用list()等操作提前消耗生成器
3. 资源泄漏：生成器中打开的资源可能无法及时释放

5.3 调试技巧

1. 使用inspect.getsource()查看装饰后的函数源码
2. 在生成器中加入print语句调试yield行为
3. 使用pdb在装饰器和生成器中设置断点

6. 性能优化实践

6.1 装饰器性能考量

装饰器会在每次调用时增加少量开销。对于性能关键路径，可以考虑：

1. 将装饰逻辑移到被装饰函数内部
2. 使用lru_cache缓存装饰器结果
3. 避免多层嵌套装饰器

6.2 生成器内存优化

生成器最大的优势是内存效率。对比以下两种实现：

python复制# 列表方式（内存不友好）
def get_numbers(n):
    return [x for x in range(n)]

# 生成器方式（内存友好）
def get_numbers_gen(n):
    for x in range(n):
        yield x

对于n=1,000,000，第一种方式会立即创建包含百万个元素的列表，而第二种方式一次只生成一个元素。

7. 实际项目应用案例

7.1 Web框架中的装饰器

Flask路由系统就是基于装饰器：

python复制@app.route('/')
def index():
    return "Hello World"

7.2 数据处理管道

使用生成器构建高效数据处理管道：

python复制def read_data(source):
    for item in source:
        yield item

def filter_data(data, condition):
    for item in data:
        if condition(item):
            yield item

def transform_data(data, mapper):
    for item in data:
        yield mapper(item)

# 组合使用
pipeline = transform_data(
    filter_data(
        read_data(source),
        lambda x: x['active']
    ),
    lambda x: {'id': x['id'], 'name': x['name'].upper()}
)

8. 最佳实践总结

1. 装饰器：

   • 保持装饰器尽可能简单
   • 总是使用functools.wraps
   • 考虑使用类装饰器处理复杂状态

2. 生成器：

   • 用生成器表达式替代列表推导式处理大数据
   • 使用yield from简化嵌套生成器
   • 注意生成器的单次使用特性

3. 组合使用：

   • 装饰器可以增强生成器的功能
   • 生成器可以作为装饰器的实现工具
   • 两者结合可以构建强大的抽象

掌握装饰器和生成器后，你会发现Python代码可以写得更加优雅和高效。它们不仅是语法特性，更是一种编程思维的体现。在实际项目中，我经常使用装饰器来处理横切关注点（如日志、权限检查），而生成器则是我处理流式数据的首选工具。