递归：让函数调用它自己

0. 本讲导读

到上一讲为止，你手上有两件重复执行代码的工具，而它们其实是同一件：while 循环把一段代码重复到条件不成立；环境图告诉你每调用一次函数就新建一帧。本讲要做的事，是把这两件东西接到一起——让一个函数在自己的函数体里调用自己。

为什么值得专门花一讲？因为有一大类问题，用循环写出来极其别扭，用递归写出来几乎就是把问题的定义原样抄下来。最典型的是阶乘：数学书上写的是

这个式子里，「阶乘」这个概念是用它自己定义的。你要是用 while 去实现它，得先在脑子里把这个定义展开成「从 1 乘到 n」，再配一个计数器、一个累乘器、一个更新语句。而递归的写法就是把上面那行式子翻译成 Python，一个字都不用多想。

更要紧的是往后看：树（tree）、链表（linked list）、Scheme 的表达式求值——这些数据结构本身就是用「自己」定义的（一棵树的分支还是树，一个链表的 rest 还是链表）。处理这类结构时，递归不是「一种可选风格」，而是唯一自然的写法。Scheme 甚至根本没有循环语句，那门语言里所有的重复都靠递归。

本讲会把递归拆成三个部件反复练，然后把 fact(3) 的环境图一帧一帧完整画出来——不画这张图，递归永远停留在「好像懂了但一写就错」的状态。之后是三种真实会遇到的崩溃方式（RecursionError、少写 return、base case 够不着）、迭代与递归的互相翻译、自引用、互递归，最后落到随堂练习 sum_digits 和 Luhn 算法上。

这一讲是 Lab 03 和 HW 02 的正面依据（HW 02 的阅读材料直接写着「Section 1.7」），也是下一讲树递归的地基。下一讲的每一个函数里都会出现两次以上递归调用，如果现在还没能把一次递归调用的过程说清楚，那时候会彻底跟不上。

1. 递归是什么：从排队买 taco 说起

先给定义，再讲为什么这个定义能干活。

「用自己定义自己」听上去像循环论证，凭什么不会转圈转到死？关键就在「更小」和「最简单的那个」这两个限定。只要每次都严格变小，而且小到某个地步就不再往下拆、直接给答案，整件事就一定会停。

排队买 taco

课上用的例子是这样的：你在一条很长的队伍里买 taco，队伍长到你看不见队头。问题是——你排在第几个？

你直接数不出来，因为你看不到前面有多少人。但你能做一件事：拍拍前面那个人的肩膀，问他排第几。

请注意这个过程里的三个事实，它们逐字对应到代码上：

• 每个人做的事完全一样：问前面的人，把答案加 1，报出去。一模一样的行为，用在队伍里的每一个位置——这就是「同一个函数被调用很多次」。
• 队头是特殊的。他是唯一一个不提问的人。如果队头也去问前面的人，这条队伍就会问到墙上去，永远回不来。队头就是 base case。
• 问题必须先一路传到头，答案才开始往回走。在队头开口之前，中间所有人都卡在原地等着——他们的「我要把听到的数加 1」这件事还没做，正悬在半空。这些「悬在半空的人」在 Python 里就是一个个还没执行完的帧（frame）。

第三条是最容易被忽略、却在环境图上最显眼的一条。它解释了为什么递归比循环费内存：队伍有多长，同时挂着的帧就有多少个。

为什么要用递归，而不是循环

课上给了三条理由，一条比一条实在。

反过来，课上也明确讲了递归的两个代价，别把递归当万能药：

2. 递归函数的解剖：三个部件

把排队那个故事翻译成写代码的步骤，就得到一份永远适用的模板。课上把它叫做「递归函数的解剖（anatomy of a recursive function）」。

注意措辞：base case 和 recursive case 都可能有多个。下一讲的树递归里，一个函数有两个 base case、两个递归调用是常态。

第 3 步为什么叫「信仰之跃」

这是初学递归时唯一真正的心理障碍，值得单独说清楚。

写 fact(n) 的递归情形时，你要写下 return n * fact(n - 1)。此刻大多数人的脑子会开始往下追：「fact(n-1) 又会调用 fact(n-2)，然后 fact(n-3)……」——追了三层就晕了，于是得出结论「递归好难」。

