Lab 1：函数与控制ok 13 项通过

0. 这份作业在练什么

Lab 0 只是让你把 Python 装上、把 ok 跑起来。Lab 1 是第一份需要你真的动脑子的作业。它总共十道题，分成三类，练的是三件互相独立、但都必须形成肌肉记忆的东西。

第一类是两组 WWPD（What Would Python Display，Python 会显示什么） 概念题（Q1、Q2）。它们不要你写代码，只要你在脑子里当一次 Python 解释器，说出交互式提示符下每一行会打印什么。这类题看起来像脑筋急转弯，实际上是这门课最重要的基本功：你必须清楚地区分「一个函数返回了什么值」和「一个函数在屏幕上打印了什么」。绝大部分初学者的 bug——函数明明「输出对了」但 ok 却判错——根源都在这里。

第二类是 Debugging Quiz（Q3），一组关于读 traceback（回溯信息）、写 doctest、用 print 调试的选择题。它不给分（'points': 0），但它教你的东西会跟着你走完整个学期。

第三类才是写代码：falling、divisible_by_k、double_eights 三道必做题，加上 digit、middle、sum_digits 三道选做题。这六道题背后其实只有两个核心手法：

做之前该掌握什么

你需要知道：怎么用 def 定义一个函数；参数（parameter）和实参（argument）的区别；= 是赋值不是相等，== 才是相等判断；三个除法相关运算符的差别。最后这一条题面里专门复习了，这里再用一张表钉死：

最常用的一个组合技：判断 x 能否被 y 整除，写 x % y == 0。判断偶数就是 x % 2 == 0。Q5 直接用到它。

验证状态

本仓库中 labs/lab01/ 下的代码跑 python3 ok --local，结果是 13 个测试用例全部通过，包括两组 WWPD、Debugging Quiz 以及六道编程题。本页贴出的每一段解答代码，都与 labs/lab01/lab01.py 中通过评分的真实文件逐字一致。

1. WWPD：Return and Print

用 python3 ok -q return-and-print -u 进入这道题。-u 是 unlock（解锁）的意思：ok 会一行一行地把交互式会话念给你听，每到一个空位就停下来问你「这里会显示什么」。答对了才继续。这套题在本仓库中已经解锁完毕，答案存在 labs/lab01/tests/return-and-print.py 里。

题目要什么

给你两个函数定义，然后问你三行交互式命令各自会显示什么：

>>> def welcome():
...     print('Go')
...     return 'hello'

>>> def cal():
...     print('Bears')
...     return 'world'

>>> welcome()
______

>>> print(welcome(), cal())
______

「显示什么」这个说法要精确化：交互式提示符（>>>）下，你敲一个表达式，Python 做两件事——① 执行它，执行过程中任何 print 调用都会立刻把文字打到屏幕上；② 执行完得到一个值，如果这个值不是 None，Python 再把这个值的 repr 形式打到屏幕上。这两件事的输出会按发生顺序混在一起，这就是这道题全部的难点。

怎么想到的

第一次看到这种题，很容易凭直觉答「welcome() 显示 hello」，然后被判错。错在哪？错在你把两条输出通道当成了一条。

正确的做法是：把每一行拆成「执行期打印了什么」和「执行完剩下什么值」两栏，分别填，最后按时间顺序拼起来。

先看 welcome()。调用 welcome，函数体从上往下执行：

所以答案是两行：

Go
'hello'

注意第一行 Go 没有引号（是 print 打的），第二行 'hello' 有引号（是提示符回显的值）。这个引号的有无，就是区分「打印」和「返回」的最直接证据，务必看清。

再看 print(welcome(), cal())。这一行难在求值顺序。一个调用表达式 print(A, B) 的求值规则是：先求算子 print，再从左到右求每个算子数（operand），全部求完之后，才把这些值传给 print 去调用。所以：

答案是三行：

Go
Bears
hello world

为什么是这个顺序

这里有两个必须钉死的点。

第一，为什么 Go 和 Bears 在前，hello world 在后？ 因为参数必须先求值完毕，才能调用外层的 print。welcome() 内部的 print('Go') 发生在「求参数」阶段，而外层 print 的输出发生在「调用」阶段。求参数一定早于调用。

第二，为什么最后一行是 hello world 而不是 'hello' 'world'？ 因为这一行是 print 打的。print 显示的是 str 形式（内容本身），而提示符回显用的是 repr 形式（源代码形式，字符串要带引号）。同一个字符串对象，经过两条不同通道显示出来长得不一样。

验证

把这段真的在终端里跑一遍，你会看到与 labs/lab01/tests/return-and-print.py 中记录的答案完全一致的输出。那个文件里的 'code' 字段就是标准答案（已解锁为明文，并通过了哈希校验）：

>>> welcome()
Go
'hello'
>>> print(welcome(), cal())
Go
Bears
hello world

2. WWPD：What If?

命令是 python3 ok -q if-statements -u。这组题考的是控制流：if 和 elif 到底谁挡住了谁，以及 return 在 if 里出现时函数什么时候跑到底、什么时候中途退出。题面给的 Hint 只有一句：print（不像 return）不会让函数退出。这句话是全部四道小题的钥匙。

先把 if/elif 的规则说死

初学者对 if 最大的误解，是把它当成「筛选器」，以为写在一起的几个条件会各自独立地判断。实际规则是：

热身：so_big

题面里先给了一个例子（这个不在 ok 的测试里，但它是理解后面两道的台阶）：

>>> def so_big(x):
...     if x > 10:
...         print('huge')
...     if x > 5:
...         return 'big'
...     if x > 0:
...         print('small')
...     print("nothin'")

注意这里是三个独立的 if，不是一条链。所以每个都要单独判断——除非中途被 return 打断。

