期中复习：把前十一讲拆开的零件重新装回去

0. 本讲导读

这一讲没有新概念。它只做一件事：把 Lecture 01 到 Lecture 11 学过的零件，放进四道真实的往年考题里，看它们怎么互相咬合。

这件事比听起来重要。你现在的状态多半是这样的：单独问「什么是生成器」你答得出，单独问「树递归怎么写」你也答得出，但拿到一道题——它既不说「这是生成器题」，也不说「这里要用树递归」——你就卡在第一行不知道该写什么。考试考的正是这一步：从题面到「该用哪个零件」的那次跳跃。

所以本讲的读法和前十一讲完全不同。前面的笔记你可以顺着读；这一份，每道题的题面给出来之后，请你先合上笔记自己写一遍，写完再看后面的推演。看懂别人的解法几乎没有收益，卡住之后再看解法才有。

本讲的四道题分别来自：

在四道题之前，本讲还有两块内容值得单独讲：一是对 Lecture 11 的更正——那节课的 print 调试练习里，调试用的 print 输出神秘地消失了，原因不在代码，而在 doctest 模块本身；二是一道 WWPD（What Would Python Display） 形式的 try-finally 题，它把异常处理的执行顺序钉死。这两块都是期中范围内的东西。

1. 更正 Lecture 11：doctest 为什么把 print 吞了

Lecture 11 的最后一个练习是 print 调试：给一个有 bug 的 make_acronym（把 'central processing unit' 变成 'CPU'），要求插 print 找出 bug。课上现场演示时出了怪事——插好的 print 语句，在跑 doctest 时一行输出都没有。

这不是学生写错了，也不是讲师写错了。是 doctest 模块本身的行为。

自己动手复现一次

光看结论没用，跑一遍才记得住。把下面这段存成 acr.py：

def make_acronym(phrase):
    """
    >>> make_acronym('central processing unit')
    'CPU'
    >>> make_acronym('user  interface')
    'UI'
    """
    words = phrase.split(' ')
    acronym = ''
    for w in words:
        print('DEBUG: w =', repr(w))
        acronym += w[0].upper()
    return acronym

注意第二条 doctest 里 'user interface' 中间是两个空格——这正是原练习里的 bug 来源：split(' ') 按单个空格切，两个空格中间会切出一个空字符串，而 ''[0] 会炸。

运行 python3 -m doctest -v acr.py，真实输出的关键部分是：

Got:
    DEBUG: w = 'central'
    DEBUG: w = 'processing'
    DEBUG: w = 'unit'
    'CPU'
Trying:
    make_acronym('user  interface')
Expecting:
    'UI'
**********************************************************************
File "/tmp/l12/acr.py", line 5, in acr.make_acronym
Failed example:
    make_acronym('user  interface')
Exception raised:
    Traceback (most recent call last):
      ...
      File "/tmp/l12/acr.py", line 12, in make_acronym
        acronym += w[0].upper()
    IndexError: string index out of range

那为什么 OkPy 里加 print 就没事？

你在做 lab 和 hw 时用的 python3 ok，加了 print("DEBUG: ...") 之后既能看到输出，测试也照样能过。这不是 doctest 的功劳，是 61A 课程组多年前写 OkPy 时自己加的。

做法是这样的：doctest 模块除了「一行命令跑完」的简单用法外，还提供一套高级 API，允许你替换掉它内部负责「判断实际输出算不算对」的那个组件——OutputChecker。OkPy 定义了 OutputChecker 的一个子类，用正则表达式识别出以 DEBUG: 之类前缀开头的行，在比对之前把它们从实际输出里剥掉。剥完再交给原来的比对逻辑。

结论：这门课的三条 takeaway

• 不要在没验证的情况下做假设。 讲师当时以为 doctest 的行为和 OkPy 一样，因为她一直用的是 OkPy。
• 文档是你的朋友。 这个行为其实写在 doctest 官方文档里，只不过是页面最底下的一条脚注。
• 抽象的力量。 见上面那个 OutputChecker 的故事。

顺带一个对期中有用的推论：考试里让你判断一段代码「显示什么」时，问的永远是把这段代码敲进交互式解释器（>>> 提示符）会看到什么，不是在 doctest 或 ok 里看到什么。 交互式解释器的规则很简单——print 调用一次打一行，最后表达式的值如果不是 None 再打一行。下一节就是一道这种题。

2. WWPD：try / except / else / finally 的执行顺序

