第 26 章 按需生产:迭代器与生成器
📖 本章目标:理解"惰性求值",掌握用
yield写生成器。
学完本章,你能写出"边用边算"的代码,处理超大数据再也不怕内存爆掉。
这一章让你的函数升级成"按需生产的食堂阿姨":要一个给一个,不囤货、不占地方。处理海量数据时,这是救命的本事。
【开场小剧场】食堂阿姨的智慧
学生: 皮皮,我听说生成器很厉害,但一直没搞懂它和普通函数有啥区别。
皮皮: 你想想食堂阿姨:如果一次性把 100 份饭全做好放那儿,盘子堆成山;但阿姨是来一个人炒一份——现做现给,不浪费,不占地方。
学生: 所以生成器就是"按需生产"的阿姨?
皮皮: 对!普通列表像"一次性全做好",生成器像"要一个给一个"。今天学这招,处理海量数据再也不用担心内存爆炸。
学生: 那阿姨记性好吗?炒完一个还得记得下一个从哪开始?
皮皮: 这就是 yield 的魔法——它不仅"交出一个",还"记住暂停的位置"。下次接着炒,食材、火候全记得。
26.1 可迭代 vs 迭代器:先理清概念
你已经用了很多"可迭代对象":列表、字符串、字典、元组……它们都能 for x in ...。
for x in [1, 2, 3]: # 列表可迭代
print(x)
可迭代对象(iterable):能 for 遍历的东西。
迭代器(iterator):一个"只能往前、每次吐一个"的流,用 next() 一个个拿。
it = iter([1, 2, 3]) # iter() 把可迭代对象变成迭代器
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
# print(next(it)) # StopIteration!没了
逐行拆解:
- iter([1, 2, 3]):把列表变成迭代器 it——可以理解成给列表装了个"吐一个拿一个"的出货口;
- next(it):每次调用吐出一个;三次分别得到 1、2、3;
- 第四次 next(it):吐完了,报 StopIteration。
next() 每次吐一个,吐完报 StopIteration。 for 循环内部就是不断调用 next(),直到碰到 StopIteration 才结束——所以 for 能遍历迭代器。
换例加深:for 内部到底在干嘛
it = iter(["a", "b", "c"])
while True:
try:
x = next(it)
print(x)
except StopIteration:
break
# a b c
这段代码等价于 for x in it:。 看到没?for 循环的本质就是"反复 next,直到 StopIteration"——只不过 for 帮你把 try/except 藏起来了。
💡 一句话:可迭代对象 = "可以遍历的东西";迭代器 = "一次只吐一个的流"。
26.2 生成器:会"暂停"的函数
生成器(generator) 是"能按需生产"的迭代器。写它只需把一个普通函数里的 return 换成 yield:
def count_down(n):
while n > 0:
yield n # 暂停,把 n 交出去
n -= 1 # 下次接着这里继续
for x in count_down(3):
print(x)
输出:
3
2
1
逐行拆解:
- yield n:遇到 yield,函数暂停,把 n 交出去;
- n -= 1:下次调用生成器时,从 yield 的下一行接着跑;
- 第一次 for 循环要值:count_down(3) 跑到 yield 3,暂停;
- 第二次要值:从 n -= 1 接着,n 变 2,回到 while,yield 2,再暂停……
和普通函数的区别(重点):
- 普通函数:一进就一口气跑完,
return结束,之前的东西全忘; - 生成器:
yield时暂停并交出一个值,下次调用时从暂停的地方接着跑,局部变量还记得。
证据: 上面的 count_down 里,n -= 1 在 yield 之后——普通函数根本走不到这一步,生成器却能每次接着往下走。这就是"有记忆的暂停"。
换例加深:用一个变量接住生成器
gen = count_down(2)
print(gen) # <generator object count_down at 0x...>
print(next(gen)) # 2
print(next(gen)) # 1
print(next(gen)) # StopIteration
注意 print(gen) 打印的是 generator object——调用一个带 yield 的函数,返回的不是普通结果,而是一个"生成器对象"。它在等你 next() 慢慢取。
🐍"皮皮注:只要函数里出现了
yield,这个函数就变成'生成器函数'——你调用它时,函数体一行都不会立刻跑,它只是交给你一个'等号后面慢慢算'的生成器对象。取一个,算一个。"
26.3 生成器省内存:神奇在哪
惰性求值(lazy evaluation):用到才算,不算到不占内存。
看这个对比:
# 方式一:列表,一次性全算,占满内存
nums = [x * 2 for x in range(10_000_000)] # 1 千万个数全算出来存着
# 方式二:生成器,用多少算多少
nums = (x * 2 for x in range(10_000_000)) # 几乎不占内存!
逐行拆解:
- 方式一:1 千万个数一次性全算出来,全塞进内存,占几百 MB;
- 方式二:一个数都不算,只是告诉你"我能按这个规则生产",等你 next() 才算一个。
注意:生成器表达式用小括号 ( ),列表推导式用中括号 [ ]。用 range(10_000_000) 这种超大范围,列表会占用几百 MB,生成器几乎为零。
nums = (x for x in range(100))
print(next(nums)) # 0
print(next(nums)) # 1
换例加深:生成器表达式也能带条件
even_gen = (x for x in range(10) if x % 2 == 0)
print(list(even_gen)) # [0, 2, 4, 6, 8]
和列表推导式语法一模一样,只是中括号换小括号——条件照样能写。
皮皮的忠告:能生成器就别列表,尤其数据量大、或者只遍历一遍时。
💡 什么时候必须用列表? 当你需要下标访问(
nums[5])、多次遍历、求长度时,才用列表。其余"只用一遍"的场景,生成器更优。
26.4 yield 的实战:斐波那契生成器
斐波那契数列:0, 1, 1, 2, 3, 5, 8……每一项是前两项之和。用生成器写,要多少给多少,不浪费:
def fibonacci():
a, b = 0, 1
while True:
yield a # 交出一个,暂停
a, b = b, a + b # 更新(下次从这里继续)
# 生成无限数列,但只取前 8 个
gen = fibonacci()
for _ in range(8):
print(next(gen)) # 0 1 1 2 3 5 8 13
逐行拆解:
- a, b = 0, 1:起始两项(第 12 章学的解包赋值);
- while True::永真循环——理论上无限生产;
- yield a:交出一个数;
- a, b = b, a + b:同时更新——a 变 b,b 变 a+b(第 12 章拆包的妙用);
- 用 for _ in range(8):只 next 8 次,就只算 8 个。
这是无限序列! 如果改成列表,内存直接爆;生成器按需生产,循环取几次就只算几次。
换例加深:用 for 消费前几个
gen = fibonacci()
for i, x in zip(range(6), gen): # 配到短为止(第 14 章 zip)
print(x) # 0 1 1 2 3 5
zip(range(6), gen) 只配对前 6 个——一个"取前 N 个"的优雅小技巧。
配套代码文件:code/ch26/fib_gen.py。
🐍"皮皮注:
while True + yield是生成器的'王牌套路'——敢无限生产,因为没人要求你全部生产。'无限'不可怕,可怕的是'全都要'。"
26.5 实战:逐行读大文件
第 19 章学过 for line in f 逐行读文件——它本身就是惰性的。这里再用生成器包装一层,让"逐行处理"更清晰:
def read_lines(filename):
"""按行产出文件内容(生成器)"""
with open(filename, "r", encoding="utf-8") as f:
for line in f:
yield line.strip() # 去换行符,一行一行给
# 用的时候
for line in read_lines("data.txt"):
if "error" in line: # 只关心错误行
print(line)
逐行拆解:
- def read_lines(filename)::生成器函数,把"逐行读文件"封装起来;
- for line in f: yield line.strip():一行一行读,去换行符,yield 出去;
- 调用 read_lines("data.txt"):不会立刻读文件,只有 for 循环真正要时才开始逐行 yield;
- 主循环里 if "error" in line:拿到一行,过滤、打印。
内存占用 O(1):不管文件多大,每次只在内存里放一行。 这正是"处理大数据"的标准姿势。
换例加深:统计大文件里 error 行数
def count_errors(filename):
total = 0
for line in read_lines(filename):
if "error" in line.lower():
total += 1
return total
print(count_errors("data.txt"))
用起来和普通函数一样顺手——生成器只是"内部按需生产",对外部调用者完全透明。
配套代码文件:code/ch26/read_big_file.py。
💡 记忆点: "逐行读大文件"一共两招:①
for line in f(文件对象本身就能逐行迭代);② 用生成器包装成read_lines(),到处复用。两者都是惰性的,都 O(1) 内存。
【皮皮小课堂】本章要点
- 可迭代对象:能
for遍历的东西(列表/字符串/字典……)。 - 迭代器:
iter()得到,next()一次吐一个,吐完StopIteration。 - 生成器:函数里用
yield代替return;暂停 + 有记忆。 - 生成器表达式:
(x for x in ...)小括号,惰性求值。 - 惰性求值:用到才算,省内存。
- 无限序列也能安全使用:
while True + yield,取几个算几个。 - 大文件:
for line in f逐行读,配合生成器封装,内存 O(1)。 - 注意:生成器一次性、无长度、不能下标——需要随机访问就换列表。
【翻车现场】本章的坑
坑 1:生成器是一次性的,不能反复遍历
gen = (x for x in range(3))
print(list(gen)) # [0, 1, 2]
print(list(gen)) # [] !!!第二次遍历是空的
生成器用完就完——它是一次性的流,不能回头。想遍历两次,就存成列表,或者再造一个生成器。
坑 2:把生成器当列表用(下标、len)
gen = (x for x in range(3))
print(gen[0]) # ❌ TypeError: 'generator' object is not subscriptable
print(len(gen)) # ❌ TypeError
生成器没有长度、不能下标访问,只有 next() 和 for。要随机访问,老老实实用列表。
坑 3:return 和 yield 混着用,含义不一样
def f():
yield 1
return "结束" # 这里的 return 不是返回值,而是"结束迭代"信号
在生成器里,return 值 不返回那个值,只是结束迭代。想要"带结果退出",用 return 不带值。别指望生成器的 return 像普通函数那样传回数据。
坑 4:以为生成器"立即执行"
gen = (print(x) for x in range(3))
print("这行先打印") # 这行先打印!生成器还没开始算
next(gen) # 才开始执行第一个 print
生成器惰性:创建时不执行,next() 时才跑。想立刻跑一遍,list(gen) 或 for。
坑 5:忘了调用带 yield 的函数
def gen():
yield 1
yield 2
print(gen()) # <generator object gen at 0x...> —— 不是 1 也不是 2!
gen() 返回的是生成器对象,不是第一个值。想取值,得 next(gen()) 或 for。"yield 让函数'延迟'到 next 才跑"——别期待它像 return 那样立刻给值。
坑 6:生成器表达式加了多余的中括号
nums = [(x for x in range(3))] # ❌ 外面再套个列表,得到一个装生成器的列表!
print(nums) # [<generator object ...>]
(x for x in range(3)) 已经是生成器了,再套 [ ] 就变成"列表里装一个生成器",完全不是本意。生成器表达式就用 ( ),别画蛇添足。
【本章习题】
一、选择题
1. (★) iter([1, 2, 3]) 和 next() 的组合,next() 的职责是?
- A. 一次性取出全部元素
- B. 每次取出一个元素
- C. 排序
- D. 计算长度
2. (★★) 生成器和普通函数的关键区别是?
- A. 生成器运行更快
- B. 生成器用
yield可以暂停,下次接着执行 - C. 生成器不能有参数
- D. 没有区别
3. (★★) 下面代码输出什么?
def count_down(n):
while n > 0:
yield n
n -= 1
gen = count_down(3)
print(next(gen))
print(next(gen))
- A.
10 - B.
32 - C.
31 - D.
21
4. (★★) list((x for x in range(5))) 的结果是?
- A.
(0, 1, 2, 3, 4) - B.
[0, 1, 2, 3, 4] - C.
0 - D.
generator object
5. (★★ 多选) 关于生成器,下列说法正确的是?
- A. 生成器是惰性求值,创建时不执行
- B. 生成器只能遍历一次
- C. 生成器可以表示无限序列
- D. 生成器表达式用小括号
(x for x in ...)
二、判断题
1. (★) 生成器表达式 (x * 2 for x in range(100)) 比列表推导式 [x * 2 for x in range(100)] 更省内存。( )
2. (★★) 用 next() 取完生成器的最后一个值后,再取一次会报 StopIteration。( )
3. (★★) 生成器可以像列表一样用 len(gen) 求长度。( )
4. (★★) 生成器只能往前取,不能回头取已经取过的值。( )
三、代码纠错题
1. (★★) 下面的代码想用生成器输出 1~5,但输出不对,请指出问题:
def one_to_five():
for i in range(1, 6):
yield i
gen = one_to_five()
print(next(gen))
print(next(gen))
print(list(gen))
2. (★★) 下面的代码想一次拿到全部生成器值并排序,但报错了,请指出问题并改正:
gen = (x for x in [3, 1, 2])
result = gen.sort() # ❌ 报错
print(result)
四、编程实战题
1. (基础 ★) 用生成器写一个 even_numbers(limit),产出从 0 开始到 limit 的偶数。测试打印前几个。
2. (基础 ★★) 写一个 my_range(stop),用 while + yield 模拟 range(stop) 的行为(从 0 到 stop-1)。
3. (基础 ★★) 用生成器写一个 square_gen(nums):接收一个数字列表,逐个产出它们的平方。测试 list(square_gen([1, 2, 3, 4])) 得到 [1, 4, 9, 16]。
4. (挑战 ★★★) 用生成器写一个"带步长的 range":my_range(start, stop, step),用 yield 逐步产出,不占内存。测试 list(my_range(1, 10, 2)) 得到 [1, 3, 5, 7, 9]。
【参考答案与解析】
一、选择题
1. 答案:B
next() 一次只取出一个元素,取完报 StopIteration。
2. 答案:B
生成器的灵魂:yield 暂停并记住状态,下次接着执行。
3. 答案:B
count_down(3) 第一次 next 产出 3,n 变 2;第二次 next 从暂停处继续,产出 2。
4. 答案:B
list() 把生成器"榨干",得到 [0, 1, 2, 3, 4]。
5. 答案:A、B、C、D
A 对:惰性;B 对:一次性;C 对:while True + yield 表示无限序列;D 对:小括号是生成器表达式。
二、判断题
1. 正确(√)。生成器惰性求值,不占内存;列表全算出来存着。
2. 正确(√)。取完再 next() 抛 StopIteration。
3. 错误(×)。生成器没有长度,len(gen) 报 TypeError。
4. 正确(√)。迭代器只能往前,不能回头。
三、代码纠错题
1. 解析: 代码本身没 bug,但要注意生成器是一次性的:前面 next(gen) 两次取走了 1、2,后面 list(gen) 只能拿到剩下的 [3, 4, 5],而不是 [1, 2, 3, 4, 5]。如果想拿到全部,别提前 next,直接 list(gen):
def one_to_five():
for i in range(1, 6):
yield i
gen = one_to_five()
print(list(gen)) # [1, 2, 3, 4, 5]
2. 解析: 生成器没有 .sort() 方法(它不是列表),所以报 AttributeError。改正:先 list(gen) 转成列表,再排序:
gen = (x for x in [3, 1, 2])
lst = list(gen) # 先"榨干"成列表
lst.sort()
print(lst) # [1, 2, 3]
核心: 生成器只有 next() 和 for 两种用法;要排序、下标、求长度,先 list() 转回列表。
四、编程实战题
1. 参考代码:
def even_numbers(limit):
for i in range(0, limit + 1):
if i % 2 == 0:
yield i
gen = even_numbers(10)
print(next(gen)) # 0
print(next(gen)) # 2
print(next(gen)) # 4
2. 参考代码:
def my_range(stop):
i = 0
while i < stop:
yield i
i += 1
print(list(my_range(5))) # [0, 1, 2, 3, 4]
3. 参考代码:
def square_gen(nums):
for n in nums:
yield n * n
print(list(square_gen([1, 2, 3, 4]))) # [1, 4, 9, 16]
4. 参考代码:
def my_range(start, stop, step):
i = start
while i < stop:
yield i
i += step
print(list(my_range(1, 10, 2))) # [1, 3, 5, 7, 9]
print(list(my_range(0, 5, 1))) # [0, 1, 2, 3, 4]
🐍"皮皮注:到这里,你的函数已经学会'按需吐货'了。下一章,给函数'穿外套'——装饰器,在不动原函数的前提下,给函数加 Buff(计时、鉴权、日志)!"
📖 下一章,给函数穿外套:装饰器入门。