这三个调用一次性演示了三种情形：return 提前退出、print 之后继续、跑到底返回 None。看懂了它们，下面两道 ok 真题就没有新东西了。

ok 真题一：ab

>>> def ab(c, d):
...     if c > 5:
...         print(c)
...     elif c > 7:
...         print(d)
...     print('foo')

>>> ab(10, 20)
______

怎么想到的。 看到 ab(10, 20)，很多人会同时勾选两个条件：10 > 5 真、10 > 7 也真，于是答 10、20、foo 三行。这是把 elif 当成了独立的 if。

正确推演：调用 ab(10, 20)，形式参数 c 绑定 10，d 绑定 20。

答案：

10
foo

这道题的设计很刁：c > 7 比 c > 5 更严格，写成 elif 之后，elif 分支永远不可能被执行——因为任何满足 c > 7 的 c 必然也满足 c > 5，早就被第一个分支截走了。这是真实代码里非常常见的一类 bug：条件顺序写反，导致某个分支成为死代码。

ok 真题二：bake

>>> def bake(cake, make):
...     if cake == 0:
...         cake = cake + 1
...         print(cake)
...     if cake == 1:
...         print(make)
...     else:
...         return cake
...     return make

>>> bake(0, 29)
______
>>> bake(1, "mashed potatoes")
______

先看清结构。 这里有两条独立的链：第一条只有一个 if cake == 0（没有配对的 else）；第二条是 if cake == 1 / else。最后那句 return make 在两条链之外，缩进回到函数体第一层。

关键的陷阱在于第一条链里有一句 cake = cake + 1——它修改了 cake 的绑定。所以第二条链判断 cake == 1 时用的是新值，不是传进来的原值。这就是为什么把两条链写成独立的 if 而不是 if/elif：出题人就是要让第一条链的副作用影响第二条链的走向。

所以 bake(0, 29) 输出三行：

1
29
29

后两行都是 29，但来源完全不同：第二行是 print(make) 打的，第三行是提示符回显 return make 的返回值。这道题故意用整数 29，就是为了让你看不出引号差别、必须靠推理而不是靠眼力。

mashed potatoes
'mashed potatoes'

这两行内容一模一样，唯一的差别就是引号——这是全课最直白的一次「print 输出 vs 值回显」对照实验。如果你能一眼说清为什么第一行没引号第二行有引号，Q1 和 Q2 的知识点就算掌握了。

顺带想一想：else 分支什么时候能走到

bake 的 else: return cake 在上面两个调用里都没被执行。什么时候会执行？当 cake 既不等于 0 也不等于 1 时，比如 bake(5, 'x')：第一条链跳过，第二条链 5 == 1 假 → 走 else → return 5，函数立即结束，最后那句 return make 永远不会被执行到。输出只有一行 5，没有任何 print 输出。（这条不在 ok 的测试里，是自己推的，你可以在 python3 -i 里验证。）

3. Debugging Quiz

命令 python3 ok -q debugging-quiz -u。七道选择题，'points': 0——不计分，但这是整个学期你会反复用到的工具箱。答案在 labs/lab01/tests/debugging-quiz.py 的每个 case 的 'answer' 字段里。下面逐题讲为什么选那个。

题 1、题 2：读 traceback

两道题共用同一段回溯信息：

Traceback (most recent call last):
  File "temp.py", line 10, in <module>
    f("hi")
  File "temp.py", line 2, in f
    return g(x + x, x)
  File "temp.py", line 5, in g
    return h(x + y * 5)
  File "temp.py", line 8, in h
    return x + 0
TypeError: must be str, not int

题 1：最近的一次函数调用是哪个？ 选项是 f("hi") / g(x + x, x) / h(x + y * 5)，答案是 h(x + y * 5)。

理由就写在第一行：Traceback (most recent call last)——最近的调用排在最后。这行英文很多人一扫而过，但它决定了整个 traceback 该从哪头读。这一栈从上往下是「谁调用了谁」的时间顺序：模块顶层第 10 行调用了 f("hi")；f 的第 2 行调用了 g(x + x, x)；g 的第 5 行调用了 h(x + y * 5)；然后在 h 的第 8 行 return x + 0 处炸了。

所以三个候选调用中，h(x + y * 5) 是发生时间最晚的那一个。

题 2：这个错误的原因是什么？ 选项是「代码试图把一个字符串加到一个整数上」/「代码陷入了死循环」/「缺少 return 语句」，答案是第一个。

依据是最后一行：TypeError: must be str, not int。TypeError 是「类型不匹配」，信息直译是「必须是 str，不能是 int」。再看出错行 return x + 0：0 是 int，那么 x 必然是 str——Python 在做 str + int 时抱怨右边不是字符串。

顺着调用链还能把这个 str 的来源追出来：顶层传的是 "hi"（字符串）→ f 里 x + x 就是 "hihi"（字符串拼接，合法）→ 传给 g 之后 x + y * 5 也还是字符串（字符串乘整数是重复，也合法）→ 传给 h，h 里 x + 0 就崩了。类型错误往往在离源头很远的地方才爆炸，这正是要学会顺着调用链回溯的原因。

另外两个选项为什么排除：死循环根本不会产生 traceback（它会一直卡住，除非你 Ctrl-C，那时报的是 KeyboardInterrupt）；缺少 return 也不会报错，只会让函数悄悄返回 None，通常表现为后续的 TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' 之类，错误信息长得不一样。

题 3：doctest 怎么写

问「如何写一个 doctest 断言 square(2) == 4」，四个选项分别用了 doctest: (2, 4)、input:/output:、没有 >>> 的裸调用、以及带 >>> 的标准写法。答案是：

def square(x):
    '''
    >>> square(2)
    4
    '''
    return x * x

