数据如何按需流动:Iterator、Generator 与惰性 Pipeline
前三章分别讨论了怎样组织函数、对象和解释器。第四章把关注点转向数据处理:当数据多到不能一次放进内存,或者数据还在持续产生时,程序应该怎样组织计算?
本篇受教材 4.1 Introduction 与 4.2 Implicit Sequences 启发,但不从斐波那契数列开始,而是贯穿一个更常见的场景:逐条读取任务执行事件,筛选失败记录并统计耗时。
整篇只沿着一条主线展开:
1. 问题不只是数据很大,而是数据不必同时存在
假设 events.jsonl 的每一行都是一条 JSON 事件。最直接的写法会先读取全部内容:
1 | import json |
这种写法的结果很明确:函数返回时,所有事件都已经解析并保存在列表中。但它也隐含了一个要求:内存必须同时容纳全部结果。
如果文件有几十 GB,或者事件来自永不结束的消息流,“先得到完整列表”就不再是合理前提。真正需要的通常只是:
1 | 取一条事件 |
可以把函数改成生成器:
1 | def iter_events(path: str): |
它不会立即解析全部文件,而是在调用者请求下一条数据时才继续读取。
二者并不是“列表落后、生成器先进”。它们表达的是不同契约:
| 方式 | 创建结果时 | 内存特点 | 适合场景 |
|---|---|---|---|
| 列表 | 立即得到全部元素 | 随结果数量增长 | 数据较小,需要反复遍历或随机访问 |
| 惰性迭代 | 消费时逐个产生 | 通常只保留当前状态 | 数据很大、持续产生或只遍历一次 |
因此,惰性的核心不是“跑得更快”,而是 不要求所有数据和中间结果同时存在。
2. Iterable 与 Iterator 分别承担什么职责
理解生成器之前,必须先分清两个经常混用的概念。
2.1 Iterable 表示“可以开始一次遍历”
Iterable(可迭代对象) 能够通过 iter(obj) 提供一个迭代器。列表、元组、字符串、集合和文件对象都可以参与 for 循环,因此都是 iterable。
1 | events = ["created", "running", "finished"] |
这里的列表保存数据,iterator 则保存“当前走到哪里”。
2.2 Iterator 表示“正在进行的一次遍历”
Iterator(迭代器) 提供两个基本操作:
1 | next(iterator) → 返回下一个元素并向前移动 |
1 | next(iterator) # 'created' |
一个 iterator 本身也是 iterable,并且 iter(iterator) 通常返回它自己:
1 | iter(iterator) is iterator # True |
这意味着它不会因为进入一个新的 for 循环就自动回到开头。
| 对象 | 保存的主要内容 | iter(obj) 的典型结果 |
能否自然重复遍历 |
|---|---|---|---|
list |
全部元素 | 每次创建新的 iterator | 可以 |
range |
起点、终点和步长 | 每次创建新的 iterator | 可以 |
| 文件对象 | 文件状态和读取位置 | 通常返回自身 | 通常不自动回到开头 |
| generator | 暂停的执行状态 | 返回自身 | 不可以,耗尽后结束 |
2.3 for 循环替我们处理了迭代协议
下面的循环:
1 | for event in events: |
概念上接近:
1 | iterator = iter(events) |
因此,for 并不要求对象是列表。它只依赖统一的迭代协议:能够得到 iterator,并能不断询问下一个值。
Iterator 是有状态对象;“下一个元素”取决于此前已经消费了多少数据。
3. Generator 用一段函数描述数据怎样产生
手写 iterator class 需要自己维护位置并实现 __iter__()、__next__()。Python 的 Generator(生成器) 让我们直接用普通控制流描述这个过程。
3.1 yield 不是“返回很多次”
包含 yield 的函数是 generator function:
1 | def countdown(start: int): |
调用它时,函数体还没有开始执行:
1 | numbers = countdown(3) # 得到 generator object |
第一次 next(numbers) 才会进入函数体,并在 yield current 处产生 3。此时函数没有结束,而是暂停并保存当前状态:
1 | next(numbers) # 3 |
next()进入函数运行到第一个 yield,产生 3 并暂停next()恢复执行从 yield 后继续,current 变为 2next()再次恢复产生 1,保留新的暂停位置next()函数结束没有新的 yield,抛出 StopIteration暂停时保存的不只是局部变量 current,还包括指令位置和未完成的控制结构。下一次恢复时,函数从上次 yield 之后继续,而不是从第一行重新运行。
3.2 return 与 yield 建立了不同的函数契约
1 | 普通函数 |
生成器适合表达“怎样逐步产生一系列值”,而不是“怎样立即计算一个最终值”。
3.3 Generator 是一次消费的执行过程
1 | numbers = countdown(3) |
第二次为空不是数据消失了,而是第一次 list() 已经把这次执行过程推进到终点。如果需要重新遍历,应重新调用 generator function:
1 | list(countdown(3)) |
4. Lazy Pipeline 让一个元素依次穿过多个阶段
现在回到任务事件。假设每条记录包含:
1 | {"task_id": "t-17", "status": "failed", "duration_ms": 820} |
我们希望统计失败任务的平均耗时。可以把处理拆成小步骤:
1 | def is_failure(event: dict) -> bool: |
然后组合成管道:
1 | events = iter_events("events.jsonl") |
创建 events、failures 和 durations 时几乎没有处理数据。真正的执行由最后的 for 循环驱动:它请求一个 duration,请求会沿着整条管道向上游传播。
每次下游请求只推动上游产生足够的数据;中间阶段不必保存完整集合。
4.1 中间操作与终止操作
可以按是否立即消费输入区分常见操作:
| 类型 | 常见操作 | 作用 |
|---|---|---|
| 惰性中间操作 | generator expression、map、filter、itertools.islice |
返回新的 iterator,描述下一阶段 |
| 终止操作 | for、list、sum、min、max、next |
真正推动迭代并产生最终结果 |
例如:
1 | pipeline = ( |
4.2 操作顺序仍然影响成本
下面两条管道语义可能相同,成本却不同:
1 | 先转换所有事件,再过滤 |
如果转换很昂贵,应该尽早过滤;如果只需要前 10 条,应该尽早限制数量。惰性求值提供了避免无用工作的机会,但不会自动选择最佳顺序。
5. 无限序列必须与“停止条件”一起设计
惰性序列不要求预先知道长度,因此可以表示无限数据:
1 | from itertools import count, islice |
count() 可以一直产生整数,但 islice(..., 5) 只取前五个。二者必须配合,因为下面的操作永远无法完成:
1 | list(count()) # 不要运行:试图收集无限序列 |
无限序列暴露了一个重要事实:并非所有 iterable 都支持序列的全部操作。
1 | 迭代可以回答:下一个值是什么? |
分页接口也可以看成长度暂时未知的序列:
1 | def iter_remote_events(client, page_size: int = 100): |
调用者只看到连续事件,不必知道后端一共请求了多少页;分页策略被隐藏在 iterable 的实现后面。
6. 惰性计算改变了时间,而不只是空间
把立即计算改成惰性计算后,同一段逻辑可能在不同时间执行。这个变化会影响错误、副作用和资源生命周期。
6.1 错误在消费时才出现
1 | def parse_numbers(lines): |
创建 numbers 不会报错。第一次 next(numbers) 得到 10,第二次消费时才出现 ValueError。
因此,返回 generator 的函数只能保证“成功建立了一个计算过程”,不能保证其中所有数据都已验证。
6.2 副作用也会被推迟
1 | def traced_values(values): |
如果没有人消费 generator,print 根本不会发生。将日志、数据库写入等副作用藏进惰性管道,会让执行时机更难判断。更稳妥的做法是让中间阶段尽量保持纯粹,把副作用放在明确的消费边界。
6.3 资源可能比预期保持得更久
iter_events() 中的文件会在 generator 结束、关闭或被回收时退出 with。如果调用者只消费一部分后长期保存 generator,文件也可能继续保持打开。
1 | events = iter_events("events.jsonl") |
实际工程中,更适合让资源所有权清晰:要么在受控作用域内完整消费,要么显式关闭,要么把资源生命周期交给外层 context manager。
6.4 一条流分给多个消费者可能重新积累内存
itertools.tee() 可以从一个输入创建多个独立 iterator,但它需要缓存领先消费者已经读取、落后消费者尚未读取的数据。如果两者速度相差很大,缓存仍可能不断增长。
因此,“接口是 iterator”不自动等于“始终只占常量内存”。还要检查实现是否排序、缓存、分组或复制了数据。
7. 惰性、分批与背压解决的不是同一问题
这三个概念经常一起出现,但职责不同:
| 机制 | 主要解决的问题 |
|---|---|
| Lazy evaluation(惰性求值) | 暂时不计算尚未需要的值 |
| Batching(分批) | 用一组元素平衡调用次数和单次开销 |
| Backpressure(背压) | 消费者跟不上时,限制生产者继续堆积数据 |
同步 generator 通常采用 pull 模型:消费者调用 next(),生产者才继续,因此天然不会无限超前。但如果生产者独立运行,例如网络接收任务不断向队列写入,仅仅把消费者写成 generator 并不能限制队列增长。此时需要有界队列、流量控制或暂停上游。
7.1 异步迭代处理“下一条数据还没有到”
同步 iterator 的 next() 需要现在返回值;当下一条数据要等待网络或其他 I/O 时,可以使用 asynchronous iterator:
1 | async for event in event_stream: |
其本质仍是“逐个取得元素”,只是 __anext__() 返回 awaitable,等待期间事件循环可以运行其他任务。异步迭代扩展了迭代协议,不改变惰性管道的基本思想。
7.2 批大小和队列容量需要用指标校准
分批不是越大越好。批次变大通常能减少网络往返和数据库提交次数,却也会增加单批内存、失败后的重做量,以及第一条结果的等待时间。队列容量也不是越大越安全:过大的缓冲区只会把过载暂时藏在内存里,并延长任务排队时间。
工程上可以先从一个保守值开始,再同时观察三个量:
如果队列持续增长,说明平均生产速度已经高于消费速度;这时继续扩大容量只能推迟问题,应该限速、增加消费者,或降低单条处理成本。
7.3 可恢复进度必须落在副作用之后
流式任务经常需要断点续跑。关键不是“保存一个 cursor”这么简单,而是决定什么时候承认某条数据已经处理完成。如果先保存进度、再写数据库,进程在两步之间崩溃,重启后会跳过尚未落库的数据;更稳妥的顺序是:
1 | 读取一批 → 完成写入 → 确认写入成功 → 提交 cursor / offset |
这样崩溃后最多会重放最近一批,不会静默漏掉它。代价是下游可能再次收到同一条数据,因此写入操作还需要唯一键、upsert 或幂等键来吸收重复。检查点解决“从哪里继续”,幂等性解决“重复执行是否安全”,两者不能互相替代。
8. 怎样选择列表、Iterator 与 Generator
可以用数据生命周期而不是个人偏好做选择:
| 需求 | 更合适的表示 |
|---|---|
| 数据较小,需要随机访问或多次遍历 | list / tuple |
| 数据范围规则明确,可按索引计算 | range 或自定义 sequence |
| 只需要顺序消费一次 | iterator / generator |
| 数据量很大,只需逐项转换 | generator pipeline |
| 数据来自分页接口 | 封装分页的 generator |
| 数据到达需要等待 I/O | asynchronous iterator |
| 多个消费者速度不同 | 有界 queue + backpressure,而不只是 generator |
性能判断也不能只看内存。应该同时观察:
1 | 峰值内存 |
9. 把本篇收束成一条执行链
最终需要保留六个判断:
- Iterable 表示能够开始遍历,Iterator 表示正在进行的一次遍历;
- Generator 是保存了暂停执行状态的 iterator,不是预先装好数据的容器;
- 惰性管道由下游消费驱动,中间阶段通常不会立即处理全部输入;
- 惰性求值主要改变计算发生的时间和内存模型,不保证总计算量更小;
- 无限序列必须配合停止条件,iterator 也不一定支持长度、索引和重复遍历;
- 背压需要限制独立生产者,不能用“已经使用 generator”代替流量控制设计。
有了按需流动的数据,下一篇会继续抽象处理过程:程序不再逐步规定怎样筛选和组合数据,而是声明自己最终需要什么结果。







