进阶修炼与毕业 · 进阶与毕业

第26章 按需生产

迭代器与生成器

第 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,再暂停……

和普通函数的区别(重点):

证据: 上面的 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) 内存。


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 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() 的职责是?

2. (★★) 生成器和普通函数的关键区别是?

3. (★★) 下面代码输出什么?

def count_down(n):
    while n > 0:
        yield n
        n -= 1

gen = count_down(3)
print(next(gen))
print(next(gen))

4. (★★) list((x for x in range(5))) 的结果是?

5. (★★ 多选) 关于生成器,下列说法正确的是?

二、判断题

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(计时、鉴权、日志)!"


📖 下一章,给函数穿外套:装饰器入门。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)