doctest 的格式是死的：写在文档字符串（docstring）里，一行以 >>> 加一个空格开头，后面跟要执行的表达式；紧接着的下一行（或几行）写期望在交互式提示符下看到的输出，一字不差。doctest 模块靠的就是 >>> 这个标记去识别测试；没有它的行只是普通说明文字，会被完全忽略——这就是第三个选项（square(2) 后面直接跟 4，但缺了 >>>）错的原因：它看起来像测试，但 doctest 根本不会执行它，你会得到「零个测试全部通过」的假安全感。

「一字不差」这四个字要重视。既然期望输出是照抄提示符的显示结果，那么前面反复强调的规则在这里全部生效：字符串带引号、None 不显示、2.0 和 2 是两回事。>>> falling(4, 0) 下面写 1，你的函数返回 1.0 就算失败。

跑 doctest 的命令题面也给了：python3 -m doctest lab01.py。全部通过时没有任何输出——静默即成功。想看细节加 -v。

题 4：什么时候该用 print 调试

三个选项：「用于永久性调试，从而对代码有长期信心」/「用于确保代码在某些点满足某些条件」/「用于查看代码运行到某处时各变量的值」。答案是第三个。

这道题在划分三种工具的职责，值得用表格钉死：

选项一说的是测试的职责，选项二说的是 assert 的职责，都被安到了 print 头上。print 的价值恰恰在于它轻、快、用完即弃：你怀疑循环变量走错了，就在循环体里插一行 print，跑一次，看清楚，删掉。

题 5：怎么让 ok 忽略你的调试输出

答案：在输出行开头打印 'DEBUG:'。

print("DEBUG:", x)

这条规则的必要性来自 Q5 那种题：divisible_by_k 的正确性一部分体现在它打印了什么，ok 会逐行比对输出。这时你要是为了调试多 print 了一行，测试立刻失败，而且失败信息看起来像是你的逻辑错了，非常误导人。ok 的对策是：凡是以 DEBUG: 开头的输出行一律丢弃，不参与比对。

另外两个选项都是错的：「ok 只看返回值不看打印」不成立（WWPD 题和 divisible_by_k 都比对打印内容）；「用 # 开头」也不行——# 在 Python 里是注释符号，跟运行时的输出内容毫无关系，ok 不认这个。

题 6：怎么开一个交互终端调查失败的测试

问：lab01 里 sum_digits 这道题测试没过，最好用哪个命令开交互终端？四个选项，答案是：

python3 ok -q sum_digits -i

-q sum_digits 指定只跑这一道题；-i（interactive）的作用是：当某个测试用例失败时，ok 会在失败的那一刻打开一个交互式提示符，而且此时环境里已经加载好了你的 lab01.py、以及那个失败用例执行到一半的所有变量。你可以当场敲 sum_digits(4224) 看它到底返回了什么、试试 4224 % 10 对不对。

对比另外三个选项：python3 ok -q sum_digits（不带 -i）只告诉你「期望 12，实际得到 8」，然后就退出了，你还得自己想办法复现；--trace 不是这个用途；python3 -i lab01.py 确实能开交互终端并加载你的函数，但它不知道哪个测试失败了、失败时的输入是什么，你得手动把测试用例再敲一遍。-i 省掉的正是这一步。

题 7：以下哪一条「不」正确

五个选项，问哪个是错的。答案是：

「代码返回一个错误答案总比崩溃好，因为它至少还能工作。」

这句话是错的，而且错得很重要。一个会崩溃的程序远好过一个默默给出错误答案的程序。 崩溃是响亮的：你立刻知道出了事，traceback 还告诉你出在哪一行。而返回错误答案是无声的：它会一路传下去，污染后续所有计算，等你发现时已经查不出源头了——这正是题 1 那个 traceback 的反面教材：那个错误好在它崩了，所以你能顺着栈追到 h 里的 x + 0。

另外四条都是对的，也都值得记：测试对写出健壮代码很重要；调试不能替代测试（调试是事后救火，测试是事前和事后的保障，两者不是一回事）；把调试用的 print 留在发布代码里是坏习惯；把 assert 留在代码里则是好习惯。注意最后两条恰好呼应题 4 的那张表——print 是临时的，assert 是永久的。

4. Falling Factorial falling

题目要什么

def falling(n, k):
    """Compute the falling factorial of n to depth k.

    >>> falling(6, 3)  # 6 * 5 * 4
    120
    >>> falling(4, 3)  # 4 * 3 * 2
    24
    >>> falling(4, 1)  # 4
    4
    >>> falling(4, 0)
    1
    """

翻成人话：从 n 开始往下数 k 个连续整数，把它们乘起来返回。 「往下数 k 个」的意思是这 k 个因子依次是 n、n-1、n-2、……、n-k+1。

四个 doctest 恰好把边界一路收缩给你看：

边界情况就是最后一行：k 为 0 时返回 1。 为什么是 1 而不是 0？因为这是一个连乘。「零个数相乘」的结果按数学惯例是乘法单位元 1，正如「零个数相加」是 0。更实际的理由：只有取 1，递推关系 falling(n, k) = n * falling(n-1, k-1) 才在 k=1 时也成立（falling(4,1) = 4 * falling(3,0) = 4 * 1 = 4）。如果 k=0 返回 0，那所有结果都会变成 0。

注意这里不是普通阶乘。falling(6, 3) 不是 6!，它只乘三项就停。数学上这叫「下降阶乘幂」，记作 \(n^{\underline{k}} = n(n-1)\cdots(n-k+1)\)。

怎么想到的

看到「把一串数乘起来」，脑子里该跳出来的模板是累积循环：搞一个变量存「到目前为止的乘积」，然后让另一个变量走遍所有因子，每走一步就乘进去。这个模板的骨架是固定的：

total = 初始值
while 还有因子:
    total = total * 当前因子
    移到下一个因子
