迭代器与生成器

0. 本讲导读

到目前为止，你处理「一堆值」的方式只有一种：先把它们全部装进一个列表，再遍历这个列表。list_partitions(6, 4) 会先算出全部 9 个分法、拼成一个二维列表，然后你才能看第一个。写树的递归时也一样：count_paths 先把所有路径数完，才返回一个数。

这套做法有两个躲不开的代价。

第一，你必须付出全部计算，哪怕只想要第一个结果。list_partitions(60, 50) 有 966370 个分法，在我的机器上要跑将近 3 秒、并且把这 96 万个字符串同时留在内存里——而如果你只是想看看前 3 个长什么样，这 3 秒和这块内存全都白花了。

第二，有些序列根本装不进列表。「所有偶数」「斐波那契数列的每一项」「一个不断产生随机数的流」，它们没有末尾，list() 会一直跑到内存耗尽。

本讲给出的解决办法，是把「一串值」这件事拆成两层：

• 可迭代对象（iterable）——「这里有一串值」。列表、元组、字符串、字典、range 都是。
• 迭代器（iterator）——「我读到第几个了」。它是一个独立的对象，同时记着「值从哪来」和「当前位置」，你每次向它要一个值，它才去算/取一个值。

把位置信息独立成一个对象，序列就不必真的存在于内存里了：只要有人能回答「下一个是什么」，就够了。生成器（generator）正是让你用写函数的方式来回答这个问题——把 return 换成 yield，一个普通函数就变成了一台「按需产值的机器」，而且它能递归。本讲最后那个 yield_partitions 只有 6 行，却能在 0 秒内吐出 60 = 10 + 50 这第一个分法，而列表版要跑 3 秒。

与前后讲的关系：上一讲讲树（tree）的递归，本讲末尾的 yield_paths 就是把上一讲的 count_paths 从「数出来」改成「一条条吐出来」——递归的骨架一模一样，只是返回方式变了。下一讲讲异常（exception）II，而 StopIteration 正是本讲会反复见到的一个异常，两讲直接接得上。教材对应 §4.2 Implicit Sequences，作业是 Lab 05 与 HW 04。

1. 复习：for 循环里到底放了什么

本讲要拆开 for 循环的内部机制，所以先把你已经会用的两件事摆出来，等下好对照。

字典可以直接放进 for 循环

你已经知道用 .keys()、.values()、.items() 遍历字典。其实字典本身就能直接进 for，此时遍历的是键：

>>> roman_numerals = {'I': 1, 'V': 5, 'X': 10}
>>> for key in roman_numerals:
...     print(key)
...
I
V
X

也就是说 for key in d 和 for key in d.keys() 效果相同。这件小事在本讲的意义是：「能放进 for 循环」是一种资格，字典有、列表有、字符串有、range 有，而它们内部的存储方式完全不同（字典是哈希表，range 连元素都不存）。既然存储方式各不相同，for 却能一视同仁地遍历它们，说明 for 依赖的不是「存储方式」，而是某个统一的接口。这个接口就是本讲的主角。

>>> for k in roman_numerals:
...     roman_numerals['L'] = 50
...
Traceback (most recent call last):
  ...
RuntimeError: dictionary changed size during iteration

树的遍历顺序：同样三行代码，位置一换结果全变

上一讲的树 ADT 继续沿用（本讲的随堂代码里原样带着它）：

def tree(root_label, branches=[]):
    for branch in branches:
        assert is_tree(branch), 'branches must be trees'
    return [root_label] + list(branches)

def label(tree):
    return tree[0]

def branches(tree):
    return tree[1:]

def is_leaf(tree):
    return not branches(tree)

下面三个函数长得几乎一样，只差 print 放在哪儿。用同一棵树 t = tree(3, [tree(-1), tree(1, [tree(2, [tree(1)]), tree(3)]), tree(1, [tree(-1)])]) 跑一遍：

print(label(tree))
for b in branches(tree):
    print_treeA(b)

for b in branches(tree):
    print(label(tree))
    print_treeB(b)

for b in branches(tree):
    print_treeC(b)
print(label(tree))

这张表值得盯久一点，因为本讲后半段所有生成器递归都建立在同一个直觉上：「在递归调用之前做事」和「在递归调用之后做事」，产生的顺序完全不同。等下把 print 换成 yield，这个直觉一字不改地继续成立——只不过结果不再是打到屏幕上，而是被一个个「让」给调用方。