不要追。 正确的心态是：

为什么这个「假定」是合法的、不是自我欺骗？因为它其实是数学归纳法（mathematical induction）：

所以「信仰之跃」不是要你闭眼相信玄学，而是要你相信一个你刚刚自己证明过的东西。检查递归函数对不对，只需查这两件事：base case 对不对、递归情形的拼装逻辑对不对——永远不需要在脑子里展开三层以上。

递归函数一定要写 if 吗

课上出过一道 True/False 投票题：「所有递归函数都必须有某种 if-else 语句。」

答案是 False——但要注意它 False 在什么地方。

每个递归函数都必须有 base case，也就是必须有某种「在这种情况下不再递归」的分支逻辑。但「分支逻辑」不等于「非得写 if/else 这个语法」。第 4 节讲的 fact 可以写成条件表达式，第 8 节的互递归里 luhn_sum_double 的 base case 判断也可以换个形状。举个能跑的例子：

>>> def fact(n):
...     return 1 if n == 0 else n * fact(n - 1)
...
>>> fact(5)
120

这里一个 if 语句都没有（1 if n == 0 else ... 是条件表达式，是一个表达式不是语句），但 base case 依然存在。

所以准确的说法是：递归函数必须有 base case，也就是必须有「某个分支不再递归」；至于用什么语法写出这个分支，是自由的。 考试里遇到这种绝对化的措辞（「必须」「所有」），先找反例。

3. countdown：递归调用放在 print 前面还是后面

课上第一个投票题是：「哪一种 countdown 的实现会在调用 countdown(5) 时逐行打印出 5、4、3、2、1、Blastoff!？」

这道题看着无聊，其实是全讲最好的一个入门题——它逼你分清「递归调用发生的时刻」和「打印发生的时刻」。下面两个实现只差两行代码的顺序，输出完全相反。（这两版是照着投票题的设定写的示例，两段都在本机跑过。）

def countdown_a(n):
    if n <= 0:
        print('Blastoff!')
    else:
        print(n)
        countdown_a(n - 1)      # 先打印，再递归

def countdown_b(n):
    if n <= 0:
        print('Blastoff!')
    else:
        countdown_b(n - 1)      # 先递归，再打印
        print(n)

实测输出：

>>> countdown_a(5)
5
4
3
2
1
Blastoff!
>>> countdown_b(5)
Blastoff!
1
2
3
4
5

countdown_a 是倒计时，countdown_b 是正着数。为什么？

把「回溯阶段每帧的 n 各不相同」这件事画出来，就是下面这张图。注意六个帧同时存在，各自记着自己的 n：

Global frame
    countdown_b  ──→ func countdown_b(n) [parent=Global]

f1: countdown_b [parent=Global]   n ──→ 5    ← 停在 countdown_b(n-1) 这一句，后面还有 print(n) 没跑
f2: countdown_b [parent=Global]   n ──→ 4    ← 同上
f3: countdown_b [parent=Global]   n ──→ 3    ← 同上
f4: countdown_b [parent=Global]   n ──→ 2    ← 同上
f5: countdown_b [parent=Global]   n ──→ 1    ← 同上
f6: countdown_b [parent=Global]   n ──→ 0    ← 走 if 分支，打印 Blastoff! 后返回 None

回溯时依次执行 f5 的 print(1)、f4 的 print(2)、f3 的 print(3)、f2 的 print(4)、f1 的 print(5)

4. fact：把环境图一帧一帧画出来

阶乘的定义：非负整数 n 的阶乘，是从 n 到 1 所有整数的乘积。

边界情况单独规定：0! = 1。（这不是随便定的——空乘积按约定等于 1，就像空求和等于 0。有了它，后面的递归定义才对 n = 1 成立。）

关键的一步观察是把定义重写成递归形式：

为什么可以这么写？把 5! 展开看：

后面那一串「4 × 3 × 2 × 1」正好就是 4! 的定义。子问题和原问题形状完全一样，只是规模小了 1。 这就是递归能上场的信号。

翻译成代码

def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1)

对照第 2 节的三个部件：

整个函数体只有四行，而且每一行都能在数学定义里找到对应。这就是第 0 节说的「把定义原样抄下来」。