return total

初始值必须是 1（不是 0，否则乘什么都是 0）。剩下要填的只有两个空：「当前因子」用哪个变量？「还有因子」这个条件怎么写？

第一版想法（会崩的那个）。 最自然的写法是搞个计数器 i 从 0 数到 k-1，因子是 n - i：

total, i = 1, 0
while i < k:
    total = total * (n - i)
    i = i + 1
return total

这个是对的，而且 k=0 时循环一次都不进、直接返回 1，边界也自动对了。但它用了两个「新」变量 i 和常量 k，因子要写成 n - i 这种间接形式，读起来隔了一层。

第二版想法：能不能不要计数器？ 观察一下：因子本身就是从 n 一路递减的。既然 n 是个局部变量（形式参数在函数帧里就是普通的局部名字，改它完全不影响调用者），那就直接拿 n 当循环变量，每轮乘完就让 n 减 1。因子直接写 n，不用算。

但这样一来循环条件怎么写？n 在动，k 不动，我需要知道「n 减到多少该停」。答案是：循环开始前先把终点算出来，存在一个变量里。 最后一个要乘的因子是 n - k + 1，所以第一个不该乘的是 n - k。把它叫 stop：

再检查一遍边界。 k = 0 时 stop = n - 0 = n，循环条件 n > n 为假，一次都不进，直接 return total 也就是初始值 1。边界不需要任何特判——这是好设计的标志：如果你发现自己要为边界情况写 if，通常说明主逻辑还能再改改。

代码

def falling(n, k):
    total, stop = 1, n - k
    while n > stop:
        total, n = total * n, n - 1
    return total

逐行看：

total, stop = 1, n - k——这是多重赋值（multiple assignment）。Python 先把右边所有表达式全部求值，得到 1 和 n-k 两个值，然后再一起绑定给左边两个名字。写成两行 total = 1 和 stop = n - k 完全等价，这里合并只是为了紧凑。注意 n - k 用的是此刻的 n（还没被改过），这正是我们要的快照。

while n > stop:——每轮开始前检查一次。stop 不变，n 每轮减 1，所以最多跑 k 轮，一定会终止（对 k ≥ 0 而言）。

total, n = total * n, n - 1——这一行是整段代码的心脏，也是必须用多重赋值的地方。规则重申：右边两个表达式先全部用「旧值」算完，再同时绑定给左边。

n = n - 1          # 先把 n 减了
total = total * n  # 这里乘进去的是减完之后的 n，错！

total = total * n
n = n - 1

return total——注意它在 while 外面（缩进和 while 对齐）。如果误缩进到循环体里，函数第一轮就返回了，falling(6,3) 会得到 6 而不是 120。

验证

手动追踪 falling(6, 3)。进入函数时局部帧里 n = 6，k = 3。第一行执行后 total = 1，stop = 6 - 3 = 3。

因子恰好是 6、5、4 三个，与 doctest 注释 # 6 * 5 * 4 一致，结果 120 ✓。

再用环境图看一眼第 1 轮那句多重赋值，把「先算右边、再绑左边」画清楚：

执行 total, n = total * n, n - 1  之前
┌─ falling 帧 ──────────────┐
│ parent: Global            │
│ n     → 6                 │
│ k     → 3                 │
│ total → 1                 │
│ stop  → 3                 │
└───────────────────────────┘

步骤 A：求右边（全部用旧值）
   total * n  →  1 * 6  →  6
   n - 1      →  6 - 1  →  5      ← 这里的 n 仍是 6

步骤 B：同时绑定
┌─ falling 帧 ──────────────┐
│ n     → 5     （被改）     │
│ k     → 3                 │
│ total → 6     （被改）     │
│ stop  → 3     （不变）     │
└───────────────────────────┘

再快速验一下边界 falling(4, 0)：total = 1，stop = 4 - 0 = 4，条件 4 > 4 为假，循环体一次都不执行，return 1 ✓。

5. Divisible By k divisible_by_k

题目要什么

def divisible_by_k(n, k):
    """
    >>> a = divisible_by_k(10, 2)  # 2, 4, 6, 8, and 10 are divisible by 2
    2
    4
    6
    8
    10
    >>> a
    5
    >>> b = divisible_by_k(3, 1)  # 1, 2, and 3 are divisible by 1
    1
    2
    3
    >>> b
    3
    >>> c = divisible_by_k(6, 7)  # There are no integers up to 6 that are divisible by 7
    >>> c
    0
    """

这道题要做两件事，而且缺一不可：

1. 打印所有满足 1 ≤ i ≤ n 且 i 能被 k 整除的整数 i，从小到大，每个一行。
2. 返回一共打印了多少个数。

这是本次作业里唯一一道同时考察 print 和 return 的题，也正因为如此，它是前两节 WWPD 知识点的最佳落地练习。ok 会同时检查两样东西：屏幕上打印出的每一行文字，以及函数的返回值。

注意 doctest 的写法很讲究：它写成 a = divisible_by_k(10, 2) 而不是直接 divisible_by_k(10, 2)。赋值语句本身没有值，所以提示符不会回显任何东西——这一行下面的 2 4 6 8 10 五行全部是函数体里 print 打出来的，跟返回值无关。返回值被存进了 a，下一行单独敲 a 才回显出 5。这样写就把两条输出通道彻底分开了，你没法蒙混过关。

边界情况在第三个例子：divisible_by_k(6, 7)。 1 到 6 里没有 7 的倍数，所以一行都不打印，返回 0。注意 doctest 里 >>> c = divisible_by_k(6, 7) 这一行下面紧接着就是 >>> c，中间是空的——doctest 用「没有输出行」来断言「什么都没打印」。如果你的函数在这种情况下多打了一个 0，测试就会失败。