Lecture 11 给出了 try 语句的完整形状：

try:
    <try suite>
except <exception> as <name>:    # 可选，可以有多个
    <except suite>
else:                             # 可选
    <else suite>
finally:                          # 可选
    <finally suite>

四个 suite 什么时候跑，是期中最容易被考的「求值顺序」之一。先把规则摆出来：

另外两条语法约束：最少要写 try + except，或者 try + finally（光有 try 不行）；except: 后面不写异常类会捕获一切异常，这很危险——静悄悄地吞掉错误是我们最不想要的，所以永远写清楚要抓哪个类。

第一题：把 Lecture 11 的 safe_divide 逐帧走一遍

def safe_divide(numerator, denominator):
    try:
        result = numerator / denominator
    except ZeroDivisionError:
        result = 'Undefined'
    else:
        print(f"The result of the division is: {result}")
    finally:
        print("Cleanup")
    return result

问：在交互式解释器里依次敲 safe_divide(1, 0) 和 safe_divide(4, 2)，各显示什么？

合起来，两次调用的真实屏幕输出（我在 Python 3.10 上跑过）是：

>>> safe_divide(1, 0)
Cleanup
'Undefined'
>>> safe_divide(4, 2)
The result of the division is: 2.0
Cleanup
2.0

两个细节值得停一下：

• 4 / 2 得到的是 2.0 不是 2。Python 的 / 永远返回 float，哪怕整除得尽。要整数除法得用 //。WWPD 题里漏掉这个 .0 就算错。
• 第二次调用里 The result... 出现在 Cleanup 之前。else 在 finally 之前跑，顺序不能颠倒。

第二题：return 和 finally 谁先谁后

这是 finally 最反直觉的地方。

def f():
    try:
        return 'try'
    finally:
        print('finally runs')

>>> f()
finally runs
'try'

return 'try' 已经执行了，函数「应该」立刻结束才对——但 finally runs 还是打出来了，而且打在返回值之前。

def g():
    try:
        return 'try'
    finally:
        return 'finally'

>>> g()
'finally'

第三题：没被接住的异常，finally 还跑吗

def k():
    try:
        raise ValueError('boom')
    except TypeError:
        print('never')
    finally:
        print('k cleanup')

>>> k()
k cleanup
Traceback (most recent call last):
  ...
ValueError: boom

逐步看：raise ValueError('boom') 抛出 ValueError；except TypeError 类型对不上，不执行，never 永远不会打印；异常此时处于「正在往外传」的状态；但离开 try 语句要先跑 finally，所以 k cleanup 先打出来；finally 结束后异常才继续往外传，最终由解释器打出 traceback。

3. One Cent：生成器做滑动窗口

题面（CS 61A Fall 2022 Final Q7）。 在潘尼游戏（Penney's Game）里，两名玩家各选一串互不相同的三次抛硬币结果（每次是 'H' 正面或 'T' 反面）。然后开始反复抛硬币，谁选的那串先出现，谁就赢。

例子：玩家 1 选 "HHH"，玩家 2 选 "THH"，实际抛出的序列是 HTTHTHTTHTHTHH。最后三次抛出的 THH 先出现（HHH 从头到尾没出现过），所以玩家 2 赢。

(a) 生成器 three_flips

先写生成器函数 three_flips。输入是一个可能无穷的迭代器 coin，每个元素是 'H' 或 'T'。它要不断产出连续三次抛硬币结果拼成的字符串——注意是滑动的，不是三个三个切开：

def three_flips(coin):
    '''
    >>> a = three_flips(iter("HTTHHT"))
    >>> next(a)      # 第 0、1、2 次抛
    'HTT'
    >>> next(a)      # 第 1、2、3 次抛
    'TTH'
    >>> next(a)      # 第 2、3、4 次抛
    'THH'
    >>> next(a)      # 第 3、4、5 次抛
    'HHT'
    '''
    start = ___(a)___
    ___(b)___:
        yield start
        start = ___(c)___ + ___(d)___

怎么想到的

先把 doctest 摊开看清楚。原始序列是 H T T H H T，产出的四个值是：

两条关键观察：

• 相邻两次产出重叠两个字符。 'HTT' 的后两位 'TT' 就是 'TTH' 的前两位。所以从上一个值得到下一个值，只需要「砍掉最前面一个字符、在后面接一个新字符」——这就是滑动窗口。
• 每次产出只额外消耗一个新元素。 第一次产出要吃掉 3 个，之后每次只吃 1 个。这一点决定了 next(coin) 该写在哪儿——写多了会把序列吃穿。