2. iterable 与 iterator：书和书签

两个定义，先记住字面意思，再看为什么要分开。

• 可迭代对象（iterable）：任何能被顺序处理的对象。换句话说，能放进 for 循环的就是 iterable。例：列表、元组、字典、字符串、range。
• 迭代器（iterator）：提供对某个 iterable 的元素的按序访问。
  • 对 iterable 调用 iter 就能造出一个 iterator。
  • 对 iterator 调用 next 就能取到下一个元素。

课堂上用的比喻很到位：iterable 是书，iterator 是书签。书本身没有「读到哪儿」这个概念，书里的字是死的、可以被很多人同时读；书签才知道位置。同一本书可以夹很多个书签，各自独立地往前走。

>>> lst = [1, 2, 3]        # iterable：一本书
>>> tracker = iter(lst)    # iterator：夹进去的一个书签
>>> next(tracker)
1
>>> next(tracker)
2
>>> next(tracker)
3
>>> next(tracker)
Traceback (most recent call last):
  ...
StopIteration

Global frame
    lst      ──→ [1, 2, 3]        ← 列表对象（无位置）
    tracker  ──→ list_iterator    ← 迭代器对象
                     .source ──→ 同一个 [1, 2, 3]（不是副本）
                     .index  ──→ 0 → 1 → 2 → 3   随每次 next 递增

next(tracker) 第 4 次：.index == 3 已越界 → raise StopIteration

这里的 .source / .index 是我为了讲清楚起的名字，CPython 内部字段不叫这个，你在 Python 里访问不到它们（tracker.index 会报 AttributeError）。但「一个引用 + 一个位置」这个心智模型是准确的。

for 循环其实就是 iter + next + 捕获 StopIteration

现在可以回答第 1 节留下的问题了。for x in lst: ... 这行代码，Python 做的是：

所以 for 从来没有假设过被遍历的东西「是列表」「有 len」「能用下标访问」。它只需要对方能交出一个会 next 的书签。字典、range、文件对象长得千差万别，却都能进 for，原因就在这儿。这也解释了为什么第 1 节的字典能直接遍历：字典的 iter 交出的书签，走的是键。

>>> next([1, 2, 3])
Traceback (most recent call last):
  ...
TypeError: 'list' object is not an iterator

>>> iter(5)
Traceback (most recent call last):
  ...
TypeError: 'int' object is not iterable

>>> t = iter([1, 2, 3])
>>> len(t)
Traceback (most recent call last):
  ...
TypeError: object of type 'list_iterator' has no len()
>>> t[0]
Traceback (most recent call last):
  ...
TypeError: 'list_iterator' object is not subscriptable

3. 书被改了，书签会怎样

第 2 节强调过：iter(lst) 没有复制 lst。迭代器只是记着「那本书在哪儿」。所以如果有人在你读的过程中改了这本书，你的书签会读到改过之后的内容。课堂上的第二个例子专门演示这件事，它比看上去烧脑：

>>> lst = [1, 3, 2, 7]
>>> iter1 = iter(lst)
>>> next(iter1)
1
>>> lst.append(5)
>>> next(iter1)
3
>>> iter2 = iter(lst)
>>> next(iter2)
1
>>> lst[1] = -10
>>> next(iter2)
-10

时刻          lst 的内容              iter1.index   iter2.index
─────────────────────────────────────────────────────────────
初始          [1, 3, 2, 7]                0           （不存在）
next(iter1)   [1, 3, 2, 7]                1           （不存在）
append(5)     [1, 3, 2, 7, 5]             1           （不存在）
next(iter1)   [1, 3, 2, 7, 5]             2           （不存在）
iter(lst)     [1, 3, 2, 7, 5]             2                0
next(iter2)   [1, 3, 2, 7, 5]             2                1
lst[1] = -10  [1, -10, 2, 7, 5]           2                1
next(iter2)   [1, -10, 2, 7, 5]           2                2   → 返回 -10

>>> c = iter([1, 2, 3, 4])
>>> next(c)
1
>>> list(c)
[2, 3, 4]
>>> list(c)
[]

4. iterator vs iterable：包含关系与「为什么要多这一层」