再看第二个例子 divisible_by_k(3, 1)：k = 1 时每个数都能被 1 整除，所以 1、2、3 全打印，返回 3。这个例子提醒你循环得从 1 开始，不是从 k 开始也不是从 0 开始——0 能被任何非零数整除（0 % 2 == 0），但题目说的是「正整数」，0 不在范围内。

怎么想到的

第一步：把「所有小于等于 n 的正整数」变成一个循环。 这是最直接的读法——题目说「小于等于 n 的正整数」，那就让 i 从 1 走到 n，一个都不漏：

i = 1
while i <= n:
    ...
    i = i + 1

条件必须是 i <= n（小于等于），不是 i < n。因为 divisible_by_k(10, 2) 的输出里包含 10 本身。这种「差一错误」（off-by-one error）是循环题最常见的 bug，写之前先拿一个 doctest 对一下端点，能省很多时间。

第二步：在循环体里筛。 「i 能被 k 整除」怎么写？题面 Review 已经给了：i % k == 0。这里必须小心一个语义方向——是 i % k 不是 k % i。i % k == 0 读作「i 除以 k 余数为 0」，即 i 是 k 的倍数。搞反了的话 divisible_by_k(10, 2) 会打出一堆奇怪的数（2 % 1 == 0、2 % 2 == 0……方向反了含义就全变了）。

第三步：计数。 题目要返回「打印了几个」。最省事的想法是：打印和计数在同一个地方发生——凡是我 print 了一个数，我就把计数器加 1。把这两句绑在同一个 if 分支里，就永远不会对不上。

第四步：检查边界。 count 初始化成 0（这次是累加，不是累乘，所以起点是 0 不是 1）。divisible_by_k(6, 7) 时循环跑 6 轮，if 一次都不成立，count 保持 0，返回 0，也没打印任何东西 ✓。同样不需要特判。

一条弯路值得提。 有人会想跳着走，让 i 直接从 k 开始、每次加 k：

i = k
while i <= n:
    print(i)
    count = count + 1
    i = i + k

这个版本也是对的，而且效率更高（只跑 n//k 轮而不是 n 轮）。但它有个隐患：如果 k 是 0，i = i + k 就永远不动，死循环。而 i % k 那个版本在 k=0 时会干脆地抛 ZeroDivisionError——崩掉比死循环好（正是 Debugging Quiz 题 7 的道理）。题目保证 k 是正整数，两个版本都能过 ok，本仓库交上去的是逐个检查的那版，因为它跟题目描述「所有小于等于 n 的正整数中……」一一对应，最不容易想错。

代码

def divisible_by_k(n, k):
    count = 0
    i = 1
    while i <= n:
        if i % k == 0:
            print(i)
            count = count + 1
        i = i + 1
    return count

逐行看：

count = 0——累加器初始化。它记录「到目前为止打印了几个」，一开始是零个。

i = 1——循环变量从 1 开始，因为题目要的是正整数。

while i <= n:——包含端点 n。

if i % k == 0:——整除判断。% 的优先级高于 ==，所以它等价于 (i % k) == 0，不用加括号。

print(i) 和 count = count + 1——两句都在 if 体里，缩进相同。这个缩进是本题的正确性关键：count 必须只在打印时才加，否则返回值会变成 n（每轮都加）。

i = i + 1——在 while 体里、if 体外。缩进级别比 print 少一层。这是本题第二个缩进关键点：i 必须每轮都推进，不管这一轮有没有打印。如果误缩进到 if 里面，那么第一个不能整除的 i 就会让循环卡住不动 → 死循环。

return count——在 while 外面。函数结束时把总数交出去。

验证

追踪 divisible_by_k(10, 2)。进入时 n = 10，k = 2，初始化后 count = 0，i = 1。

屏幕上依次出现 2、4、6、8、10 共五行，与 doctest 一致；return count 返回 5，被赋给 a，下一行敲 a 回显 5 ✓。

再验边界 divisible_by_k(6, 7)：i 从 1 走到 6，每轮算 i % 7 得到 1、2、3、4、5、6，没有一个是 0（因为 i < 7 时 i % 7 就等于 i 本身），if 一次都不进。i 变成 7 时条件 7 <= 6 为假，退出，返回 count = 0。屏幕上一个字都没有 ✓。

6. Double Eights double_eights

题目要什么

def double_eights(n):
    """Return true if n has two eights in a row.
    >>> double_eights(8)
    False
    >>> double_eights(88)
    True
    >>> double_eights(2882)
    True
    >>> double_eights(880088)
    True
    >>> double_eights(12345)
    False
    >>> double_eights(80808080)
    False
    """

判断一个数的十进制表示里有没有相邻的两个 8。关键词是相邻——挨着的、中间不隔任何数字。六个 doctest 每一个都在堵一条歧义：

最后一个例子把所有偷懒解法一网打尽。「数一数有几个 8，≥2 就返回 True」——被 80808080 毙掉。「看看有没有 8 出现过两次以上」——同样被毙。必须真的判断「位置相邻」。

还有一个细节：返回值必须是布尔值 True / False，不是 1 / 0，也不是字符串。doctest 比对的是显示文本，1 和 True 显示出来不一样。

怎么想到的

第一个念头：能不能转成字符串？ '88' in str(n) 一行就完事了。这确实能过 ok，但它绕开了这道题真正要练的东西——用算术把一个整数逐位拆开。CS 61A 这个阶段还没讲字符串方法，而且后面 sum_digits、digit、以及未来递归章节的一大堆题都建立在「% 10 取末位、// 10 去末位」这套手法上。所以正经做法是算术。

第二步：建立拆数字的基本动作。 对一个正整数 n：

反复做这两件事，就能从右往左把每一位都过一遍，直到 n 变成 0（这时所有位都取完了）。循环骨架：