fact(3) 的完整环境图

下面这段是本讲的核心，请一行一行读。不要跳。

此刻栈上一共挂着四个帧，全局帧算上是五个。这是整个过程中内存占用最高的一瞬间：

Global frame
    fact  ──→ func fact(n) [parent=Global]

f1: fact [parent=Global]
    n  ──→ 3          挂起在:  return n * fact(2)        返回值: 待定
f2: fact [parent=Global]
    n  ──→ 2          挂起在:  return n * fact(1)        返回值: 待定
f3: fact [parent=Global]
    n  ──→ 1          挂起在:  return n * fact(0)        返回值: 待定
f4: fact [parent=Global]
    n  ──→ 0          执行:    return 1                  返回值: 1   ← base case

用一张表把「下去」和「回来」并排放，最能看清全貌：

写成一行展开式（这就是「真的展开到 base case 再逐层回代」）：

fact(3)
= 3 * fact(2)
= 3 * (2 * fact(1))
= 3 * (2 * (1 * fact(0)))
= 3 * (2 * (1 * 1))          ← base case 触底，开始回代
= 3 * (2 * 1)
= 3 * 2
= 6

5. 递归会怎么崩：三种真实的失败

课上做了一个 demo：「如果拿一个很大的数去调 fact 会怎样？为什么？」 还有一道投票题：「执行 fact(-1) 会发生什么？」 这两个问题的答案是同一个东西，值得连着讲。下面三段都在本机（CPython 3.10）真跑过，报错信息是原样复制的。

失败一：栈太深 —— RecursionError

fact(900) 能算出来（结果是个 2270 位的整数，Python 的 int 没有上限）。但把参数换成 3000：