初学者最容易糊涂的一句话：所有 iterator 都是 iterable，但不是所有 iterable 都是 iterator。

为什么迭代器也算 iterable？因为它满足 iterable 的定义：能放进 for 循环。第 3 节最后 list(c) 那个例子已经证明了这一点——list 内部就是在遍历它。

那对一个已经是迭代器的对象调 iter 会怎样？

>>> a = iter([1, 2, 3])
>>> iter(a) is a
True

返回的就是原对象本身，不是新书签。这条规则看起来是个技术细节，其实很关键：正因为 iter(iterator) 返回自己，第 2 节里 for 的第 2 步（无条件先调一次 iter）才能对迭代器同样适用——for x in some_iterator 不会莫名其妙地从头开始，而是从当前位置继续。

为什么要多这一层？

如果只是想遍历列表，for x in lst 就够了，凭什么还要 iter / next？课上给了三条理由，每一条都值得展开。

理由一：迭代器是加在 iterable 之上的一层抽象（abstraction）。 用迭代器写的代码，对「值是从哪儿来的」不做任何假设：可能来自列表，可能来自文件的每一行，可能来自网络，也可能是现算出来的（第 6 节的生成器）。只要对方能 next，你的代码就能用。于是提供数据的一方可以随时改内部实现——把列表换成数据库查询——而下游代码一行都不用改。这正是这门课反复强调的「用接口隔离实现」，只不过换了个场景。

理由二：迭代器把「元素」和「位置」打包进同一个对象。 这意味着位置可以被传递。看这段代码：

>>> def take_two(it):
...     return [next(it), next(it)]
...
>>> t = iter([10, 20, 30, 40, 50])
>>> take_two(t)
[10, 20]
>>> take_two(t)
[30, 40]
>>> next(t)
50

两次调用 take_two，第二次自动从 30 接着来——因为「读到哪儿了」这个信息装在 t 里，跟着参数一起传进了函数。如果传的是列表，take_two 就必须额外接一个「起始下标」参数，还得想办法把新下标传回来。迭代器让「进度」变成一个可以传参的值。

由此还派生出一个很实用的保证：每个元素只会被处理一次。多个函数轮流从同一个迭代器取值，谁也不会重复处理别人已经处理过的元素。

理由三：迭代器阻止你改动原始的 iterable。 拿到一个迭代器，你能做的只有 next——没有 append、没有下标赋值。把迭代器而不是列表交给别人，就等于说「你只能读，不能改」。（当然，第 3 节说过，如果别人手上另有那个列表的引用，他照样能改；迭代器保护的是通过它本身发起的修改。）

5. 内置的惰性函数：map、filter、zip、reversed

Python 有一批内置函数，它们的返回值不是列表，而是迭代器，并且惰性（lazily）计算——需要一个值的时候才算一个，而不是一上来把全部结果算完。

它们全都是迭代器，所以第 3、4 节讲的规矩一条不落地适用：一次性、不能 len、不能下标。

>>> map(abs, [-1, 2, -3])
<map object at 0x7ec7e9593ee0>
>>> list(map(abs, [-1, 2, -3]))
[1, 2, 3]

直接在交互式解释器里敲 map(...)，看到的是 <map object at 0x...> 而不是结果——这几乎是每个人第一次用 map 时的困惑。它不是出错了，是这个对象还没开始算。

zip 的长度规则

>>> list(zip([1, 2], [3, 4]))
[(1, 3), (2, 4)]
>>> list(zip([1, 2], [3, 4, 5], [6, 7]))
[(1, 3, 6), (2, 4, 7)]

第二个例子里第二个列表有 3 个元素，但结果只有 2 个元组：zip 在最短的那个 iterable 用完时就停，多出来的 5 被丢掉。这个「以最短为准」的规则等下做 palindrome 时会用上。

把迭代器变回能看的东西

想看完整内容，就把元素倒进一个容器：

注意这三个都会把迭代器抽干：它们必须看到每一个元素才能完成工作（sorted 甚至必须看完全部才能排序）。所以一旦 list(t) 过一次，t 就空了。

惰性到底惰到什么程度

课上这个例子是本节的核心，把它一步一步看完，你对「惰性」的理解就到位了。