while n > 0:
    last = n % 10   # 当前最右位
    n = n // 10     # 砍掉它
    ... 处理 last ...

这个循环一定会终止：n 每轮至少变成原来的十分之一（向下取整），有限步内必然到 0。

第三步：怎么判断「相邻」？这是本题真正的坎。

循环每轮只能看到一位数字 last。要判断相邻，我需要同时知道这一位和上一位。可上一位在上一轮就已经被处理掉了，怎么办？

方案 A（走不通的直觉）：一次取两位。 用 n % 100 == 88 判断末两位是不是 88，然后 n = n // 10（注意只砍一位，不是两位，否则会跳过重叠的位置）。这个方案其实可行：

while n > 9:            # 至少还有两位
    if n % 100 == 88:
        return True
    n = n // 10
return False

它是对的，但有两个容易写错的地方：循环条件必须是 n > 9（剩一位时就没必要看了，写成 n > 0 也不会错但多跑一轮），以及每轮只能砍一位——如果写成 n = n // 100，2882 会先看 82（不是 88），然后 n 变成 28，看 28，还是不是 88，返回 False，错过了中间的 88。这个坑很深。

方案 B（本仓库采用的）：用一个变量记住上一位是不是 8。 与其每轮回头取两位，不如让循环带着记忆往前走：设一个布尔变量 prev_was_eight，含义是「我刚刚看过的那一位是 8 吗」。那么每轮的判断就变成：

这个「用一个变量携带上一步的信息」的模式叫状态变量，是循环编程里最基础也最重要的技巧之一。方案 B 比方案 A 好在：它每轮只关心一位，逻辑更贴近「相邻」这个概念本身，而且天然推广——如果题目改成「三个连续的 8」，方案 B 加个计数器就行，方案 A 要改成 % 1000 且循环条件也得跟着改。

第四步：初始值和边界。 prev_was_eight 一开始设 False——进入循环前我还没看过任何一位，所以「上一位是 8」当然是假的。这保证了 double_eights(8)：唯一一轮里 last = 8，但 prev_was_eight 是 False，不返回 True；更新记忆后循环结束（n 变成 0），走到 return False ✓。

第五步：为什么中途 return True、末尾 return False？ 因为「存在性」问题只需要找到一个证据就能下结论。一旦发现相邻的 88，答案已经确定，没必要继续扫；return True 立刻结束函数，这也是 880088 那种有多处 88 的情况不会重复计算的原因。只有把所有位都扫完一个证据都没找到，才能断言 False——所以 return False 必须在循环外面。

代码

def double_eights(n):
    prev_was_eight = False
    while n > 0:
        n, last = n // 10, n % 10
        if last == 8 and prev_was_eight:
            return True
        prev_was_eight = (last == 8)
    return False

逐行看：

prev_was_eight = False——状态变量初始化。名字起得很实在：它就读作「上一位是 8 吗」。

while n > 0:——只要还有位没处理完就继续。n 归零意味着所有位都取过了。

n, last = n // 10, n % 10——又是多重赋值，又是「右边先全部用旧值算完」。这里必须用多重赋值或者注意顺序：

n = n // 10     # n 已经被砍掉一位了
last = n % 10   # 取的是砍完之后的末位，错位了一格！

last = n % 10
n = n // 10

if last == 8 and prev_was_eight:——两个条件用 and 连起来，必须同时成立。and 是短路（short-circuit）的：先求 last == 8，如果为假就直接得出 False，右边 prev_was_eight 根本不会被求值。在这道题里两边都没有副作用，所以短路只影响效率不影响结果；但求值顺序这件事本身是这门课的核心考点，随时提醒自己。

return True——找到了就立刻结束整个函数，连循环带函数一起退出。这里体现了 return 的「立即终止」语义在算法上的用处：提前退出（early return）。

prev_was_eight = (last == 8)——更新记忆。右边 last == 8 是一个比较表达式，它的值就是 True 或 False，直接赋给变量即可。括号不是必需的（== 优先级高于 =），加上是为了让「把一个布尔值存起来」这件事一眼可见。

这一行必须在 if 外面（与 if 同层，都在 while 体里），因为无论当前位是不是 8 都要更新。这也是唯一能让 80808080 返回 False 的写法。

return False——循环正常结束（没有中途 return True）说明扫完全部位都没找到，返回 False。它在 while 外面。

验证

先追踪正例 double_eights(2882)。初始 n = 2882，prev_was_eight = False。

第 3 轮时当前位是 8、上一位也是 8，立刻返回 True ✓。注意最高位的 2 根本没被检查——找到答案就走人，不必扫完。

再追踪那个杀手锏反例 double_eights(80808080)。数字从右往左依次是 0, 8, 0, 8, 0, 8, 0, 8：

return False ✓。整张表最值得看的是第 3、5、7 轮那一列加粗的 False：每当遇到一个非 8 的数字，记忆就被清零。正是这个清零动作，让四个 8 无法「隔空配对」。如果把最后一行写成 if last == 8: prev_was_eight = True（只置真不清假），那么第 2 轮之后 prev_was_eight 就永远是 True，第 4 轮的 8 会误命中，函数错误地返回 True。

剩下几个 doctest 快速过一遍：double_eights(8)——一轮，last=8 但 prev=False，不命中，n 变 0 退出，返回 False ✓。double_eights(88)——第 1 轮 last=8/prev=False，记忆置 True；第 2 轮 last=8/prev=True，返回 True ✓。double_eights(880088)——从右往左是 8,8,...，第 2 轮就命中，返回 True ✓（另一处 88 压根没走到）。double_eights(12345)——没有 8，prev 全程 False，返回 False ✓。

7. Pick a Digit digit（选做）

题目要什么