为什么必须用生成器而不是先把 coin 转成 list 再切片？因为题面写了 coin 可能是无穷的。list(coin) 会永远跑下去。生成器的价值就在于它「用多少算多少」，这也是 Lecture 10 的核心。

填空

def three_flips(coin):
    start = next(coin) + next(coin) + next(coin)
    while True:
        yield start
        start = start[1:] + next(coin)

• (a) next(coin) + next(coin) + next(coin)——先手动吃掉三个，拼成第一个窗口。这里能这么写，是因为 Python 的 + 从左往右求值，三次 next 依次拿到第 0、1、2 个元素。
• (b) while True——无限循环。备选项 for x in coin 是错的：for 会自己从 coin 里取元素，和循环体里的 next(coin) 抢，一轮吃两个，产出的窗口会跳着走。
• (c) start[1:]——去掉最老的那一位，留下后两位。
• (d) next(coin)——接上一个新的。备选项 coin 是错的（那是把迭代器对象跟字符串相加，直接 TypeError），coin.pop() 更错——迭代器没有 pop 方法。

next 次数   冻结位置        start 的值    coin 已消耗到（下标）
  —        尚未启动        （不存在）     0
  1        yield 那一行    'HTT'          3
  2        yield 那一行    'TTH'          4
  3        yield 那一行    'THH'          5
  4        yield 那一行    'HHT'          6  ← 已耗尽
  5        —— 见下 ——

>>> next(a)
Traceback (most recent call last):
  File "...", line 5, in three_flips
    start = start[1:] + next(coin)
StopIteration

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "...", line 16, in <module>
    next(a)
RuntimeError: generator raised StopIteration

(b) penney：用 filter 找第一个命中

def penney(coin, p1, p2):
    '''返回潘尼游戏的胜者：玩家 1 选 p1，玩家 2 选 p2。

    >>> penney(iter("HTTHTHTTHTHTHH"), "THH", "HHH")
    1
    >>> penney(iter("HTTHTHTTHTHTHH"), "HHH", "THH")
    2
    >>> penney(iter("HTTHTHTTHTHTHH"), "HTT", "THH")   # HTT 先出现
    1
    '''
    it = ___(a)___(lambda x: ___(b)___, ___(c)___)
    if next(it) == p1:
        return 1
    return 2

怎么想到的

骨架已经把答案框死了：it 是某个东西，next(it) 取出来的第一个值直接拿来跟 p1 比。所以 it 必须是「所有出现过的三连窗口里，只保留是 p1 或 p2 的那些」的迭代器——它的第一个元素就是「先出现的那一串」。

「从一串东西里挑出满足条件的」——这是 filter(函数, 可迭代对象)。加上第一个参数已经写好是 lambda，答案立刻明朗：

it = filter(lambda x: x in [p1, p2], three_flips(coin))

• (a) filter
• (b) x in [p1, p2]——判断这个三连窗口是不是两名玩家中某一个选的串
• (c) three_flips(coin)——被筛的对象是所有滑动窗口。备选项里的 coin 是错的：coin 里的元素是单个字符 'H'/'T'，永远不会等于三字符的 p1；(p1, p2) 更错——那是把答案本身当输入筛。

4. Escape Lumon：在网格上做树递归

题面（DATA C88C Spring 2025 Midterm Q7）。 Helly 是 Lumon 公司的新员工，她被锁在办公楼里出不去，必须至少收集 3 张安全徽章才能离开。同事 Mark 给了她一张走廊地图，用 Python 的嵌套列表（list of lists）表示：每个格子是 0 或 1，1 表示这里能捡到一张徽章。

实现 count_paths(grid)：返回从左上角走到右下角、途中只能向右或向下移动、并且捡到至少 3 张徽章的不同路径数。

