跳转到主要内容

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

请盯着结果确认三件事:

  1. 创建不等于执行:g = three_yields() 之后什么都没打印——调用生成器函数只是拿到生成器,函数体等第一次 next 才启动。
  2. 暂停时一切被冻结:两次 next 之间,局部变量 x、执行到哪一行,都原封不动存在生成器对象里。普通函数可没有这种本事(它根本没有「暂停」这个状态)。
  3. 醒来从 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:语法桥。

小练习

  1. 用 while + iter() + next() 手工模拟 for ch in "hi",打印每个字符,捕获 StopIteration 后打印「完毕」。
  2. 写生成器函数 evens(n),依次产出 2, 4, …, 2n(共 n 个),用 for 验证 list(evens(4)) 是 [2, 4, 6, 8]。
  3. 写无限生成器 countdown_from(n):产出 n, n-1, n-2, … 一直到 0 后又从 n 重新开始,无限循环。配 islice 打印 n=3 的前 7 个数。
  4. 修复坑:下面代码先输出 20 再输出 0,请改成两处都输出 20,并说明原因。
gen = (x * x for x in [1, 2, 3, 4] if x % 2 == 0)
print(sum(gen))
print(sum(gen))
  1. 用「__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]