>>> def double(x):
...     print(f'** {x} => {2 * x} **')
...     return 2 * x
...
>>> f = lambda x: x >= 10
>>> t = filter(f, map(double, range(3, 7)))
>>> next(t)
** 3 => 6 **
** 4 => 8 **
** 5 => 10 **
10

继续往下要：

>>> next(t)
** 6 => 12 **
12
>>> list(t)
[]

>>> s = [-4, -3, -2, 3, 2, 4]
>>> mp = map(abs, s)
>>> min(mp)
2
>>> list(mp)          # 想再看看都有哪些绝对值
[]

>>> reversed(map(abs, [1, -2]))
Traceback (most recent call last):
  ...
TypeError: 'map' object is not reversible
>>> reversed(iter([1, 2, 3]))
Traceback (most recent call last):
  ...
TypeError: 'list_iterator' object is not reversible

6. 生成器：用写函数的方式造迭代器

map 和 filter 好用，但它们能表达的模式很窄——「每个都变换一下」「筛掉一些」。如果我想要的序列是「先 x 再 -x」，或者「树里所有和为 total 的路径」，怎么办？

手写一个迭代器类是可以的（那要等学完面向对象），但 Python 给了一条捷径：把 return 换成 yield，函数就变成了迭代器。

• 生成器函数（generator function）：函数体里出现了 yield 的函数。
• 生成器对象（generator object）：调用生成器函数得到的返回值。可以对它调 next，按顺序拿到被 yield 出来的值。

>>> def plus_minus(x):
...     yield x
...     yield -x
...
>>> plus_minus(5)
<generator object plus_minus at 0x78d032746420>
>>> gen = plus_minus(5)
>>> next(gen)
5
>>> next(gen)
-5
>>> next(gen)
Traceback (most recent call last):
  ...
StopIteration

先看第一行输出：plus_minus(5) 的值不是 5，也不是 -5，而是一个生成器对象。这说明调用生成器函数时发生的事，跟调用普通函数完全不同。

调用生成器函数时，函数体一行都不执行

这是本节最反直觉、也最重要的一点。用带副作用的例子来验证：

>>> def noisy():
...     print('start')
...     yield 1
...     print('middle')
...     yield 2
...     print('end')
...
>>> h = noisy()
>>> # 什么都没打印！
>>> next(h)
start
1
>>> next(h)
middle
2
>>> next(h)
end
Traceback (most recent call last):
  ...
StopIteration

h = noisy()
  ┌─ 创建帧 f1: noisy [parent=Global]，但立刻挂起 ─┐
  │   局部变量：（无）                              │
  │   下一条待执行：print('start')                  │
  └────────────────────────────────────────────────┘
  Global frame: h ──→ generator object（内部持有上面这一帧）

next(h) 第 1 次：恢复 f1 → print('start') → 到 yield 1
  f1 冻结，下一条待执行 = print('middle')；返回值 1 交给调用方

next(h) 第 2 次：恢复 f1 → print('middle') → 到 yield 2
  f1 冻结，下一条待执行 = print('end')；返回值 2 交给调用方

next(h) 第 3 次：恢复 f1 → print('end') → 函数体结束
  f1 销毁 → raise StopIteration

对比一下你熟悉的普通函数：普通函数的帧在 return 时就消失了，局部变量随之作废；生成器的帧则在 yield 处存活着被冻起来，等下一次 next 把它唤醒。「函数可以暂停并保留现场」是生成器唯一的新东西，其余全是它的推论。

既然生成器对象是迭代器，第 4 节那条规则也适用：

>>> g = plus_minus(5)
>>> iter(g) is g
True
>>> list(plus_minus(5))
[5, -5]
>>> for v in plus_minus(5):
...     print(v)
...
5
-5

>>> next(plus_minus)
Traceback (most recent call last):
  ...
TypeError: 'function' object is not an iterator

>>> def f():
...     print('side effect')
...     yield 1
...
>>> f()
<generator object f at 0x...>

>>> def g2():
...     yield 1
...     return 99
...
>>> list(g2())
[1]

    yield 5
    ^^^^^^^
SyntaxError: 'yield' outside function

7. 无限生成器：列表做不到的事

生成器最能体现价值的地方，是表示没有尽头的序列。因为它每次只算一个值，「总共有多少个」根本不影响它能不能被创建。

>>> def evens():
...     i = 0
...     while True:
...         yield i
...         i += 2
...
>>> gen = evens()
>>> next(gen)
0
>>> next(gen)
2