def count_paths(grid):
    """
    >>> simple_grid = [
    ...     [1, 0, 0],
    ...     [1, 0, 0],
    ...     [1, 0, 0],
    ... ]
    >>> count_paths(simple_grid)
    1

    >>> # R = 向右, D = 向下
    >>> # 路径 1: RRDD, 路径 2: RDRD, 路径 3: RDDR, 路径 4: DRRD, 路径 5: DRDR
    >>> complex_grid = [
    ...     [1, 0, 1],
    ...     [0, 1, 0],
    ...     [0, 0, 1],
    ... ]
    >>> count_paths(complex_grid)
    5

    >>> zeros_grid = [
    ...     [0, 0, 0],
    ...     [0, 0, 0],
    ...     [0, 0, 0],
    ... ]
    >>> count_paths(zeros_grid)
    0
    """
    def helper(row, col, badges):
        if row >= len(grid) or col >= len(grid[0]):
            return ___(a)___
        badges += ___(b)___
        if ___(c)___:
            if badges >= 3:
                return ___(d)___
            else:
                return ___(e)___
        return ___(f)___
    return ___(g)___

先把 doctest 翻译成人话

三个 doctest 各卡一个点，值得逐个手算：

simple_grid：徽章全在第 0 列。 3×3 网格从左上到右下一共有 $\binom{4}{2} = 6$ 条路径（走 4 步，其中挑 2 步向下）。但只有一条路径能踩满第 0 列的三个 1：先一路向下走到底，再一路向右——DDRR。其余五条路径都在某一步提前拐右，就永远回不到第 0 列了（不能向左）。答案 1。

complex_grid：6 条路径里 5 条合格。 逐条数：

zeros_grid：一张徽章都没有，六条路径全不合格，答案 0。它顺便告诉你：函数返回的是「合格路径数」，不是「路径数」——如果你写成先数路径再判断，会得到 6。

怎么想到的：这是一棵树，不是一张网格

「从起点到终点有多少条路」这个问法，跟 Lecture 06 的 count_partitions 是同一个形状。关键在于把「走一步」看成一次分叉：

但光有位置还不够。「至少 3 张徽章」这个条件不是只看终点格子就能判断的，它取决于你一路怎么走过来。这就是为什么骨架里 helper 有第三个参数 badges：

逐个填空

def count_paths(grid):
    def helper(row, col, badges):
        if row >= len(grid) or col >= len(grid[0]):
            return 0
        badges += grid[row][col]
        if row == len(grid) - 1 and col == len(grid[0]) - 1:
            if badges >= 3:
                return 1
            else:
                return 0
        return helper(row, col + 1, badges) + helper(row + 1, col, badges)
    return helper(0, 0, 0)

三个顺序问题，一个都不能错

验证：把 simple_grid 完整展开

下面是 count_paths(simple_grid) 的真实调用树（我加了打印语句跑出来的，缩进表示调用深度）。badges= 标的是捡过当前格子之后的值：

helper(0, 0, 0)  badges=1
  helper(0, 1, 1)  badges=1
    helper(0, 2, 1)  badges=1
      helper(0, 3, 1) → 0   越界（列出界）
      helper(1, 2, 1)  badges=1
        helper(1, 3, 1) → 0   越界
        helper(2, 2, 1) → 0   终点，但 badges=1 < 3
        = 0
      = 0
    helper(1, 1, 1)  badges=1
      helper(1, 2, 1)  … = 0
      helper(2, 1, 1)  … = 0
      = 0
    = 0                        ← 第一步向右的全部走法：0 条
  helper(1, 0, 1)  badges=2
    helper(1, 1, 2)  badges=2
      helper(1, 2, 2)  … = 0
      helper(2, 1, 2)  … = 0
      = 0
    helper(2, 0, 2)  badges=3
      helper(2, 1, 3)  badges=3
        helper(2, 2, 3) → 1   终点，badges=3 ≥ 3  ✔
        helper(3, 1, 3) → 0   越界（行出界）
        = 1
      helper(3, 0, 3) → 0     越界
      = 1
    = 1
  = 1                          ← 第一步向下的全部走法：1 条
TOTAL 1

逐层回代看得很清楚：唯一那个 1 来自最深处的 helper(2, 2, 3)——也就是路径 DDRR。它一路往上加，经过 helper(2,1,3)、helper(2,0,2)、helper(1,0,1)，最后和「第一步向右」那半边的 0 相加，得到 1。

def count_paths(grid):
    badges = 0                    # ✗ 错
    total = 0
    def helper(row, col):
        nonlocal badges, total
        badges += grid[row][col]
        ...

5. All Treeils Lead to Rome：树的数据抽象 + 递归

题面（CS 61A Summer 2023 Midterm Q6）。 定义：Treeil 是这样一种树——它的每一个非叶节点，都恰好有一个子节点的 label 等于该节点自己的 label。换个说法：从任何节点出发，都存在唯一一条通往叶子的路径，路径上所有节点的 label 全都相同。

