Python
16 迭代器与生成器
for 的本质、yield 执行模型,看懂 `for chunk in chain.stream()`
- Python
- 进阶
目标:搞懂
for循环背后 Python 到底做了什么,能亲手写出迭代器协议和生成器,从此看懂for chunk in chain.stream(...)这类 LangChain 流式代码——LLM 逐字输出、读大文件不爆内存,背后都是本章这一套机制。
1. 为什么需要:一行代码凭什么能「边到边处理」
LangChain 书第 1 章里有这么几行(先不求看懂每个词):
stream = simple_chain.stream([HumanMessage("Tell me a joke")])
for chunk in stream:
print(chunk)
# Why
# don
# 't
LLM 生成文本是一个词一个词蹦出来的。如果等全文生成完再一次性返回,用户要盯着空白屏幕干等好几秒;上面这段代码却是每到一个片段(chunk)就立刻打印。问题来了:stream 返回的东西里,此刻还没有完整答案,for 循环凭什么能遍历它?
再比如读一个 10 GB 的日志文件:
with open("huge.log") as f:
lines = f.readlines() # ❌ 一次性把 10GB 全塞进内存,电脑直接卡死
换成 for line in f:(10-文件和异常 用过),内存里同一时刻只有一行。它凭什么做得到?
答案相同:for 遍历的从来不是「一整堆数据」,而是一个会按需吐数据的对象——迭代器。数据可以来一点处理一点,来多少占多少内存。本章就讲透这套机制:先拆 for 的真面目,再讲如何自己造这样的对象,最后回到 LangChain。
2. for 循环的真面目:iter() + next()
for x in obj: 是个语法糖。Python 在背后做的事翻译成 while 循环是这样:
for x in [10, 20, 30]:
print(x)
# 大致等价于下面这段(Python 内部自动完成,不用真这么写):
it = iter([10, 20, 30]) # 第 1 步:向对象要一个「迭代器」
while True:
try:
x = next(it) # 第 2 步:不断向迭代器要「下一个值」
print(x) # 第 3 步:拿到的值交给循环体
except StopIteration: # 第 4 步:迭代器说「没了」,用异常终止循环
break
运行结果(两种写法相同):
10
20
30
三个新面孔:
iter(obj):向obj要它的迭代器。列表、字符串、字典、文件都说得出话,所以都能被 for 遍历。next(it):向迭代器要下一个值。要一次给一次,不主动准备后面的——这就是「按需吐数据」。StopIteration:一个异常(见 18-异常处理、调试与测试)。迭代器被掏空后再要,就抛它;for 捕获它来正常结束循环。循环的正常结束,底层竟然是一次异常——这是本章第一个反直觉但重要的机制。
next() 还有个常用变体:给第二个参数作默认值,耗尽时不抛异常而返回它,适合「取第一个,没有就算了」的写法:
it = iter([])
print(next(it, "空空如也")) # 空空如也
3. 迭代器协议:__iter__ 与 __next__
「能被 iter() 要出迭代器」和「能被 next() 要值」不是天生的,是两个魔术方法(15-面向对象进阶 讲过魔术方法的套路):
- 对象实现
__iter__,返回一个迭代器 → 它是可迭代对象(iterable),能放 for 后面; - 对象实现
__next__,返回下一个值、没值时抛StopIteration→ 它是迭代器(iterator)。
两个都实现,这套约定就叫迭代器协议。亲手写一个倒计时类:
class Countdown:
def __init__(self, start):
self.n = start
def __iter__(self):
return self # 自己就是迭代器,直接交出去
def __next__(self):
if self.n <= 0:
raise StopIteration # 没值了:按协议抛这个异常,for 会接住
self.n -= 1
return self.n + 1
for x in Countdown(3):
print(x)
# 3
# 2
# 1
现在 iter()、next()、for 三条路都通了,因为它们找的就是这两个方法。
可迭代对象 vs 迭代器:一对易混概念
多数时候两者是两个不同对象:列表是可迭代对象,iter(列表) 才造出迭代器。验证:
lst = [1, 2]
print(iter(lst) is iter(lst)) # False:每次 iter() 都新造一个迭代器
next(lst) # ❌ TypeError: 'list' object is not an iterator
g = (x for x in lst) # 生成器表达式,下一节细讲
print(iter(g) is g) # True:生成器自己就是迭代器,__iter__ 返回自身
| 可迭代对象(如 list、str、dict) | 迭代器(如生成器) | |
|---|---|---|
| 实现的方法 | __iter__ | __iter__ + __next__ |
| 能放进 for | 能 | 能 |
能直接 next() | 不能,TypeError | 能 |
| 数据何时就位 | 早已全部存在内存里 | 按需产出,一次一个 |
| 能遍历几次 | 无限次(每次 iter() 拿新迭代器) | 只有一次,掏空即废 |
最后一行解释了上一节代码的现象,也埋着本章最大的坑:
c = Countdown(3)
print(list(c), list(c)) # [3, 2, 1] []——Countdown 自己就是迭代器,第一次已掏空
list 没这个问题,因为每次 for 都找它要了新的迭代器,各掏各的。想让 Countdown 也经得起反复遍历,标准姿势有两个。
姿势一:拆成两个类——可迭代对象记配置、只负责发迭代器;迭代器记进度(list 内部正是这么干的):
class Countdown:
def __init__(self, start):
self.start = start # 只记配置,不记进度
def __iter__(self):
return CountdownIterator(self.start) # 每次 iter() 发一个全新的
class CountdownIterator:
def __init__(self, n):
self.n = n # 进度记在迭代器身上
def __iter__(self):
return self
def __next__(self):
if self.n <= 0:
raise StopIteration
self.n -= 1
return self.n + 1
c = Countdown(3)
print(list(c), list(c)) # [3, 2, 1] [3, 2, 1]——每次发新迭代器,各掏各的
姿势二(更常用):把 __iter__ 写成生成器函数。函数体里有 yield,每次调用它就返回一个全新的生成器,进度天然记在生成器身上——手写 __next__ 和 StopIteration 的样板全省了:
class Countdown:
def __init__(self, start):
self.start = start
def __iter__(self): # 生成器函数:每次 iter() 造一个新生成器
n = self.start
while n > 0:
yield n
n -= 1
c = Countdown(3)
print(list(c), list(c)) # [3, 2, 1] [3, 2, 1]
姿势二是自定义可迭代类的现代标准写法。分界线记牢:可迭代对象记配置,迭代器记进度——想反复遍历,就把两样分开存放。
4. 生成器函数:yield 的「暂停—唤醒」执行模型
倒计时类要自己管理 self.n、自己抛异常,样板不少。只要函数体里出现一个 yield,这个函数就成了生成器函数——调用它不执行函数体,而是返回一个现成的迭代器,协议全由 Python 代劳。
核心执行模型一句话:执行到 yield 暂停并交出值,next() 唤醒继续。普通函数是「一口气跑完」,生成器函数是「按 next 分段放映的电影」。
下面这个例子值得逐行精读。先看代码,再看执行结果,对照「第几次 next 执行到了哪」:
def three_yields():
print("【第 1 次 next】从函数开头执行")
x = 10
yield x # 在这里暂停,把 10 交出去
print("【第 2 次 next】从 yield 的下一行醒来")
y = x * 2 # 醒来时 x 还是 10——局部变量被冻结保存了
yield y # 又暂停,交出 20
print("【第 3 次 next】继续")
yield x + y # 暂停,交出 30
print("【第 4 次 next】函数体走完,抛 StopIteration")
g = three_yields() # 注意:此刻函数体一行都没执行!只是造出生成器
print("生成器已创建")
print("拿到:", next(g)) # 10
print("拿到:", next(g)) # 20
print("拿到:", next(g)) # 30
next(g) # StopIteration(for 循环里会被接住,这里直接跑会报错)
运行结果:
生成器已创建
【第 1 次 next】从函数开头执行
拿到: 10
【第 2 次 next】从 yield 的下一行醒来
拿到: 20
【第 3 次 next】继续
拿到: 30
【第 4 次 next】函数体走完,抛 StopIteration
Traceback (most recent call last):
...
StopIteration
请盯着结果确认三件事:
- 创建不等于执行:
g = three_yields()之后什么都没打印——调用生成器函数只是拿到生成器,函数体等第一次 next 才启动。 - 暂停时一切被冻结:两次 next 之间,局部变量
x、执行到哪一行,都原封不动存在生成器对象里。普通函数可没有这种本事(它根本没有「暂停」这个状态)。 - 醒来从 yield 的下一行继续,不是从头跑。
也解释了 §1 的问题:for chunk in stream 里,每个 chunk 到达(yield 交出)就进循环体打印,模型生成下一个 chunk 的等待时间里,程序就闲在 yield 处暂停着,自然不占内存也不干等。
生成器只能消费一次
生成器是迭代器,而迭代器掏空即废:
def nums():
yield 1
yield 2
g = nums()
print(list(g)) # [1, 2] list() 内部就是不停 next 直到 StopIteration
print(list(g)) # [] 再遍历:直接收到 StopIteration,得到空列表
这不是 bug,是设计:生成器往往代表「一次性的数据流」(网络响应、文件内容),流过了就过了。
5. 生成器表达式 vs 列表推导式
第 08 章学过列表推导式 [x * x for x in range(1000)]。把方括号换成圆括号,就得到生成器表达式——一个匿名的生成器:
import sys
lst = [x * x for x in range(1000)] # 立刻算出全部 1000 个数,存成列表
gen = (x * x for x in range(1000)) # 只造了一个"会算数的机器",一个数都没算
print(sys.getsizeof(lst)) # 8856 字节(Python 3.14 / macOS 实测)
print(sys.getsizeof(gen)) # 208 字节——与要处理多少数据无关
差 40 多倍,而且列表的占用随数据量线性涨,生成器基本不动——机器本身很小,数字才是按需生产的。
惰性还可以亲眼看到——不 next,函数体一个字不执行:
gen = (print(f"算了一轮: {x}") or x for x in range(3))
print("--- 创建完成,还没执行 ---")
print("取到:", next(gen))
print("--- 取了一次之后 ---")
运行结果:
--- 创建完成,还没执行 ---
算了一轮: 0
取到: 0
--- 取了一次之后 ---
next 之后那一行 算了一轮 才出现,且只出现一次——每次 next 只推一轮。
列表推导式 [...] | 生成器表达式 (...) | |
|---|---|---|
| 求值时机 | 立刻全部算好 | 惰性,next 一次算一次 |
| 内存 | 与数据量成正比 | 几乎恒定(约 200 字节) |
| 能遍历几次 | 随意 | 一次 |
| 能切片/索引/len | 能(它是列表) | 不能 |
| 适用场景 | 要反复用、要下标、要 len | 只过一遍、数据大、与 for 配合 |
经验法则:只需要遍历一次,就用生成器。唯一要注意的坑:生成器表达式作为唯一实参传函数时,两层括号可省——sum(x * x for x in range(10))。
6. 双向通道与接力棒:send 与 yield from(认识即可)
真实代码里还会遇到 yield 的两个进阶形态,读代码认识即可。
yield 不只交出值,还能接收值。send() 让调用方把数据塞回生成器,yield 表达式的值就是塞进来的东西——生成器成了可以双向通话的协程(这也是「生成器是 20-异步编程入门 里协程的思想源头」的原因):
def echo():
while True:
received = yield # yield 右边没写东西:交出 None,接收 send 进来的值
print("收到:", received)
e = echo()
next(e) # 第一次必须 next(或 send(None)):推进到 yield 处,才能开始 send
e.send("hello") # 收到: hello
e.send("world") # 收到: world
yield from:把活儿委托给子生成器。自己不再逐个转发,整段交出去,子生成器耗尽后回来继续:
def inner():
yield "a"
yield "b"
def outer():
yield "开始"
yield from inner() # 等价于:for v in inner(): yield v
yield "结束"
print(list(outer())) # ['开始', 'a', 'b', '结束']
读库代码时见到 yield from xxx,理解成「把 xxx 产出的值原样接力吐出」即可。
7. itertools 四件套与无限生成器
标准库 itertools(import 即用)是提前造好的一箱子生成器工具,真实项目出场率极高。
from itertools import count, islice, chain, groupby
# count:从 3 开始的无限计数器 3, 4, 5, ...(必须配 islice 截断才敢遍历)
print(list(islice(count(3), 5))) # [3, 4, 5, 6, 7]
# islice:切片的生成器版——stream[:5] 不存在,islice(stream, 5) 才行
# chain:把多个可迭代对象首尾接成一条流
for ch in islice(chain("ab", "cd"), 3):
print(ch) # a b c(各一行)
# groupby:把相邻的同类元素分组,常用于数据归类
data = [("水果", "苹果"), ("水果", "香蕉"), ("蔬菜", "白菜")]
for key, group in groupby(data, key=lambda item: item[0]):
print(key, [item[1] for item in group])
# 水果 ['苹果', '香蕉']
# 蔬菜 ['白菜']
注意 groupby 只对相邻相同元素分组(坑见下节),它返回的 group 本身也是个生成器,只能消费一次,一般当场转成 list。
有 islice 兜底,就敢写无限生成器了——不设终止条件的生成器,理论上能永远吐下去,要几个截几个。经典例子斐波那契数列:
from itertools import islice
def fib():
a, b = 0, 1
while True: # 无限循环 + yield:一个永不枯竭的数列流
yield a # 交出一个,暂停;唤醒后往下算下一个
a, b = b, a + b
print(list(islice(fib(), 10))) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
while True 在普通函数里是灾难,在生成器里却恰到好处:反正每次只算一个,无限只是「你不喊停就一直有」。LLM 的 token 流、传感器的读数流,本质都是这种「不知道总量、来一个处理一个」的流。
8. 实战:组装一条生成器流水线
单个生成器是「一台按需吐数据的机器」,多台串起来才是完全体——像 Unix 管道 cat app.log | grep ERROR | sort | uniq -c:每一环收一个、处理一个、交出一个,全链条任意时刻只持有当前这一个元素。
先造一小份演示日志(真实场景把它想成 10 GB):
# make_log.py:生成演示数据,跑一次即可
from pathlib import Path
rows = [
("08:00:01", "INFO", "user login"),
("08:00:05", "ERROR", "db timeout"),
("08:00:09", "INFO", "user login"),
("08:01:00", "ERROR", "db timeout"),
("08:02:00", "ERROR", "disk almost full"),
("08:03:00", "INFO", "user login"),
]
Path("app.log").write_text(
"\n".join(f"2026-10-08 {t} {level} {msg}" for t, level, msg in rows),
encoding="utf-8",
)
主程序:读文件 → 挑出 ERROR 行 → 剥掉日期时间留正文 → 汇总计数。每一环都是一个生成器函数:
# analyze.py
from collections import Counter
def read_lines(path):
"""第 1 环:逐行读文件——文件对象本身就是迭代器(§1 承诺的答案)"""
with open(path, encoding="utf-8") as f:
for line in f:
yield line.rstrip("\n")
def only_errors(lines):
"""第 2 环:过滤——非 ERROR 行直接丢弃,不往下游传"""
for line in lines:
if " ERROR " in line:
yield line
def strip_time(lines):
"""第 3 环:变换——split 最多切 3 刀,[3] 就是正文(第 7 章的字符串功夫)"""
for line in lines:
yield line.split(" ", 3)[3]
def count_by_message(messages):
"""终点站:汇总——流水线的尽头通常是聚合,普通函数即可"""
counts = Counter()
for msg in messages:
counts[msg] += 1
return counts
pipeline = strip_time(only_errors(read_lines("app.log")))
print(count_by_message(pipeline))
实测输出:
Counter({'db timeout': 2, 'disk almost full': 1})
盯着第一行日志走一遍:read_lines 打开文件、yield 出第 1 行 → only_errors 收到、判定丢弃,再去拉第 2 行 → 第 2 行是 ERROR,转手 → strip_time 砍掉 2026-10-08 08:00:05 ERROR、只留正文 → count_by_message 计数。然后第 3 行才被读取。没有任何一环把整个文件装进内存——把 app.log 换成 10 GB,内存占用几乎不变。§1 的两个问题(流式输出、大文件不爆内存)在这里兑现为同一条机制。
两个实用细节:
- 组装方式随意换:分层写变量(从右往左读:先
read_lines,再only_errors,再strip_time),或一步嵌套count_by_message(strip_time(only_errors(read_lines("app.log"))))。环节一多,中间变量版更可读、更好调试。 - 不启动就不干活:
pipeline = ...组装完时一行日志都没读,直到count_by_message里 for 起来才逐环拉动——§5 的「不 next 不执行」贯穿全链。
9. 常见坑
坑 1:生成器耗尽后继续用,不报错但结果为空。 这是所有坑里最阴的——没有异常,只有静悄悄的空结果:
gen = (x for x in range(5))
print(sum(gen)) # 10
print(sum(gen)) # 0 —— 不报错!但第二次拿到的是空流
修法:数据要反复用,先物化成列表 data = list(gen),用列表去重复操作。
坑 2:对生成器求 len。 生成器还没算,长度根本不存在:
gen = (x for x in range(10))
print(len(gen)) # ❌ TypeError: object of type 'generator' has no len()
要个数就 len(list(gen))(代价是全部算完);只判断是否为空,用 next(gen, None) is None。
坑 3:把生成器当列表传来传去。 函数 A print 了一遍生成器参数、函数 B 又去 sum——A 顺手把流消费光,B 拿到空。规则:生成器默认只归一个消费者;API 需要多次读取时,参数直接收列表,或函数内先 list()。
坑 4:groupby 忘了先排序。 分组依据不相邻,就被切成重复的组:
from itertools import groupby
words = ["苹果", "白菜", "香蕉", "萝卜", "土豆"]
is_fruit = lambda w: "水果" if w in ("苹果", "香蕉") else "蔬菜"
for key, group in groupby(words, key=is_fruit):
print(key, list(group))
# 水果 ['苹果']
# 蔬菜 ['白菜']
# 水果 ['香蕉'] ← 意料之外:又出现一组"水果"
# 蔬菜 ['萝卜', '土豆']
修法:分组前先按同一个 key 排序,groupby(sorted(words, key=is_fruit), key=is_fruit)。
10. 在 LangChain 里的样子
现在回头精读开头的代码。摘自 langchain-book-python/01-认识LangChain与LCEL.md:
stream = simple_chain.stream([HumanMessage("Tell me a joke")])
for chunk in stream:
print(chunk)
# Why
# don
# 't
逐行解读:
simple_chain.stream(...):stream是所有 Runnable 统一的流式调用接口。它不等待完整回答,而是立刻返回一个生成器(底层由 LLM API 的流式响应驱动:每收到一小段增量文本就yield一个AIMessageChunk)。for chunk in stream:走到这里才启动流。模型每产出一个 chunk,next()唤醒生成器拿到它,进循环体打印——chunk 到达即消费,用户看到的就是逐词蹦字的效果。- 循环的结束同样靠
StopIteration:模型输出完毕,生成器自然耗尽,for 正常退出。§2 那套机制在这里一字不差地运转。
再看服务端部署形态,摘编自 langchain-book-python/10-流式API与部署.md(async 语法在 20-异步编程入门,这里只看结构):
@app.post("/chat")
async def chat(req: ChatRequest):
async def token_stream():
try:
# stream_mode="messages":逐 token 产出 (message, metadata)
async for message, metadata in agent.astream(
{"messages": [{"role": "user", "content": req.question}]},
{"configurable": {"thread_id": req.session_id}},
stream_mode="messages",
):
if message.content:
yield message.content # token 到达即 yield
except Exception as e:
yield f"Error: {e}"
return StreamingResponse(token_stream(), media_type="text/plain; charset=utf-8")
token_stream是一个生成器函数(函数体里有yield),只是加了async、内部用async for逐 token 拉取 agent 输出——异步版生成器,暂停—唤醒模型完全相同。token_stream()调用后不执行函数体,只交出一个生成器,塞给StreamingResponse:FastAPI 拿着它不断「next」,来一个 token 就往网络写一块,浏览器那边便实时蹦字。yield f"Error: {e}"正是坑 1 的反面应用:响应头已发出、改不了状态码,所以异常也要转成一条普通的 yield 流出去,绝不让流「无声耗尽」。
一条数据流从 LLM API → astream → token_stream 生成器 → HTTP 响应,全程没有一处把完整回答攒进内存——这就是 §8 流水线的网络版,只不过中间那环换成了「LLM API 吐 token」。更多 LangChain 惯用法见 22-读懂LangChain:语法桥。
小练习
- 用 while +
iter()+next()手工模拟for ch in "hi",打印每个字符,捕获StopIteration后打印「完毕」。 - 写生成器函数
evens(n),依次产出 2, 4, …, 2n(共 n 个),用 for 验证list(evens(4))是[2, 4, 6, 8]。 - 写无限生成器
countdown_from(n):产出 n, n-1, n-2, … 一直到 0 后又从 n 重新开始,无限循环。配islice打印n=3的前 7 个数。 - 修复坑:下面代码先输出
20再输出0,请改成两处都输出20,并说明原因。
gen = (x * x for x in [1, 2, 3, 4] if x % 2 == 0)
print(sum(gen))
print(sum(gen))
- 用「
__iter__写成生成器函数」的技巧(§3 姿势二),写一个可反复遍历的class Squares::构造时收n,每次遍历产出 1², 2², …, n²;验证list两遍结果相同。
练习答案
# 练习 1
it = iter("hi")
while True:
try:
ch = next(it)
print(ch)
except StopIteration:
print("完毕")
break
# 练习 2
def evens(n):
for i in range(1, n + 1):
yield 2 * i
print(list(evens(4))) # [2, 4, 6, 8]
# 练习 3
from itertools import islice
def countdown_from(n):
while True: # 外层无限:一轮走完从头再来
for x in range(n, -1, -1):
yield x
print(list(islice(countdown_from(3), 7))) # [3, 2, 1, 0, 3, 2, 1]
# 练习 4:生成器只能消费一次——第一次 sum 把流掏空(2² + 4² = 20),
# 第二次遍历立刻 StopIteration,sum 得到 0。要反复使用就先物化成列表:
gen = (x * x for x in [1, 2, 3, 4] if x % 2 == 0)
squares = list(gen) # 一次性算好存进列表
print(sum(squares)) # 20
print(sum(squares)) # 20
# 练习 5
class Squares:
def __init__(self, n):
self.n = n # 可迭代对象只记配置
def __iter__(self): # 生成器函数:每次遍历都造一个新生成器
for i in range(1, self.n + 1):
yield i * i
s = Squares(4)
print(list(s), list(s)) # [1, 4, 9, 16] [1, 4, 9, 16]