def digit(n, k):
    """Return the k-th digit from the right of n for positive integers n and k.

    >>> digit(3579, 2)
    5
    >>> digit(3579, 0)
    9
    >>> digit(3579, 10)
    0
    """
    return ____

取出 n 从右数第 k 位的数字。k 从 0 开始计：k = 0 是个位，k = 1 是十位，k = 2 是百位……如果 n 没有那么多位，返回 0。

拿 3579 对一下：

还有一个额外的硬约束写在题干里：函数体只能有一条 return 语句（"has only a single return statement as its body"），模板里写死了 return ____。也就是说不许写循环、不许写 if，必须用一个表达式一步到位。这个约束才是这道题的真正难点——它逼你从「一位一位剥」的循环思维，切换到「直接算」的表达式思维。

边界情况是 digit(3579, 10)：k 超出位数时返回 0，而且是自动返回，不能靠 if 特判。

怎么想到的

先想「如果允许循环怎么做」。 很自然：把 n 砍 k 次尾巴，然后取末位。

i = 0
while i < k:
    n = n // 10
    i = i + 1
return n % 10

这个能过测试，但违反了「只有一条 return」的要求。不过它把思路点明了：取第 k 位 = 先砍掉右边 k 位，再取新的末位。 两步。

第二步：把「砍 k 次」压成一个表达式。 每砍一次是 // 10，砍 k 次就是除以 10 共 k 次。连续做 k 次整除 10，等价于一次整除 \(10^k\)：

