Python高级特性：迭代器、生成器、装饰器与闭包详解

1. Python核心概念深度解析：迭代器、生成器、装饰器与闭包

在Python开发中，迭代器、生成器、装饰器和闭包是四个极其重要的高级特性。它们不仅能提升代码效率，还能让程序更加优雅和Pythonic。作为有多年Python开发经验的工程师，我发现很多开发者对这些概念的理解停留在表面，导致无法充分发挥它们的威力。本文将带你深入理解这些概念的本质、应用场景和实战技巧。

2. 迭代器：数据遍历的幕后英雄

2.1 迭代器基础概念

迭代器是Python中用于遍历集合元素的工具。想象你有一本书，迭代器就像是一个书签，它能帮你记住当前读到哪一页，并且知道如何翻到下一页。

python复制nums = [1, 2, 3]
iter_nums = iter(nums)
print(next(iter_nums))  # 输出1
print(next(iter_nums))  # 输出2
print(next(iter_nums))  # 输出3

这段代码展示了迭代器的基本用法。iter()函数获取列表的迭代器，next()函数逐个获取元素。当没有更多元素时，会抛出StopIteration异常。

2.2 自定义迭代器实现

在实际项目中，我们经常需要自定义迭代器。比如开发一个学生管理系统时，我们希望直接遍历所有学生信息：

python复制class StudentSystem:
    def __init__(self):
        self.students = []
        self.index = 0
    
    def add_student(self, name, age):
        self.students.append({"name": name, "age": age})
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < len(self.students):
            student = self.students[self.index]
            self.index += 1
            return student
        raise StopIteration

# 使用示例
system = StudentSystem()
system.add_student("Alice", 20)
system.add_student("Bob", 21)

for student in system:
    print(f"{student['name']}: {student['age']}")

关键点：

1. __iter__方法返回迭代器对象本身
2. __next__方法返回下一个元素或抛出StopIteration
3. 迭代器状态保存在实例变量中（这里是index）

注意：良好的迭代器实现应该考虑线程安全问题，特别是在多线程环境下使用时。

2.3 迭代器的高级应用

迭代器在Python中无处不在，很多内置函数都基于迭代器协议：

python复制# 文件读取也是迭代器
with open('data.txt') as f:
    for line in f:  # 文件对象本身就是迭代器
        print(line.strip())

# zip, map, filter等都返回迭代器
names = ['Alice', 'Bob']
ages = [20, 21]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

迭代器的优势在于惰性计算，只有在需要时才生成元素，这对处理大数据集特别有用，可以节省内存。

3. 生成器：优雅的迭代器简化版

3.1 生成器基础

生成器是一种特殊的迭代器，使用yield关键字定义。它比普通迭代器更简洁：

python复制def count_down(n):
    print("Starting count down")
    while n > 0:
        yield n
        n -= 1

# 使用生成器
for i in count_down(5):
    print(i)

生成器函数执行到yield时会暂停，保存所有局部状态，下次调用时从暂停处继续执行。

3.2 生成器表达式

类似于列表推导式，但更节省内存：

python复制# 列表推导式 - 立即计算所有结果
squares_list = [x*x for x in range(1000000)]  # 占用大量内存

# 生成器表达式 - 惰性计算
squares_gen = (x*x for x in range(1000000))  # 几乎不占内存

print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

3.3 生成器高级技巧

生成器可以双向通信：

python复制def running_average():
    total = 0
    count = 0
    while True:
        value = yield total/count if count else 0
        total += value
        count += 1

avg = running_average()
next(avg)  # 启动生成器
print(avg.send(10))  # 10.0
print(avg.send(20))  # 15.0
print(avg.send(30))  # 20.0

关键点：

1. 使用send()方法向生成器发送数据
2. 首次调用必须先next()或send(None)启动生成器
3. yield既返回数据也接收数据

4. 装饰器：不修改代码增强函数功能

4.1 装饰器基础

装饰器本质上是一个高阶函数，它接受一个函数作为参数并返回一个新函数：

python复制def log_time(func):
    import time
    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

@log_time
def calculate_sum(n):
    return sum(range(n))

print(calculate_sum(1000000))

4.2 带参数的装饰器

装饰器本身也可以接受参数：

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

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

4.3 类装饰器

装饰器也可以使用类实现：

python复制class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0
    
    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"Call {self.calls} of {self.func.__name__}")
        return self.func(*args, **kwargs)

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

say_hello()
say_hello()

5. 闭包：函数与环境的完美结合

5.1 闭包基础

闭包是指在一个内部函数中访问外部函数的变量：

python复制def make_multiplier(factor):
    def multiplier(number):
        return number * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # 10
print(triple(5))  # 15

5.2 闭包的实际应用

闭包非常适合创建特定功能的函数工厂：

python复制def make_adder(n):
    def adder(x):
        return x + n
    return adder

add5 = make_adder(5)
add10 = make_adder(10)

print(add5(3))   # 8
print(add10(3))  # 13

5.3 闭包与装饰器的关系

装饰器实际上是闭包的一种应用：

python复制def decorator(func):
    def wrapper(*args, **kwargs):
        print("Before calling")
        result = func(*args, **kwargs)
        print("After calling")
        return result
    return wrapper

6. 性能优化与注意事项

6.1 迭代器与生成器的内存优势

处理大数据时，迭代器和生成器可以显著减少内存使用：

python复制# 不好的做法 - 读取整个文件到内存
with open('huge_file.txt') as f:
    lines = f.readlines()  # 可能耗尽内存
    for line in lines:
        process(line)

# 好的做法 - 使用迭代器逐行处理
with open('huge_file.txt') as f:
    for line in f:  # 文件对象本身就是迭代器
        process(line)

6.2 装饰器的执行顺序

多个装饰器从下往上执行：

python复制@decorator1
@decorator2
def my_func():
    pass

# 等价于
my_func = decorator1(decorator2(my_func))

6.3 避免闭包的内存泄漏

闭包会保持外部变量的引用，可能导致内存无法释放：

python复制def create_leak():
    big_data = [...]  # 大数据
    def inner():
        return len(big_data)
    return inner

leak = create_leak()
# 即使不再需要leak，big_data也不会被释放
# 解决方法：显式删除
leak = None

7. 实战案例：构建一个数据管道

结合这些概念，我们可以构建一个强大的数据处理管道：

python复制def file_reader(filename):
    """生成器：逐行读取文件"""
    with open(filename) as f:
        for line in f:
            yield line.strip()

def filter_comments(lines):
    """生成器：过滤注释行"""
    for line in lines:
        if not line.startswith('#'):
            yield line

def parse_numbers(lines):
    """生成器：解析数字"""
    for line in lines:
        yield [float(x) for x in line.split()]

def pipeline(filename):
    """构建处理管道"""
    lines = file_reader(filename)
    filtered = filter_comments(lines)
    numbers = parse_numbers(filtered)
    return numbers

# 使用装饰器记录处理时间
@log_time
def process_file(filename):
    for nums in pipeline(filename):
        print(sum(nums))

process_file('data.txt')

这个案例展示了如何将生成器用于数据处理管道，每个处理步骤都是惰性的，只有需要时才处理数据，大大提高了内存效率。