先把 Lecture 09 的树 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)

(a) is_treeil：把定义翻译成代码

def is_treeil(t):
    """
    >>> t1 = tree(1)
    >>> is_treeil(t1)
    True
    >>> t2 = tree(1, [tree(2), tree(3)])
    >>> is_treeil(t2)
    False
    >>> t3 = tree(1, [tree(1, [tree(1), tree(3)]), tree(2)])
    >>> is_treeil(t3)
    True
    >>> t4 = tree(1, [tree(1, [tree(1), tree(1)]), tree(2)])
    >>> is_treeil(t4)
    False
    >>> t5 = tree(2, [tree(3, [tree(1)]), tree(2, [tree(2)])])
    >>> is_treeil(t5)
    False
    """
    if ___(a)___:
        return True
    else:
        match_one = ___(b)___([b for b in branches(t) if ___(c)___]) == 1
        return ___(d)___ and ___(e)___([___(f)___ for b in branches(t)])

先把五个 doctest 手算一遍

t4 和 t5 是这道题的全部难点所在：t4 说明「恰好一个」不能放宽成「至少一个」；t5 说明光检查根这一层不够，每个后代都要检查。 这两件事对应最终代码里的两个条件，用 and 连起来。

填空

def is_treeil(t):
    if is_leaf(t):
        return True
    else:
        match_one = len([b for b in branches(t) if label(t) == label(b)]) == 1
        return match_one and all([is_treeil(b) for b in branches(t)])

(b) max_treeil：最大的 treeil 子树有多少个节点

现在 t 不一定是 treeil。求：t 的所有子树中，是 treeil 的那些里面，节点数最多的是多少个节点。可以假设 is_treeil 已经写好了。

def max_treeil(t):
    """
    >>> max_treeil(t1)     # tree(1)
    1
    >>> max_treeil(t2)     # 1 -> [2, 3]
    1
    >>> max_treeil(t3)     # 1 -> [1 -> [1, 3], 2]
    5
    >>> max_treeil(t4)     # 1 -> [1 -> [1, 1], 2]
    1
    >>> max_treeil(t5)     # 2 -> [3 -> [1], 2 -> [2]]
    2
    """
    if ___(a)___:
        return 1
    elif ___(b)___:
        return 1 + ___(c)___
    else:
        return max([___(d)___ for b in branches(t)])

怎么想到的

骨架分三支，逐支追问「什么情况下走这支」：

剩下 (c)：既然第二支要返回「t 的节点总数」，那就是 1（根自己） + 所有子树的节点数之和。而当 t 是 treeil 时，它的每棵子树也都是 treeil（这是定义递归成立的直接推论），所以 max_treeil(b) 返回的就是 b 的节点总数。于是：

def max_treeil(t):
    if is_leaf(t):
        return 1
    elif is_treeil(t):
        return 1 + sum([max_treeil(b) for b in branches(t)])
    else:
        return max([max_treeil(b) for b in branches(t)])

max_treeil(t5)
  is_leaf? 否
  is_treeil(t5)? 否  →  走第三支：max([...])
  ├─ max_treeil(3 → [1])
  │    is_leaf? 否
  │    is_treeil? 否（孩子 label 是 1，没有 3）→ 第三支
  │    └─ max_treeil(1)   叶子 → 1
  │    = max([1]) = 1
  └─ max_treeil(2 → [2])
       is_leaf? 否
       is_treeil? 是（孩子 label 2 恰好匹配一个）→ 第二支
       └─ max_treeil(2)   叶子 → 1
       = 1 + sum([1]) = 2
  = max([1, 2]) = 2

6. Multi Compose：返回函数的递归

题面（CS 61A Summer 2024 Midterm Q6）。 实现 multi_compose(funcs, x, y)：输入一个函数列表和两个整数 x、y，返回一个复合函数，它对输入 x 的输出是 y；这个复合函数由 funcs 里的某个子序列依次施加而成。约束：

• 函数只能按它们在列表里的先后顺序施加——下标 i 的函数必须在下标 i+1 的函数之前施加。
• 每个函数用 0 次或 1 次。
• 若不存在这样的复合函数，返回 None；若存在多个，返回其中任意一个。
• 可以假设 x != y。
• 解法必须用给定的 safe_compose。

