生成器与迭代器

是什么，为什么存在

迭代器协议（iterator protocol） 是 Python 逐项读取数据的统一接口。可迭代对象的 __iter__() 返回一个迭代器，迭代器的 __next__() 返回下一项；没有下一项时，__next__() 抛出 StopIteration。for、推导式、sum()、zip() 和许多标准库 API 都建立在这套协议上。

可迭代对象和迭代器不是同义词。列表、元组与 range 通常可以多次调用 iter()，每次得到新的独立迭代器；文件对象、生成器对象和很多流式游标本身就是迭代器，iter(obj) is obj，消费后不会自动回到开头。

生成器（generator）是实现迭代器的一种方式。生成器函数使用 yield 产出值，Python 替你保存暂停位置、局部变量与异常处理状态。调用生成器函数只创建生成器对象，函数体要等到第一次 next() 才开始执行。

生成器解决的是控制权和状态保存问题。生产者可以在产出一项后暂停，消费者决定何时继续，因此无需先构造完整列表。这种 惰性求值（lazy evaluation） 适合逐行读取、转换管道、分页结果和可能无限的序列，也能让下游在找到结果后提前停止。

惰性不等于一定更快，也不保证内存永远很小。管道中某一步若调用 list()、sorted() 或需要全量分组，仍会物化所有输入；itertools.tee() 的消费者进度相差很大时也要缓存尚未被较慢一方读取的元素。应从数据流的所有权和消费方式判断，而不是把生成器当作通用优化开关。

工作原理

for item in source 会先求值 source，再调用 iter(source) 一次。循环反复调用 next(iterator) 并把结果绑定给 item；收到 StopIteration 时正常结束。循环体自己抛出的其他异常不会被协议吞掉。

迭代器必须让 __iter__() 返回自身。这样，接收任意可迭代对象的代码可以统一调用 iter()，即使传入的已经是迭代器也不会丢失当前位置。自定义容器则通常让 __iter__() 每次创建新迭代器，以便多个循环互不干扰。

生成器函数的调用与普通函数不同。调用时只创建一个生成器对象；第一次 next() 执行到首个 yield，把右侧值交给调用方并暂停。下一次 next() 从暂停点之后恢复，其中保存的局部变量仍是上次的状态。

生成器正常执行到函数末尾或执行 return 时会结束。协议层通过 StopIteration 表示结束，return value 会把 value 放进该异常的 value 属性；普通 for 循环只把它当成结束信号，不会把这个返回值作为一项产出。

生成器也是可关闭的状态机。close() 会在暂停点抛入 GeneratorExit，因此 finally 有机会运行；若生成器捕获关闭信号后又产出值，close() 会抛出 RuntimeError。调用方提前停止时是否关闭生成器，是必须明确的所有权契约。

示例

下面四个示例依次展示协议、惰性执行、委托与提前关闭。输出均来自本地 python3 对对应文件的实际执行。

单遍倒计时迭代器

Countdown 同时是可迭代对象和迭代器。它的当前位置保存在实例中，因此第二次遍历只会看到剩余项，耗尽后则得到空结果。

list(countdown) 没有重新创建倒计时，它从当前的 2 继续消费到结束。最后一次 list() 再次调用 iter(countdown)，得到的还是已经耗尽的同一对象。

若希望每次循环都从 start 重新开始，应把可迭代对象与游标状态分开。容器的 __iter__() 可以返回新的 Countdown，或者直接返回一个生成器；不要在迭代器的 __iter__() 中悄悄重置状态，那会破坏嵌套循环和部分消费的含义。

看见生成器何时执行

discounted_orders() 在创建时不会读取订单。每次消费者请求下一项，它才继续扫描，直到产出一个符合条件的结果或耗尽输入。

def discounted_orders(rows):
    print("pipeline started")
    for order_id, total in rows:
        print(f"reading {order_id}")
        if total >= 100:
            yield f"{order_id}:{total * 90 // 100}"


source = [("A-17", 120), ("B-02", 80), ("C-99", 200)]
discounts = discounted_orders(source)

print("created")
print(next(discounts))
print(list(discounts))
print(list(discounts))

created
pipeline started
reading A-17
A-17:108
reading B-02
reading C-99
['C-99:180']
[]