while True 在普通函数里是死循环，是 bug；在生成器里它是特性。原因就是第 6 节那条：yield 会把帧冻住，控制权交回调用方。循环是被「暂停」的，不是在空转。

f1: evens [parent=Global]   （被 gen 这个生成器对象持有）

  next 第 1 次结束时：  i ──→ 0    暂停在 yield i
  next 第 2 次结束时：  i ──→ 2    暂停在 yield i
  next 第 3 次结束时：  i ──→ 4    暂停在 yield i
  ...

对比普通函数：每次调用都是一个全新的帧，i 每次都从头开始。

>>> gen = evens()
>>> list(gen)
（无限循环，程序卡死；Ctrl+C 打断会看到 KeyboardInterrupt，
 放任不管则最终 MemoryError）

>>> gen = evens()
>>> [next(gen) for _ in range(5)]
[0, 2, 4, 6, 8]

8. yield from：把一整串值转手让出去

经常会遇到这种需求：我这个生成器要产出的值，一部分来自另一个 iterable。比如「先把 a 里的元素全给出去，再把 b 里的全给出去」：

def a_then_b(a, b):
    for x in a:
        yield x
    for x in b:
        yield x

这段代码没错，但 for x in a: yield x 这个模式太常见了，Python 给了专门的语法：

def a_then_b(a, b):
    yield from a
    yield from b

>>> list(a_then_b([1, 2], [3, 4]))
[1, 2, 3, 4]

yield from <iterable> 的意思是：把这个 iterable 里的元素一个一个地 yield 出去，直到它耗尽。它不是「yield 一个 iterable」——这个区别下面就要吃它的亏。

递归生成器

课上说得明白：用 yield from 的一个常见理由，就是递归地调用生成器函数。 看这个倒计时：

def countdown(k):
    if k > 0:
        yield k
        yield from countdown(k - 1)
    else:
        yield 'Blastoff!'

>>> list(countdown(3))
[3, 2, 1, 'Blastoff!']

这个结构和上一讲所有树递归、和第 1 节的 print_treeA 是同一个骨架：先处理自己（yield k），再把「更小的同类问题」的全部结果转手让出去（yield from countdown(k - 1)）。把它真的展开一层层看：

list  ← 'Blastoff!'
 └─ G3: countdown  k=3   暂停在 yield from countdown(k-1)
     └─ G2: countdown  k=2   暂停在 yield from countdown(k-1)
         └─ G1: countdown  k=1   暂停在 yield from countdown(k-1)
             └─ G0: countdown  k=0   暂停在 yield 'Blastoff!'

每一层的 k 都独立保存在自己的帧里，互不干扰。
一个值要从 G0 传到 list，得穿过三层 yield from。

忘了 from 会怎样

def countdown(k):
    if k > 0:
        yield k
        yield countdown(k - 1)      # 少了一个 from
    else:
        yield 'Blastoff!'

>>> list(countdown(3))
[3, <generator object countdown at 0x7f7b63b46420>]

9. 三个同心圆：iterable、iterator、generator

三个名词到这儿全都出场了，把关系一次理清。

用一句话串起来：iterable 是「有一串值」这个资格；iterator 在此之上加了「记着读到哪儿」；generator 则是「用一段暂停/恢复的函数体来现算这一串值」的迭代器。 每往里一层，能力更强，但也更「一次性」。

10. 案例研究：从 count_partitions 到 yield_partitions

这一节把整讲的东西合起来用一次。题目是 Lecture 06 见过的整数分拆（partition）：把正整数 n 写成若干个不超过 m 的正整数之和，各部分按递增顺序排列，问有多少种写法。n = 6, m = 4 时有 9 种：

6 = 2 + 4        6 = 1 + 1 + 4      6 = 3 + 3
6 = 1 + 2 + 3    6 = 1 + 1 + 1 + 3  6 = 2 + 2 + 2
6 = 1 + 1 + 2 + 2                   6 = 1 + 1 + 1 + 1 + 2
6 = 1 + 1 + 1 + 1 + 1 + 1

第一步：原始的计数版本

def count_partitions_original(n, m):
    if n == 0:
        return 1
    elif n < 0:
        return 0
    elif m == 0:
        return 0
    else:
        with_m = count_partitions_original(n - m, m)
        without_m = count_partitions_original(n, m - 1)
        return with_m + without_m