这个等式对整数地板除是成立的（不是显然的，但确实成立：连续两次向下取整除法 (n // a) // b == n // (a*b) 对正整数 a, b 恒成立）。题目 Hint 里提到 built-in pow 函数，其实 Python 的幂运算符 ** 更顺手：10 ** k。

第三步：拼起来。 砍完之后取末位，就是再 % 10：

n // 10 ** k % 10

第四步：检查边界为什么自动对。 这是这个解法最漂亮的地方。digit(3579, 10)：

代码

def digit(n, k):
    return n // 10 ** k % 10

这一行里有三个运算符，全靠优先级和结合性正确断句，值得单独讲。

** 优先级最高，所以 10 ** k 先算，不会被误解成 (n // 10) ** k。

// 和 % 同级且左结合，所以从左往右：先做 //，再做 %。整个表达式实际断句为：

(n // (10 ** k)) % 10

这正是我们要的顺序：先砍掉右边 k 位，再取末位。如果顺序反了（先 % 10 再 // 10**k），你得到的会是 (n % 10) // 10**k——先取末位再除，k > 0 时永远是 0，全错。

验证

逐个追踪三个 doctest：

第二行特别值得留意：10 ** 0 = 1（任何非零数的 0 次方是 1），于是 n // 1 = n——「砍掉右边 0 位」就是「什么都不砍」，语义完全对上。这也是为什么 k 从 0 开始编号在这里比从 1 开始更自然。

再自己验一个中间情况 digit(3579, 1)：10 ** 1 = 10，3579 // 10 = 357，357 % 10 = 7 → 十位是 7 ✓。

8. Middle Number middle（选做）

题目要什么

def middle(a, b, c):
    """Return the number among a, b, and c that is not the smallest or largest.
    Assume a, b, and c are all different numbers.

    >>> middle(3, 5, 4)
    4
    >>> middle(30, 5, 4)
    5
    >>> middle(3, 5, 40)
    5
    >>> middle(3, 5, 40)
    5
    >>> middle(30, 5, 40)
    30
    """
    return ____

三个数里，返回既不是最小也不是最大的那个——中位数。

题目给了两个重要前提，都要吃透：

• 「Assume a, b, and c are all different numbers」——三个数两两不同。这条免掉了所有麻烦：不用考虑 middle(5, 5, 3) 这种「最小和中间是同一个值」的情况。可以放心假设三者构成严格的大小顺序。
• 和上一题一样，只能写一条 return 表达式（"by writing a single return expression"），模板是 return ____。不许 if。

题目还贴心地给了 Hint 和两个内建函数的用法：

>>> max(1, 2, 3)
3
>>> min(-1, -2, -3)
-3

Hint 的原话是：试试把所有数加在一起，然后用 min 和 max 把你不想要的那些减掉。

怎么想到的

没有 Hint 时的第一反应：穷举比较。 三个数排序，无非六种排列，写一堆 if：

if a < b < c or c < b < a:
    return b
elif b < a < c or c < a < b:
    return a
else:
    return c

这是对的（Python 支持 a < b < c 这种链式比较，语义就是 a < b and b < c），但又长又容易漏一种情况，而且违反「只能一条 return 表达式」的要求。看到这种约束就该意识到：出题人知道有个巧妙的算术恒等式，他要你找到它。

顺着 Hint 想。 关键的观察是：三个互不相同的数，恰好可以被划分成三类——最小的一个、最大的一个、中间的一个，一个不多一个不少。也就是说：

移项就直接得到答案：

为什么「三个数互不相同」这个前提不可省。 假设允许重复，比如 middle(5, 5, 3)：min = 3，max = 5，公式给出 5+5+3-3-5 = 5。恰好也对（中间的确是 5）。再试 middle(5, 5, 5)：5*3 - 5 - 5 = 5，也对。看起来还挺鲁棒？但 「中位数」的定义在有重复时本身就模糊了，题目直接排除这种输入，让你不用纠结。做题时看到「Assume ...」一定要读，它是在告诉你「这些情况你不用管」。

代码

def middle(a, b, c):
    return a + b + c - min(a, b, c) - max(a, b, c)

逐部分看：

a + b + c——三个数的总和。

min(a, b, c)——min 是内建函数（built-in function），可以接受任意多个参数，返回其中最小的。max 同理。它们不需要 import，直接用。

- min(...) - max(...)——减法左结合，所以是 ((a+b+c) - min(...)) - max(...)，先减最小再减最大，顺序无所谓，减法在这里是可交换的（都是减）。

整个表达式的求值过程严格遵守这门课的求值规则：先求算子（min 这个名字查到内建函数），再从左到右求算子数（a、b、c 的值），然后调用。 min(a, b, c) 和 max(a, b, c) 是两个独立的调用表达式，各自被完整求值成一个数，然后参与外层的加减运算。

验证

把所有 doctest 逐个代入公式：

四个例子覆盖了「中间的是第三个参数」「中间的是第二个参数」「中间的是第一个参数」三种情况——公式对参数位置完全对称，所以位置根本不影响正确性。这也是它比 if 版优越的地方：if 版必须显式枚举六种排列，公式版一句话覆盖全部。

再展开一次 middle(30, 5, 40) 的完整求值，看清求值顺序：

9. Sum Digits sum_digits（选做）

题目要什么

def sum_digits(y):
    """Sum all the digits of y.

    >>> sum_digits(10) # 1 + 0 = 1
    1
    >>> sum_digits(4224) # 4 + 2 + 2 + 4 = 12
    12
    >>> sum_digits(1234567890)
    45
    >>> a = sum_digits(123) # make sure that you are using return rather than print
    >>> a
    6
    """

把一个非负整数的所有数位加起来。4224 → 4+2+2+4 → 12。

四个 doctest 里第四个最值得注意，它的注释直接把出题意图写在脸上：make sure that you are using return rather than print。它用 a = sum_digits(123) 接住返回值，再单独回显 a。如果你写的是 print(total)，这个测试会显示 6 然后 a 回显出的却是空（None 不显示），立刻露馅。 这是本次作业第三次用不同方式敲打同一件事。

sum_digits(1234567890) = 1+2+3+4+5+6+7+8+9+0 = 45，用来验证多位数不会中途出错。

怎么想到的

这道题是 falling（累积循环）和 double_eights（逐位拆解）的合体，两个模板一拼就出来了。

拆解部分照抄 double_eights：y % 10 取末位、y // 10 砍末位、while y > 0 直到取完。

累积部分照抄 falling，但把乘法换成加法，所以初始值从 1 换成 0：

「初始值取单位元」不是死记的规则，它有明确的理由：初始值必须是「还没累积任何东西时的正确答案」。零个数相加是 0，零个数相乘是 1。这样一来空输入的边界就自动正确——sum_digits(0) 时循环一次不进，返回 0，而 0 的数位和确实是 0 ✓。（0 这个输入不在 doctest 里，但题目说「非负整数」，所以它是合法输入，值得自己验一下。）

代码

def sum_digits(y):
    total = 0
    while y > 0:
        y, last = y // 10, y % 10
        total = total + last
    return total

逐行看：

total = 0——累加器，加法单位元起步。

while y > 0:——只要还有位没取完就继续。y 每轮至少缩小到十分之一，一定终止。注意这里直接改的是形式参数 y——这完全合法，y 在函数帧里就是个普通的局部名字，改它不影响调用者传进来的那个整数（整数是不可变对象，而且这里改的只是局部绑定）。

y, last = y // 10, y % 10——与 double_eights 那行一模一样的写法：右边两个表达式都用旧的 y，算完后同时绑定。last 拿到末位数字，y 变成砍掉末位的部分。

total = total + last——把这一位加进累加器。

return total——在循环外，把累加结果交出去。这一行是第四个 doctest 专门盯着的地方。

验证

追踪 sum_digits(4224)，期望 12。初始 total = 0，y = 4224。

返回 12 ✓，与注释 # 4 + 2 + 2 + 4 = 12 一致。

注意第 4 轮：y = 4 时，4 % 10 = 4（取出唯一那位），4 // 10 = 0（砍掉之后什么都不剩）。正是 4 // 10 == 0 这个事实终结了循环——最高位被取出的同一轮里，y 就归零了。

再看 sum_digits(10)：第 1 轮 last = 0、y = 1、total = 0；第 2 轮 last = 1、y = 0、total = 1；退出，返回 1 ✓。这个例子里数位 0 被正常加进去了（加 0 不改变结果），说明不需要为 0 这个数位做任何特殊处理。

最后一个 doctest 的双通道检查：

10. 整份作业回顾

Lab 1 表面上是十道零散的小题，实际上只教了四件事。把它们抽出来，比记住十个答案有用得多。

一、两条输出通道

这是 Lab 1 最核心、也是最容易被轻视的一课。它被反复考了至少五次：Q1 的 welcome/cal、Q2 的 bake（同一个 29 出现两次、同一句 mashed potatoes 一次带引号一次不带）、Q5 的 divisible_by_k（必须同时打印和返回）、Debugging Quiz 里的 DEBUG: 前缀、Q10 sum_digits 那个专门写着「make sure that you are using return rather than print」的 doctest。

二、循环的四件套

falling、divisible_by_k、double_eights、sum_digits 四道题，代码长得都不一样，骨架却是同一个：

三、整数的算术拆解

贯穿始终的一条铁律：结果该是整数的地方，一律用 //，绝不用 /。 用了 / 结果就变成浮点数，doctest 比对显示文本，2 和 2.0 就是两回事。

四、让边界自动正确

这份作业里有四个边界情况，没有一个需要写 if 特判：

迁移到哪里

最后一句

Lab 1 这十道题，六道能写出来的核心其实只有一句话：你必须能在纸上当一次 Python 解释器。 本页每道题都手动追踪了一遍循环表格或求值步骤，不是为了凑篇幅——那是这门课要求你养成的默认动作。写完代码不确定对不对时，最靠谱的办法永远不是「再改改看能不能过」，而是拿一个具体输入，把每一步的变量值老老实实写在纸上。