搞懂 Python 迭代器与生成器：高效处理海量数据的秘密武器

在处理日常业务时，我们经常需要遍历列表、字典或文件中的数据。对于几千、几万条数据，普通的 list 游标循环完全够用。但如果面对数百万行的大型日志文件、百 GB 级的数据库导出流，或者无限数据流，如果依然把所有数据一次性加载到内存中，轻则导致程序卡顿，重则引发令人头疼的 OOM（Out of Memory） 崩溃。

Python 能够轻松应对海量数据流的秘诀，就藏在其核心的迭代器协议（Iterator Protocol）与生成器（Generator）机制中。本文将带你从底层协议剖析到实际应用，彻底掌握这一高效处理大数据的利器。

一、 迭代器协议：Iterable 与 Iterator 的本质

在深入生成器之前，我们必须先弄懂 Python 中两个核心概念：可迭代对象（Iterable）和迭代器（Iterator）。

1.1 可迭代对象（Iterable）

任何能够“返回一个迭代器”的对象，都是可迭代对象。常见的数据结构如 list, tuple, dict, str, set 以及文件对象都属于可迭代对象。

• 它们的共同特征是实现了 __iter__() 方法。
• 你可以使用 iter(obj) 来获取它的迭代器。

1.2 迭代器（Iterator）

迭代器是一个带状态的对象，它不仅实现了 __iter__()（返回自身），还实现了 __next__() 方法。

• 每次调用 __next__()，迭代器就会返回序列中的下一个元素。
• 当数据遍历完毕时，必须抛出 StopIteration 异常来通知遍历结束。

我们可以用代码手动模拟一个迭代器的底层行为：

# 自定义一个简单的数字范围迭代器
class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration  # 遍历结束必须抛出该异常
        self.current -= 1
        return self.current + 1

# 测试自定义迭代器
counter = Countdown(3)
print(next(counter))  # 输出: 3
print(next(counter))  # 输出: 2
print(next(counter))  # 输出: 1
# print(next(counter))  # 抛出 StopIteration 异常

核心差异：

• Iterable（可迭代对象）：可以被遍历多次（每次通过 iter() 生成新的迭代器）。
• Iterator（迭代器）：是一次性的，内部维护了当前遍历的指针，一旦耗尽就废弃了。

二、 生成器（Generator）：优雅编写迭代器的语法糖

虽然自定义类实现 __iter__ 和 __next__ 可以构建迭代器，但代码相对繁琐。Python 提供了生成器（Generator），让我们只需编写一个普通的函数，就能自动获得迭代器的所有特性。

2.1 威力巨大的 yield 关键字

只要函数中包含了 yield 关键字，它就不再是一个普通函数，而是一个生成器函数。当调用该函数时，它不会立即执行代码，而是返回一个生成器对象。

def fibonacci_gen(n):
    print("--- 生成器开始执行 ---")
    a, b = 0, 1
    for _ in range(n):
        yield a  # 暂停执行，把值“产出”给调用方
        a, b = b, a + b

# 获取生成器对象（此时函数内部代码并未运行）
gen = fibonacci_gen(5)
print(type(gen))  # 输出: <class 'generator'>

# 使用 next() 驱动生成器
print(next(gen))  # 打印 "---..." 并输出: 0
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 1

工作原理剖析：

1. 当执行到 yield a 时，生成器会把 a 的值返回，同时冻结（Suspend）当前函数的执行状态（包括局部变量、代码执行位置）。
2. 当下一次调用 next() 或使用 for 循环拉取时，函数从上次暂停的地方无缝恢复，继续往下执行。

2.2 生成器表达式（Generator Expression）

类似于列表推导式，Python 支持用圆括号创建生成器表达式。两者的内存占用有天壤之别：

import sys

# 1. 列表推导式：一次性在内存中生成 100 万个整数（占用几十 MB 内存）
list_comp = [x ** 2 for x in range(1000000)]
print("列表占用内存大小:", sys.getsizeof(list_comp), "字节")

# 2. 生成器表达式：采用“惰性求值（Lazy Evaluation）”，几乎不占用内存
gen_expr = (x ** 2 for x in range(1000000))
print("生成器占用内存大小:", sys.getsizeof(gen_expr), "字节")

输出结果会发现，list_comp 占用高达数兆字节，而 gen_expr 永远只有几十个字节，因为它内部只存储了一个生成逻辑，每次按需计算。

三、 高级进阶：yield from 委派生成器

在 Python 3.3 中引入的 yield from 语法，极大地简化了子生成器（Sub-generator）的嵌套调用。它可以把外部生成器的请求直接“委派”给内层生成器。

假设我们要合并输出多个数据源：

def gen_numbers():
    yield 1
    yield 2

def gen_letters():
    yield 'A'
    yield 'B'

# 使用 yield from 组合多个生成器
def merged_generator():
    yield from gen_numbers()
    yield from gen_letters()

for item in merged_generator():
    print(item, end=' ')  # 输出: 1 2 A B

yield from 不仅代码更简洁，还能在异步编程（如早期的 asyncio 协程架构）中完美处理双向数据流（向子生成器传值和返回值）。

四、 企业级实战：大文件分块读取与流式处理

在实际企业开发中，最经典的生成器应用莫过于处理超大文件（如几十 GB 的服务器 Nginx 访问日志、大型 CSV 数据清洗）。

4.1 错误示范（OOM 灾难）

# 如果文件大小为 15GB，服务器内存只有 8GB，这行代码会直接导致服务崩溃！
with open("huge_access.log", "r", encoding="utf-8") as f:
    lines = f.readlines()  # 把所有行一次性读入内存列表

4.2 正确示范：利用生成器函数进行流式处理

我们可以编写一个按行、或按指定块大小（Chunk）读取文件的生成器：

def read_large_file(file_path, chunk_size=1024):
    """分块读取大文件生成器"""
    with open(file_path, "r", encoding="utf-8") as f:
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            yield chunk

# 实战：统计大文件中某个关键词出现的次数，内存占用恒定为常数级别
def count_keyword_in_file(file_path, keyword):
    count = 0
    # 逐块获取，内存中永远只存在当前这一个 chunk
    for chunk in read_large_file(file_path, chunk_size=4096):
        count += chunk.count(keyword)
    return count

# 模拟调用
# total_count = count_keyword_in_file("huge_access.log", "ERROR")
# print(f"关键词出现总次数: {total_count}")

五、 总结

迭代器与生成器是 Python 性能优化的基石：

1. 迭代器协议定义了统一的遍历标准（__iter__ 与 __next__）。
2. 生成器（yield）通过惰性求值（Lazy Evaluation）将空间复杂度从 $O(N)$ 降低到 $O(1)$。
3. 在面对大数据流、日志分析、实时数据管道等场景时，善用生成器是衡量一个 Python 程序员是否专业的重要标准。