核心的拆分思路是对「最大的那部分用不用 m」做二分：要么这个分法里至少用一次 m（剩下要凑 n - m，还能继续用 m），要么完全不用 m（凑 n，但只能用到 m - 1）。两类不重不漏，加起来就是全部。

第二步：合并 base case，为改写做准备

随堂代码给了一个等价的简化版，它把「n < 0」和「m == 0」并成一个失败出口，并把「n == 0」这个成功出口挪进 else：

def count_partitions_simplified(n, m):
    if n < 0 or m == 0:
        return 0
    else:
        exact_match = 0
        if n == m:
            exact_match = 1
        with_m = count_partitions_simplified(n - m, m)
        without_m = count_partitions_simplified(n, m - 1)
        return exact_match + with_m + without_m

为什么这么改？因为 n == 0 那个 base case 的含义是「刚好凑满了，算一种分法」，但它不知道自己是怎么凑满的——返回 1 就完了。等下我们要返回的不是数量而是分法本身，就必须在还知道最后一块是什么的时候记下来。n == m 正是那个时刻：还剩 n 要凑，而允许的最大部分恰好是 m == n，那就直接用一块 m 填满，这是一种分法。

第三步：返回列表而不是数量

把每个 return <数> 换成 return <列表>，加法换成列表拼接：

def list_partitions(n, m):
    if n < 0 or m == 0:
        return []
    else:
        exact_match = []
        if n == m:
            exact_match = [[m]]
        with_m = [p + [m] for p in list_partitions(n - m, m)]
        without_m = list_partitions(n, m - 1)
        return exact_match + with_m + without_m

随堂代码里还有一个 list_partitions_str，除了把 p + [m] 换成 f"{p} + {m}"、把 [[m]] 换成 [str(m)]，其余一模一样，输出形如 '1 + 2 + 3'。

第四步：改成生成器

列表版有个硬伤：它必须把全部分法算完才返回。list_partitions(60, 50) 要生成 966370 个分法，在我的机器上要跑约 3 秒，而且这 96 万个结果同时占着内存。生成器版可以边算边给：

def yield_partitions(n, m):
    if n > 0 and m > 0:
        if n == m:
            yield str(m)
        for p in yield_partitions(n - m, m):
            yield f"{p} + {m}"
        yield from yield_partitions(n, m - 1)

逐行对照列表版：

>>> gen = yield_partitions(6, 4)
>>> next(gen)
'2 + 4'
>>> next(gen)
'1 + 1 + 4'
>>> list(yield_partitions(6, 4))
['2 + 4', '1 + 1 + 4', '3 + 3', '1 + 2 + 3', '1 + 1 + 1 + 3', '2 + 2 + 2', '1 + 1 + 2 + 2', '1 + 1 + 1 + 1 + 2', '1 + 1 + 1 + 1 + 1 + 1']

9 个，和计数版的答案对上了。

惰性到底快多少

>>> s = list(yield_partitions(60, 50))   # 要等几秒
>>> len(s)
966370
>>> gen = yield_partitions(60, 50)       # 瞬间完成
>>> next(gen)
'10 + 50'
>>> next(gen)
'1 + 9 + 50'

两种写法算的是同一件事，差别只在什么时候算。list(...) 把 966370 个分法全算出来（约 3 秒），只为了让你看第一个；next(gen) 只做了「找出第一个分法」所必需的那几十次递归调用，感觉不到耗时。如果你的程序只需要前几个结果、或者会在中途 break，生成器版省下的就是几乎全部的计算。

11. 随堂练习：palindrome 与 min_abs_indices

起始代码是课程网站 Lecture 10 下的 10.py，用 python3 -m doctest 10.py 跑测试（没有输出就是全过）。

palindrome：判断回文

def palindrome(s) -> bool:
    """
    Return `True` if a sequence `s` is the same forward and backward
    (e.g. if `s` is a palindrome), or `False` otherwise.

    >>> palindrome([3, 1, 4, 1, 5])
    False
    >>> palindrome([3, 1, 4, 1, 3])
    True
    >>> palindrome('seveneves')
    True
    >>> palindrome('seven eves')
    False
    """