>>> fact(3000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in fact
    return n * fact(n - 1)
  File "<stdin>", line 5, in fact
    return n * fact(n - 1)
  File "<stdin>", line 5, in fact
    return n * fact(n - 1)
  [Previous line repeated 995 more times]
  File "<stdin>", line 2, in fact
    if n == 0:
RecursionError: maximum recursion depth exceeded in comparison

三件事值得注意：

• [Previous line repeated 995 more times]——Python 知道你在原地打转，帮你把重复的栈帧折叠了。看到这一行，基本可以确定是递归出了问题。
• 错误不是在 3000 层才发生的，而是在大约第 1000 层。CPython 默认的递归深度上限是 1000（sys.getrecursionlimit() 返回 1000），到了就主动抛错。
• 结尾那句 in comparison 表示上限是在执行 if n == 0: 这个比较时被撞破的——不同的代码这句尾巴会不一样，不用纠结。

为什么会有这个上限？ 回到第 3 节那张图：递归到第 k 层时，栈上同时挂着 k 个帧，每个帧都占一块内存。这块区域叫调用栈（call stack），它的大小是有限的。撑爆它就是栈溢出（stack overflow）。Python 与其让操作系统在真溢出时把整个进程杀掉（那时你连报错都看不到），不如自己先设一道 1000 层的软限制，抛一个能被捕获、能看懂的 RecursionError。

失败二：base case 够不着 —— fact(-1)

投票题问 fact(-1) 会发生什么。很多人会猜「返回 1」或者「返回 -1」。真实结果：

>>> fact(-1)
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded in comparison

这个例子把第 2 节那句「必须朝 base case 的方向严格前进」变成了具体教训：「变小」不够，得「朝着 base case 变」。 修法有两种，各有取舍：

本课的 doctest 一般会写明函数只接受非负整数，所以 05.py 那样不加检查也算对。但要能说清楚自己的函数在非法输入上是什么行为——这是第 2 讲就强调过的习惯。

def fact(n):
    if n == 1:          # 错在这里
        return 1
    else:
        return n * fact(n - 1)

>>> fact(0)
Traceback (most recent call last):
  ...
RecursionError: maximum recursion depth exceeded in comparison

失败三：递归情形忘了写 return

这是初学者最高频的错，而且它的报错信息乍看和递归毫无关系。

def sum_digits(n):
    if n < 10:
        return n
    else:
        sum_digits(n // 10) + n % 10      # 忘了 return

>>> sum_digits(123)
Traceback (most recent call last):
  ...
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

注意报错发生的位置：崩在 f1，但真正的 bug 在 f2 那一层的写法上。这类错误的识别特征是：报错信息里出现 'NoneType'，而你根本没写过 None。 一旦看到，第一反应就该是「哪条执行路径漏了 return」。

6. 实战一：sum_digits，从迭代翻译成递归

随堂练习的起始代码在 05.py，题面是：

def sum_digits(n: int) -> int:
    """
    Returns the sum of the digits of a non-negative integer n.

    >>> sum_digits(0)
    0
    >>> sum_digits(5)
    5
    >>> sum_digits(123)
    6
    >>> sum_digits(3094153)
    25
    """

这个函数在第 2 讲写过一版 while 循环。现在要求用递归重写。为什么用一道做过的题？因为它能把「迭代和递归其实在做同一件事」摆到台面上。

题目到底要什么

把四个 doctest 逐个翻译：

怎么想到的

递归的第一个动作永远是：找出「把问题变小一点点」的那个操作。 对一个整数来说，可用的工具是第 2 讲学过的两个运算符：

有了这两个，三个部件就凑齐了：

第 3 步只需要想一层：「前面那些位的和 + 最后一位」。不要去想 3094153 会怎样一路拆到 3。

代码

这是 05-sol.py 里的实现（本仓库用 python3 -m doctest 05-sol.py 实测通过）：

def sum_digits(n: int) -> int:
    if n < 10:
        return n
    else:
        last = n % 10
        all_but_last = n // 10
        return sum_digits(all_but_last) + last

把两版并排读，能看出一条通用的翻译规律：

验证：手动追踪 sum_digits(123)

Global frame
    sum_digits  ──→ func sum_digits(n) [parent=Global]

f1: sum_digits [parent=Global]
    n             ──→ 123
    last          ──→ 3
    all_but_last  ──→ 12        挂起在: return sum_digits(12) + last
f2: sum_digits [parent=Global]
    n             ──→ 12
    last          ──→ 2
    all_but_last  ──→ 1         挂起在: return sum_digits(1) + last
f3: sum_digits [parent=Global]
    n             ──→ 1         返回值: 1        ← base case，没有 last / all_but_last

另一种拆法：用参数携带中间状态

课上给了第二种从迭代翻译过来的写法，形状更贴近原来的 while 循环：

def sum_digits(n: int, curr_sum: int) -> int:
    if n == 0:
        return curr_sum
    else:
        last = n % 10
        all_but_last = n // 10
        return sum_digits(all_but_last, curr_sum + last)

调用方式是 sum_digits(123, 0)，那个 0 就是迭代版里的 total = 0。追踪一遍：

然后 f3、f2、f1 依次原样把 6 交上去，什么也不加。

TypeError: sum_digits() missing 1 required positional argument: 'curr_sum'

def sum_digits(n):
    if n == 0:
        return 0                                  # 注意这里返回 0，不是 n
    else:
        return sum_digits(n // 10) + n % 10

>>> sum_digits(123)         # 期望 6
5
>>> sum_digits(3094153)     # 期望 25
22

>>> 123 / 10
12.3

7. 自引用：函数体里提到自己的名字

自引用（self-reference）指的是：一个函数在自己的函数体里提到自己的名字。

你可能会说：那不就是递归吗？——不完全是。递归是「调用自己」，自引用是「提到自己」。提到而不调用时，会发生一些很有意思的事。课上用 print_sums 演示（下面这段是这个经典例子的标准写法，本机跑过）：

def print_sums(x):
    print(x)
    def next_sum(y):
        return print_sums(x + y)
    return next_sum

先看它怎么用：

>>> print_sums(1)(2)(3)
1
3
6

三次调用，打出 1、3、6，也就是 1、1+2、1+2+3 的前缀和。这个函数把「上一次的累计值」记住了，而且没用任何全局变量、没用任何循环。它是怎么记住的？

Global frame
    print_sums  ──→ func print_sums(x) [parent=Global]

f1: print_sums [parent=Global]
    x         ──→ 1
    next_sum  ──→ func next_sum(y) [parent=f1]      ← 这个函数对象被 return 出去了
    返回值     ──→ func next_sum(y) [parent=f1]

f2: next_sum [parent=f1]                             ← parent 是 f1，不是 Global
    y         ──→ 2
    正在算:  print_sums(x + y)
             y 在 f2 找到 = 2
             x 在 f2 找不到 → 去 parent f1 找 → 1
             ⇒ x + y = 3

8. 互递归：两个函数互相调用

互递归（mutual recursion）是递归的一个特例：两个或更多函数互相调用，谁也不直接调用自己，但绕一圈还是回到了自己身上。这正好落进第 1 节那句定义里的「间接调用」。

课上的例子是判断奇偶（下面这版是这个经典例子的标准写法，本机跑过）：

def is_even(n):
    if n == 0:
        return True
    else:
        return is_odd(n - 1)

def is_odd(n):
    if n == 0:
        return False
    else:
        return is_even(n - 1)

先弄清它凭什么是对的。这两个函数其实是把奇偶性的一个递归定义直接抄下来了：

• 0 是偶数（不是奇数）。
• 对 n > 0：n 是偶数，当且仅当 n-1 是奇数；n 是奇数，当且仅当 n-1 是偶数。

换成奇数验证一遍：is_even(7) → is_odd(6) → is_even(5) → is_odd(4) → is_even(3) → is_odd(2) → is_even(1) → is_odd(0) → False。实测 is_even(7) 确实是 False。

注意触底时落在哪个函数里决定了答案：n 是偶数就落在 is_even(0)（返回 True），n 是奇数就落在 is_odd(0)（返回 False）。整条链条的作用就是「走 n 步，看最后停在哪个函数」。

def is_even(n):
    if n == 0:
        return True
    else:
        return is_odd(n - 1)

def is_odd(n):
    return is_even(n - 1)      # 没有 base case

9. 实战二：Luhn 算法（互递归）

Luhn 算法是真实世界里用来校验信用卡号的算法——它能挡掉大部分「手抖打错一位」的输入。规则只有两条：

题目到底要什么

05.py 要求实现 luhn_sum(n)，返回上面那个和（不判断能不能被 10 整除，只算和）。doctest：

def luhn_sum(n: int) -> int:
    """
    >>> luhn_sum(5)
    5
    >>> luhn_sum(52)  # (5*2) + 2 --> (1+0) + 2 --> 3
    3
    >>> luhn_sum(138743)  # from lecture slides
    30
    >>> luhn_sum(17893729974)
    60
    """

逐个读：

怎么想到的

先看卡在哪里。用第 6 节 sum_digits 的骨架来写：从右往左一位位剥，每剥一位加进和里。但这道题里每一位的处理方式不一样——有的原样加，有的要翻倍再拆。所以剥到某一位时，你必须知道「我现在处理的是该翻倍的位，还是不该翻倍的位」。

这就是一个典型的两状态来回切换的问题，正好落进第 8 节那句判据。两条路：

题目明确要求用互递归，所以走第 2 条。剩下三个小问题：

问题一：翻倍后大于 9 怎么办？ 规则说「把乘积的各位数字加起来」。这不就是刚写完的 sum_digits 吗？sum_digits(16) = 7。而且乘积小于等于 9 时（比如 4 * 2 = 8）sum_digits(8) = 8，正好原样返回。一个函数把两种情况都盖住了，一行 if 都不用写。 这是这道题最漂亮的一步。

问题二：base case 是什么？ 和 sum_digits 一样：n < 10，只剩一位了。但两个函数的 base case 返回的东西不同——luhn_sum 直接返回那一位，luhn_sum_double 要返回翻倍处理后的那一位。

问题三：从哪头开始？ n % 10 取到的是最右边那一位，而规则也是「从最右边数起」。天作之合：最外层调用 luhn_sum（右起第 1 位不翻倍），它剥掉一位后交给 luhn_sum_double（右起第 2 位要翻倍），再交回 luhn_sum……自动交替。

代码

这是 05-sol.py 里的实现（本仓库用 python3 -m doctest 05-sol.py 实测四个 doctest 全过）：

def luhn_sum(n: int) -> int:
    if n < 10:
        return n
    else:
        last = n % 10
        all_but_last = n // 10
        return last + luhn_sum_double(all_but_last)

def luhn_sum_double(n: int) -> int:
    last = n % 10
    all_but_last = n // 10
    luhn_digit = sum_digits(last * 2)
    if n < 10:
        return luhn_digit
    else:
        return luhn_digit + luhn_sum(all_but_last)

逐行讲，以及为什么是这样而不是别样

验证：手动追踪 luhn_sum(138743)

把每一层摊平成表，和幻灯片那三行表格逐格对应：

再快速验一遍最短的两条 doctest：

• luhn_sum(5)：5 < 10 直接命中 base case，返回 5。✓
• luhn_sum(52)：last = 2，all_but_last = 5 → 2 + luhn_sum_double(5)。luhn_sum_double(5)：luhn_digit = sum_digits(10) = 1 + 0 = 1，5 < 10 → 返回 1。总计 2 + 1 = 3。✓ 和 doctest 注释里写的 (5*2) + 2 --> (1+0) + 2 --> 3 一字不差。

    if n < 10:
        return n              # 错：忘了这一位也要翻倍

    luhn_digit = last * 2     # 错：漏了 sum_digits

        return last + luhn_sum(all_but_last)        # 在 luhn_sum 里调用了 luhn_sum

10. 递归与迭代：怎么选，怎么互相翻译

课上有一句话值得单独拎出来：「迭代其实是递归的一个特例。」 这不是修辞，是可以验证的事实——任何 while 循环都能机械地改写成递归。

翻译规则

把第 6 节那张对照表提炼成一份可以照着做的清单：

拿第 2 讲写过的「1 加到 n」练一次手（两版都跑过，n = 100 时都得 5050）：

# 迭代版
def sum_to(n):
    i, total = 1, 0
    while i <= n:
        total += i
        i += 1
    return total

# 递归版
def sum_to(n):
    if n == 0:
        return 0
    else:
        return sum_to(n - 1) + n

递归版短得多，而且不需要任何循环变量。但它在 n = 100000 时会 RecursionError，迭代版不会。这就是全部的取舍。

选择清单

本讲小结

动手练习

五道题。先在纸上写出答案，再展开对照——直接看答案等于没做。第 2、3 题请真的把帧画出来。

练习 1：WWPD（输出顺序）

下面这个函数，mystery(3) 会打印什么？按顺序写出每一行。

def mystery(n):
    if n == 0:
        return
    print('down', n)
    mystery(n - 1)
    print('up', n)

down 3
down 2
down 1
up 1
up 2
up 3

练习 2：找 bug（RecursionError）

下面这个函数想数出正整数 n 有多少位。count_digits(4224) 会发生什么？

def count_digits(n):
    if n == 0:
        return 0
    else:
        return count_digits(n // 10) + 1

再看这一个，同样的题目。count_digits(1234) 返回 4，看起来没问题——那 count_digits(4224) 呢？

def count_digits(n):
    if n == 1:
        return 1
    else:
        return count_digits(n // 10) + 1

练习 3：画环境图

对下面的调用，写出：一共新建了几个帧、每个帧里 n 的值、每个帧的返回值。

def f(n):
    if n <= 1:
        return 1
    else:
        return n + f(n - 2)

f(7)

练习 4：写代码（递归 count_up）

实现 count_up(n)，从 1 打印到 n，每行一个。不许用循环，不许用额外参数（调用形式必须是 count_up(5)）。

>>> count_up(5)
1
2
3
4
5

def count_up(n):
    if n <= 0:
        return
    count_up(n - 1)
    print(n)

练习 5：改写成互递归

把下面这个用参数记状态的函数，改写成一对互递归的函数（功能不变：把一个正整数的奇数位——从右起第 1、3、5……位——加起来）。

def sum_odd_positions(n, is_odd_pos=True):
    if n == 0:
        return 0
    last = n % 10
    rest = sum_odd_positions(n // 10, not is_odd_pos)
    if is_odd_pos:
        return last + rest
    else:
        return rest

def sum_odd(n):          # 当前这一位算进去
    if n == 0:
        return 0
    return n % 10 + sum_even(n // 10)

def sum_even(n):         # 当前这一位跳过
    if n == 0:
        return 0
    return sum_odd(n // 10)