"created" 出现在 "pipeline started" 前面，证明调用生成器函数没有执行函数体。第一次 next() 只读到足以产出 A-17 的位置；后面的 list() 才继续扫描另外两条记录。

这个生成器与输入共享消费进度。若 rows 本身也是迭代器，生产者和调用方交替读取它会互相取走数据。一个数据源有多个消费者时，应决定是重新创建源、物化快照、显式广播，还是接受单一所有者。

用 yield from 委托并接收返回值

yield from 不只是缩写一层 for。它把迭代操作委托给子生成器，并在子生成器结束后取得其 return 值。

def read_partition(name, values):
    count = 0
    for value in values:
        count += 1
        yield f"{name}:{value}"
    return count


def export_rows():
    west_count = yield from read_partition("west", [10, 20])
    east_count = yield from read_partition("east", [30])
    return west_count + east_count


rows = export_rows()
while True:
    try:
        print(next(rows))
    except StopIteration as done:
        print(f"rows={done.value}")
        break

west:10
west:20
east:30
rows=3

外层生成器先原样产出西区的两项，子生成器返回 2 后才进入东区。最终返回值 3 只在手动捕获的 StopIteration.value 中可见；list(export_rows()) 会得到三条记录，但不会保留计数。

委托还会转发 send()、throw() 与 close() 的交互。业务代码若只需拼接普通可迭代对象，itertools.chain() 往往更直接；需要子生成器返回值或完整委托语义时，yield from 才表达了真正的契约。

提前停止时关闭生成器

生成器可以让资源跨越多个 yield 保持打开。消费者只取一项时，应显式关闭自己拥有的生成器，让 finally 立即执行。

from io import StringIO


def read_nonempty(text):
    stream = StringIO(text)
    print(f"opened={not stream.closed}")
    try:
        for line in stream:
            cleaned = line.strip()
            if cleaned:
                yield cleaned
    finally:
        stream.close()
        print(f"closed={stream.closed}")


rows = read_nonempty("alpha\n\nbeta\n")
print(next(rows))
rows.close()
print(list(rows))

opened=True
alpha
closed=True
[]

第一次 next() 后，生成器暂停在 yield cleaned，stream 仍然打开。rows.close() 把控制权送回暂停点，finally 关闭流；已经关闭的生成器保持耗尽，因此随后转换为列表得到 []。

文件读取生成器也应使用同样的结构：在生成器函数内部用 with open(...) 包住 yield 所在的循环。若 API 把关闭责任交给调用方，应在名称、文档和使用方式中说明，并可由调用方使用 contextlib.closing() 建立清楚的作用域。

陷阱

把迭代器当成可重复集合

修复方法： 若输入必须重复读取，就让 API 接收能创建新迭代器的可迭代对象或工厂。数据量有界且确实需要多遍时，可以在所有权边界物化一次；不要在深层辅助函数中暗自复制未知大小的输入。

返回已经关闭资源上的生成器表达式

修复方法： 让包含 with 的函数本身成为生成器，并在 with 内的循环中逐项 yield。这样文件会在首次迭代时打开，在耗尽、异常或显式关闭生成器时离开上下文。

用观察代码意外消费输入

修复方法： 调试单遍数据流时，在生产点记录每一项，或只用 itertools.islice() 取得明确数量并接受这些项已被消费。测试应同时断言本次结果与剩余输入，不能只看第一次返回值。

在生成器内部抛出 StopIteration

修复方法： 生成器要结束时使用 return。从另一个迭代器取可选项时，给 next() 提供默认值或在局部捕获 StopIteration，不要让它越过生成器帧边界。

假设 break 会关闭生成器

修复方法： 消费者拥有生成器并可能提前结束时，在 finally 中调用 close()，或者用 contextlib.closing()。不要依赖特定 Python 实现的即时垃圾回收来保证文件、锁或事务的释放时机。

把 tee() 当作免费复制

修复方法： 进度接近的短期分支可以使用 tee()。消费者速度差异不受控时，应改用有界队列和背压、把数据持久化，或在输入有界时明确物化。

延伸阅读

• Python 标准类型：迭代器类型
• Python 语言参考：yield 表达式
• Python 语言参考：生成器表达式
• Python 函数式编程指南：迭代器
• PEP 380：委托给子生成器的语法
• PEP 479：生成器中的 StopIteration 处理