题目要什么。 判断序列正着读和倒着读是否一样。注意 doctest 里既有列表又有字符串，所以实现不能只对其中一种奏效。最后一个例子 'seven eves' 说明空格算一个字符——不要自作聪明去掉空格。

怎么想到的。 直觉是「把 s 倒过来，和 s 比一比」。倒过来用 reversed(s)。于是第一版：

return reversed(s) == s        # 错的

拿 'aba' 试一下，得到 False——明明是回文。原因是 reversed(s) 返回的是一个迭代器对象，拿一个迭代器去和字符串比较，比的是「这两个是不是同一个对象」，永远是 False。第 5 节强调过：惰性函数的返回值不是你想要的那串值，必须先落进容器。改成：

return list(reversed(s)) == list(s)

两边都套 list，把类型统一成列表再比。右边的 list(s) 不能省：s 是字符串时，list(reversed('aba')) 是 ['a', 'b', 'a']，而 'aba' 是字符串，两者永不相等。

第二种写法（用 zip）。 挑战要求用 zip 和 reversed。思路换成「逐位对比」：把正序和倒序配对，如果每一对的两个元素都相等，就是回文。

return all([a == b for a, b in zip(s, reversed(s))])

这个写法其实做了双倍的比较——第 i 位和倒数第 i 位比了两次。但它对，而且很直观。

min_abs_indices：找出绝对值最小的所有下标

def min_abs_indices(s) -> list[int]:
    """
    Returns a list of all indices of elements in s
    whose absolute value is equal to the minimum absolute value of s.

    >>> min_abs_indices([-4, -3, -2, 3, 2, 4])
    [2, 4]
    >>> min_abs_indices([1, 2, 3, 4, 5])
    [0]
    """

题目要什么。 先算出 s 中所有元素绝对值的最小值，再返回所有绝对值等于它的元素的下标。两个容易读漏的点：返回的是下标不是元素值；可能有多个（第一个 doctest 里 -2 和 2 绝对值都是 2，下标 2 和 4 都要）。

怎么想到的。 拆成两步就清楚了：

第 2 步如果直接 for x in s，你会拿到元素却不知道它在第几位，只能再想办法找回下标——那是弯路。要什么就遍历什么。

def min_abs_indices(s):
    min_abs = min(map(abs, s))
    return [i for i in range(len(s)) if abs(s[i]) == min_abs]

第二种写法（不用列表推导式）。 挑战要求只用迭代内置函数。「从一堆候选里挑出满足条件的」就是 filter；候选是所有下标，即 range(len(s))：

def min_abs_indices(s):
    min_abs = min(map(abs, s))
    f = lambda i: abs(s[i]) == min_abs
    return list(filter(f, range(len(s))))

两点值得注意：f 是一个闭包，它用到了外层的 s 和 min_abs——这是第 3 讲高阶函数的老本行，只是这次被 filter 调用；末尾的 list(...) 不能省，因为 filter 返回的是迭代器，而 doctest 期望的输出是 [2, 4]，不是 <filter object at 0x...>。

abs_vals = map(abs, s)
min_abs = min(abs_vals)
return [i for i in range(len(s)) if abs_vals[i] == min_abs]

12. 随堂练习：yield_paths（递归生成器）

def yield_paths(t, total):
    """
    Yield each path from the root node to any other node in the tree
    that adds up to the target total.
    >>> t = tree(3, [tree(-1), tree(1, [tree(2, [tree(1)]), tree(3)]), tree(1, [tree(-1)])])
    >>> list(yield_paths(t, 3))  # path does not have to go to a leaf
    [[3], [3, 1, -1]]
    >>> list(yield_paths(t, 4))
    [[3, 1], [3, 1]]
    >>> list(yield_paths(t, 5))
    []
    >>> list(yield_paths(t, 6))
    [[3, 1, 2]]
    >>> list(yield_paths(t, 7))
    [[3, 1, 2, 1], [3, 1, 3]]
    """

题目要什么。 三个关键点全藏在 doctest 里：

• list(yield_paths(t, 3)) 的结果里有 [3]——只含根节点的路径也算，而且那句注释明说了 path does not have to go to a leaf，路径可以在任何节点停下。
• list(yield_paths(t, 4)) 得到 [[3, 1], [3, 1]]——两条一模一样的路径。因为根有两个标签为 1 的孩子，它们是不同的节点，各算一条。所以不能去重。
• list(yield_paths(t, 5)) 是 []——一条都没有时，什么都不 yield，list 得到空列表。生成器天然支持这个，不需要特判。