def safe_compose(f, g):
    """
    >>> composed = safe_compose(lambda x: x + 1, lambda x: x * 2)
    >>> composed(5)
    11
    >>> safe_compose(lambda x: x, None) is None and safe_compose(None, lambda x: x) is None
    True
    """
    if f is None or g is None:
        return None
    def composed(x):
        return f(g(x))
    return composed

safe_compose(f, g) 返回的是 f 套在 g 外面：composed(x) 先算 g(x)，再把结果喂给 f。所以 g 先施加、f 后施加。这个顺序后面是解题关键。另外它对 None 是「传染性」的：任一参数是 None，结果就是 None。

def multi_compose(funcs, x, y):
    """
    >>> add_one, double = lambda x: x + 1, lambda x: x * 2
    >>> sub_three, square = lambda x: x - 3, lambda x: x ** 2
    >>> list_of_funcs = [add_one, double, sub_three, square]
    >>> double_then_square = multi_compose(list_of_funcs, 3, 36)
    >>> double_then_square
    Function
    >>> double_then_square(1)      # (1 * 2) ** 2 --> 4
    4
    >>> square_then_double = multi_compose(list_of_funcs, 3, 18)
    >>> square_then_double         # None
    >>> all_funcs = multi_compose(list_of_funcs, 3, 25)
    >>> all_funcs(1)               # (((1 + 1) * 2) - 3) ** 2 --> 1
    1
    >>> negate = multi_compose(list_of_funcs, 100, -100)
    >>> negate                     # None
    """
    if x == y:
        return lambda x: ___(a)___
    if ___(b)___:
        return None
    return ___(c)___ or multi_compose(___(d)___)

先读懂题在问什么

这道题最容易被读错的地方：x 和 y 只是用来「挑出该用哪些函数」的样本，返回的函数并不是只对 x 有效。

看第一个 doctest：multi_compose(list_of_funcs, 3, 36)。要在 [add_one, double, sub_three, square] 里按顺序挑一个子序列，使得对 3 施加后得到 36。手算一下：double(3) = 6，square(6) = 36。✔ 所以挑中的子序列是 [double, square]（跳过 add_one 和 sub_three）。

返回的函数是「先 double 再 square」这个复合函数本身。所以下一行 double_then_square(1) 得到 (1 * 2) ** 2 = 4——用的是别的输入，答案自然不是 36。

第二个 doctest 是反例：multi_compose(list_of_funcs, 3, 18) 返回 None。square(3) = 9、double(9) = 18 确实能凑出 18，但 square 在列表里排在 double 后面，不允许先 square 再 double。顺序约束在这里咬人。

multi_compose(L, 50, 48) 的 doctest 里那个变量叫 sub_two，注释写 2 - 2 --> 0——因为挑中的是 [add_one, sub_three]：50 → 51 → 48。所以对输入 2 就是 2 → 3 → 0。名字只是人给的标签，真正决定行为的是被挑中的那串函数。

怎么想到的：子序列 = 每个元素「选」或「不选」

再看 base case。递归到什么时候能宣布成功？当 x 已经等于 y 了——剩下的函数一个都不用挑，直接返回一个「什么都不做」的函数。什么时候宣布失败？当函数用完了 x 还不等于 y。

填空

def multi_compose(funcs, x, y):
    if x == y:
        return lambda x: x
    if not funcs:
        return None
    return safe_compose(multi_compose(funcs[1:], funcs[0](x), y), funcs[0]) \
           or multi_compose(funcs[1:], x, y)

把 (c) 拆开看

验证：完整展开 multi_compose(L, 3, 36)

下面是真实运行时的调用树（我加打印跑出来的，缩进＝深度）。L = [add_one, double, sub_three, square]。每一行括号里第一项是剩余函数列表、第二项是当前的值、第三项是目标 36。