怎么想到的。 提示说「参考上一讲 count_paths」。那个函数是数有多少条和为 total 的路径：

def count_paths(t, total):
    if label(t) == total:
        found = 1
    else:
        found = 0
    return found + sum([count_paths(b, total - label(t)) for b in branches(t)])

它的递归结构是：当前节点自己算不算一条（label(t) == total），加上每个分支里、目标减去当前标签之后还有多少条。第 10 节刚练过同一套改造手法——把「数量」换成「东西本身」：

剩下要想明白的只有一件事：为什么目标是 total - label(t)？ 因为路径必须从根出发，所以当前节点的标签是一定会被算进去的。既然它已经贡献了 label(t)，那么子树里的那一段就只需要凑出 total - label(t)。

def yield_paths(t, total):
    if label(t) == total:
        yield [label(t)]

    for b in branches(t):
        for path in yield_paths(b, total - label(t)):
            yield [label(t)] + path

代码逐行讲

验证：完整展开 yield_paths(t, 3)

再看 total = 4 为什么会出现两条相同的 [3, 1]：顶层 3 == 4？否，不产出。三个分支的新目标都是 4 - 3 = 1。第一个分支标签 -1 != 1，无；第二个分支标签 1 == 1 ✓ 产出 [1]，回代成 [3, 1]；第三个分支标签也是 1 == 1 ✓ 产出 [1]，回代成另一个 [3, 1]。两条路径走的是不同的边，只是标签恰好相同——所以结果里有两个 [3, 1]，这不是 bug。

本讲小结

三个圈速记

iterable  ⊇  iterator  ⊇  generator object

能进 for  ─────────────────────────────→  三者都能
能 next   ────────────  iterator 起才能  ─→
iter(x)   ──  新书签  ──  返回 x 自己  ──→  返回 x 自己
遍历几次  ──  无限次  ──     一次      ──→      一次

一段代码里最该问自己的三个问题

动手练习

练习 1：这段代码打印什么

>>> s = [1, 2, 3, 4]
>>> t = iter(s)
>>> next(t)
>>> u = iter(s)
>>> next(u)
>>> s[1] = 20
>>> next(t)
>>> list(u)
>>> list(t)

练习 2：惰性的代价

下面这段代码运行后，屏幕上打印了几行 calling？result 是什么？

def f(x):
    print('calling')
    return x * x

nums = map(f, [1, 2, 3])
result = [n for n in nums if n > 100]
total = sum(nums)

练习 3：生成器执行顺序

def g():
    print('A')
    yield 1
    print('B')
    yield 2

gen = g()
print('C')
for x in gen:
    print(x)

练习 4：写一个生成器

实现 evens_up_to(n)，按从小到大的顺序 yield 出 0 到 n（含 n）之间的所有偶数。list(evens_up_to(7)) 应得 [0, 2, 4, 6]，list(evens_up_to(0)) 应得 [0]，list(evens_up_to(-1)) 应得 []。再用它写一个 evens_then_odds(n)：先 yield 所有偶数，再 yield 所有奇数。

def evens_up_to(n):
    i = 0
    while i <= n:
        yield i
        i += 2

def odds_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 2

def evens_then_odds(n):
    yield from evens_up_to(n)
    yield from odds_up_to(n)

练习 5：改写成生成器

下面这个函数返回一棵树里所有叶子的标签组成的列表。把它改写成生成器 yield_leaves(t)，使 list(yield_leaves(t)) 得到同样的结果。

def leaf_labels(t):
    if is_leaf(t):
        return [label(t)]
    result = []
    for b in branches(t):
        result = result + leaf_labels(b)
    return result

def yield_leaves(t):
    if is_leaf(t):
        yield label(t)
    for b in branches(t):
        yield from yield_leaves(b)

练习 6：判断对错

下面每句话对不对？

1. iter(iter([1, 2, 3])) 会返回一个全新的迭代器。
2. 一个生成器对象可以放进 for 循环。
3. len(map(abs, [-1, 2])) 返回 2。
4. 生成器函数里必须至少有一个 yield。
5. list(filter(lambda x: x > 0, iter([1, -2, 3]))) 返回 [1, 3]。