mc([add_one, double, sub_three, square], 3, 36)
  ├─ 用 add_one → mc([double, sub_three, square], 4, 36)
  │    ├─ 用 double → mc([sub_three, square], 8, 36)
  │    │    ├─ 用 sub_three → mc([square], 5, 36)
  │    │    │    ├─ 用 square → mc([], 25, 36) → 函数空了 → None
  │    │    │    └─ 不用      → mc([], 5, 36)  → 函数空了 → None
  │    │    │    = None
  │    │    └─ 不用 sub_three → mc([square], 8, 36)
  │    │         ├─ 用 square → mc([], 64, 36) → None
  │    │         └─ 不用      → mc([], 8, 36)  → None
  │    │         = None
  │    │    = None
  │    └─ 不用 double → mc([sub_three, square], 4, 36)
  │         ├─ 用 sub_three → mc([square], 1, 36) → … → None
  │         └─ 不用         → mc([square], 4, 36) → … → None
  │         = None
  │    = None                    ← 「用 add_one」整条路走不通
  └─ 不用 add_one → mc([double, sub_three, square], 3, 36)
       ├─ 用 double → mc([sub_three, square], 6, 36)
       │    ├─ 用 sub_three → mc([square], 3, 36) → … → None
       │    └─ 不用         → mc([square], 6, 36)
       │         └─ 用 square → mc([], 36, 36)
       │                        x == y  ✔  返回 lambda x: x
       │         = safe_compose(lambda x: x, square)  → 一个函数
       │    = 那个函数
       └─ = safe_compose(那个函数, double)  → 最终答案
  = 最终答案（先 double 再 square）

B  ──→  func composed(x) [parent = f2]

f2: safe_compose  [parent=Global]
    f  ──→  A          （即 lambda t: t ** 2 那一层）
    g  ──→  double
    composed ──→ func composed(x) [parent=f2]

f1: safe_compose  [parent=Global]      ← 造出 A 的那次调用
    f  ──→  I  (lambda x: x)
    g  ──→  square
    composed ──→ func composed(x) [parent=f1]

调用 B(1) 时：
  新建 f3: composed [parent=f2]，x ──→ 1
  求 f(g(x))：g 在 f2 里查到 double → double(1) = 2
              f 在 f2 里查到 A      → A(2)
  调用 A(2) 时：
  新建 f4: composed [parent=f1]，x ──→ 2
  求 f(g(x))：g 在 f1 里查到 square → square(2) = 4
              f 在 f1 里查到 I      → I(4) = 4
  B(1) = 4

这张图是这道题真正的价值所在：safe_compose 每被调用一次，就留下一帧；返回的 composed 函数的 parent 指向那一帧，于是它「记住」了当时的 f 和 g。 一串嵌套的 safe_compose 调用，就在内存里串成一条帧的链条——这就是闭包（closure），也是 Lecture 03、04 讲高阶函数和环境图时那些练习的真正用途。

7. 考试范围地图：十一讲各自会怎么考

期中的范围是本讲（含）之前的全部内容。把十一讲列出来，配上「它在题里长什么样」，你就知道自己该补哪一块。表里的「典型考法」全部来自上面这四道题以及本讲用到的知识点，不是我编的题型分类。

四道题各自暴露了哪块短板

如果你在某道题上卡住了，卡的位置基本能定位到具体一讲：

本讲小结

动手练习

五道题，全部基于本讲内容。请先自己写/自己算，再展开答案。

练习 1：WWPD

下面这段在交互式解释器里依次执行，屏幕上出现什么？

>>> def mystery(n):
...     try:
...         return 10 // n
...     except ZeroDivisionError:
...         print('div by zero')
...         return -1
...     finally:
...         print('done', n)
...
>>> mystery(5)
>>> mystery(0)
>>> print(mystery(0))

>>> mystery(5)
done 5
2
>>> mystery(0)
div by zero
done 0
-1
>>> print(mystery(0))
div by zero
done 0
-1

练习 2：改一行会怎样

把 three_flips 的最后一行从 start = start[1:] + next(coin) 改成 start = start[1:] + next(coin) + next(coin)，那么 a = three_flips(iter("HTTHHTHT")) 之后连续三次 next(a) 分别得到什么？

练习 3：把门槛改掉

如果 Lumon 的规则从「至少 3 张徽章」改成「恰好 3 张」，count_paths 要改哪里？对 simple_grid、complex_grid、zeros_grid 的答案分别变成多少？

if badges > 3:
    return 0

练习 4：为什么这个 is_treeil 是错的

有人这样写 is_treeil。它在五个 doctest 里有几个是对的？错的那些为什么错？

def is_treeil(t):
    if is_leaf(t):
        return True
    return len([b for b in branches(t) if label(t) == label(b)]) == 1

练习 5：multi_compose 的两支能不能对调

把最后一行的两支对调，写成

return multi_compose(funcs[1:], x, y) \
       or safe_compose(multi_compose(funcs[1:], funcs[0](x), y), funcs[0])

结果还对吗？multi_compose(L, 3, 36) 会返回什么？