欢迎、编程环境、函数与异常 I

0. 本讲导读

CS 61A 的全名是 The Structure and Interpretation of Computer Programs（计算机程序的构造和解释）。你会在这门课里学三门语言：Python、Scheme、SQL。但课程本身不是一门「Python 入门」——三门语言只是载体，真正要教的是四件事：抽象（abstraction）、问题求解（problem solving）、控制复杂度（managing complexity）、以及解释程序语言（interpreting programming languages）。换句话说：怎么像一个计算机科学家那样思考。

这个区别在第一讲就会体现出来。很多入门课讲到函数时会说：「用 def 定义，用括号调用，记住这个语法。」本讲不这样讲。本讲要回答的是一个更笨、也更重要的问题：

这个问题的答案是一套可以手工执行的规则。学会它，你就能在写代码之前预测代码的行为，在代码出错时定位错在哪一步。学不会它，你就只能靠「试一下看看」——而这门课后面的递归、高阶函数、环境图、解释器，全部会因此变成玄学。

本讲的内容分成四块，从外到内：

往后看：下一讲讲控制流（if / while），它会让程序不再是一条直路；再往后是高阶函数、递归。但无论走到哪一讲，「求值一个表达式」这套规则都不会变——后面所有内容都是在这套规则上加东西，而不是替换它。本讲欠下的债，后面每一讲都要还。

关于这门课怎么上

课程材料几乎全在 cs61a.org：讲义、作业、办公时间日历都在那里；答疑在 Ed（edstem.org），作业提交在 Gradescope，教材是免费在线的 Composing Programs。这个夏季学期的评分是 三分之二考试 + 三分之一其余所有，并且有每周一次的 CBTF 小测——课程给出的理由是：频繁的小赌注测试优于一次性的高赌注考试，而且 AI 编程工具让带回家的作业不再能可靠反映理解水平。

关于 AI 的官方立场值得原样记住：让 AI 替你写代码 ❌，把 AI 当文档和学习资源 ✅。给出的理由不是道德说教，而是三个很实在的问题——你愿意做一个只会无脑 vibecode 的人吗？你愿意把自己的思考和技能外包给一家把利润放在你前面的公司吗？以及最要命的一个：如果你连基础都不懂，你凭什么判断 AI 的输出是对的？

1. 编程环境：文件系统、终端与解释器

这一节里没有任何编程思想，全是工具。但它必须放在最前面，因为接下来所有的代码都要在这个环境里跑。如果你从来没用过命令行，这一节请动手把每条命令都敲一遍——光看是学不会的。

文件系统：文件、目录、路径

你的电脑用三个概念组织所有数据：

• 文件（file）：一段有名字的数据。hw01.py、lecture-01.html、一张照片，都是文件。
• 目录（directory），日常叫「文件夹（folder）」：一个装文件和其他目录的容器。目录套目录，形成一棵树。
• 路径（path）：一个文件或目录的位置。

路径有两种写法，课程给的类比非常准确：

相对路径里有两个特殊名字，务必记住，它们在终端里天天用：

• .（一个点）＝ 当前目录
• ..（两个点）＝ 父目录，也就是上一级
• ~（波浪号）＝ 你的家目录（home directory），比如 /home/alice

终端：用打字的方式操作电脑

终端（terminal）是一个基于命令行（文本）的程序，让你用打字而不是点鼠标的方式跟电脑和文件系统交互。Mac 和 Linux 自带；Windows 用户用 WSL（Windows Subsystem for Linux）。

为什么要学这个？因为很多开发工作根本没有图形界面可点——远程服务器、自动化脚本、课程的 ok 自动评分器，都是命令行的。而且一旦熟练，打字比点鼠标快得多。

打开终端，你会看到一个提示符（prompt），大致长这样：

alice@laptop:~/cs61a$ 

拆开看：alice 是用户名，laptop 是机器名，~/cs61a 是当前工作目录（这里表示家目录下的 cs61a），最后的 $ 表示「该你输入了」。不同系统提示符长得不一样，但「当前工作目录」这个信息基本都会显示——它非常重要，因为所有相对路径都是从这里算起的。

下面是本讲演示的全部命令。rm 那条请特别小心。

一个能省下大量时间的小技巧：按上/下方向键可以翻命令历史。刚跑过的一条长命令想改一个字重跑，按一下上箭头就回来了，不用重敲。（另外，很多终端支持按 Tab 补全文件名，这也值得练。）

下面是一次完整的会话，把这些命令串起来看——建议你照着敲一遍：

alice@laptop:~$ pwd
/home/alice
alice@laptop:~$ mkdir cs61a          # 新建目录
alice@laptop:~$ cd cs61a             # 走进去
alice@laptop:~/cs61a$ pwd
/home/alice/cs61a
alice@laptop:~/cs61a$ touch hw01.py  # 造一个空文件
alice@laptop:~/cs61a$ ls
hw01.py
alice@laptop:~/cs61a$ cd ..          # 回到父目录
alice@laptop:~$ pwd
/home/alice

注意提示符里的当前目录是怎么随着 cd 变化的：~ → ~/cs61a → ~。这正是「你站在树上某处」那个心智模型的可视化。

Python 解释器：终端里再套一层

装好 Python 3 之后，在终端里输入 python3 并回车，你会进入 Python 解释器（interpreter）：

alice@laptop:~/cs61a$ python3
Python 3.12.0 (main, ...)
Type "help", "copyright", "credits" or "license" for more information.
>>> 

提示符从 $ 变成了 >>>。这个变化不是装饰——它意味着你现在说的是另一种语言：

>>> ls
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'ls' is not defined

解释器 vs. IDE

解释器很方便，但它是临时的：退出之后你敲过的一切都没了。它适合试代码——想知道 10 // 3 等于几，开一个解释器两秒钟就有答案。

写作业得用 IDE（integrated development environment，集成开发环境），课程演示的是 Visual Studio Code。IDE 把代码存成文件，是永久的，适合写较长的代码，还带一堆软件工程用得上的功能（语法高亮、自动补全、调试器、Git 集成等）。

实际做作业时两者一起用：在 VS Code 里写 hw01.py，同时开一个终端跑测试；想不起来某个表达式的值，就在解释器里试一下。本笔记里所有以 >>> 开头的代码块，都是在解释器里敲的，下面没有 >>> 的行就是解释器回显的结果——你可以照着敲，应该得到一模一样的输出。

2. 值与表达式：Python 拿到 (2 + 2) * 5 之后做了什么

现在开始真正的内容。先立一个贯穿全课的区分：

原始数据类型

原始数据类型（primitive data type）是 Python 内建的、不能再拆的基本类型。本讲用到四种：

关于字符串，三点值得先说清：

• 单引号和双引号完全等价：'hello' 和 "hello" 是同一个值。选哪个只看方便——字符串里本身含单引号时用双引号包，反之亦然。
• 三重引号（''' 或 """）可以写跨多行的字符串。它还有个重要用途：当多行注释用。第 7 节的 docstring 就是它。
• # 是单行注释：从 # 到行尾的内容 Python 完全忽略，写给人看的。

布尔值本讲只是点个名，下一讲会花整整一讲讲它。

表达式：把值组合起来

光有值没用，得能组合它们。表达式就是组合数据的方式，Python 自动为你计算它们的值。先看数值运算：

>>> (2 + 2) * 5
20
>>> 5 ** 2      # 乘方（指数）
25
>>> 10 / 3      # 真除法 true division
3.3333333333333335
>>> 10 // 3     # 地板除 floor division
3
>>> 10 % 3      # 取模 modulo
1

前两行没什么意外：括号改变优先级，** 是乘方（不是 ^，^ 在 Python 里是别的运算）。后三行才是重点，它们是这门课前几周出现频率最高的三个运算符：

// 和 % 是一对：10 // 3 是 3，10 % 3 是 1，而 3 * 3 + 1 = 10。也就是「商」和「余数」。下一讲的 sum_digits（把一个数的各位数字加起来）就是靠 % 10 取出最低位、// 10 砍掉最低位来做的——这两个运算符是「拆数字」的标准工具，务必熟练。

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

字符串上的运算符

+ 和 * 用在字符串上有各自的含义：

>>> 'hello'
'hello'
>>> 'hello' + 'world'
'helloworld'
>>> 'a' * 5
'aaaaa'

+ 是拼接（concatenation），* 是重复。注意 'hello' + 'world' 的结果里没有空格——拼接就是把两串字符原样接起来，不会自作主张加东西。想要空格就自己写：'hello' + ' ' + 'world'。

第一行也值得看一眼：单独求值 'hello'，解释器显示 'hello'——带引号。这是因为解释器显示的是这个值的「代码形式」，引号提醒你「这是个字符串，不是一个名字」。等到第 8 节用 print 时你会看到不带引号的版本，那个区别很重要。

>>> 'Hello, ' + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

3. 名字与赋值：绑定到底是什么

到目前为止，每个算出来的值转眼就丢了。(2 + 2) * 5 得到 20，显示完就没了；下一行想再用这个 20，只能重敲一遍表达式。

解决办法是给值贴一个标签，把它存下来以后用。这就是赋值语句（assignment statement）：

>>> pi = 3.1415926
>>> pi
3.1415926

这两行发生的事情完全不同，必须分开理解：

Global frame
    pi  ──→ 3.1415926

这个「名字 → 值」的对应关系，就是绑定（binding）；装着一堆绑定的那个东西叫帧（frame）；程序启动时就存在的那个帧叫全局帧（global frame）。这三个词从现在起会一直用到期末。

>>> x = 5
>>> x = x + 1
>>> x
6

名字也常被叫做变量（variable）。课程特意提醒：叫「变量」不够准确，因为名字不只能绑定到数值，还能绑定到函数、类等等——第 4 节你就会看到一个名字绑定到一个函数。

多重赋值

>>> x, y = 1, 3
>>> x
1
>>> y
3

一行绑定两个名字。这里的执行顺序有个细节值得记住：Python 先把右边所有表达式全部求值完，然后才做绑定。这让下面这个写法成立：

>>> x, y = 1, 3
>>> x, y = y, x      # 交换两个名字的绑定
>>> x
3
>>> y
1

如果 Python 是「先绑定 x，再绑定 y」，那第二行执行到一半时 x 已经变成 3，接着 y = x 就会让 y 也是 3，交换失败。正因为右边的 y, x 在任何绑定发生之前就已经被求值成了 (3, 1)，交换才是对的。 这又一次印证了那条规则：右边先算完，左边才动。

f-string：把值嵌进字符串

>>> name = 'Rebecca'
>>> f'Hello {name}!'
'Hello Rebecca!'

在字符串的引号前面加一个 f，字符串里 {} 包住的部分就会被当成表达式求值，结果替换进去。这比 'Hello ' + name + '!' 好读，而且不用担心类型转换——大括号里放数字也没问题：

>>> radius = 5
>>> f'半径 {radius} 的圆，面积约 {3.14 * radius ** 2}'
'半径 5 的圆，面积约 78.5'

注意大括号里可以是任意表达式，不只是名字——3.14 * radius ** 2 在这里被完整求值了。忘了写 f 是最常见的错误，结果是大括号原样出现在输出里：'Hello {name}!'。

import：把别人写好的名字拿过来

>>> from operator import mul
>>> mul(10, 5)
50

from 模块 import 名字 的作用，说白了就是一次赋值：它在当前环境里新建一个绑定，把名字 mul 绑定到 operator 模块里的那个乘法函数。执行完之后，全局帧里就多了一条：

Global frame
    mul  ──→ func mul(a, b)      # 来自 operator 模块的内建函数

这一点很重要：函数也是值，可以被名字绑定，跟 3.1415926 被 pi 绑定没有本质区别。第 3 讲的高阶函数整讲都建立在这个观察上。

另一个常用的模块是 math：

>>> from math import pi, sqrt
>>> pi
3.141592653589793
>>> sqrt(16)
4.0

>>> print(hello)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'hello' is not defined. Did you mean: 'help'?

4. 函数：把一组操作打包起来，起个名字

假设你要算三个圆的面积，半径分别是 5、7、10。用目前学的东西，你会写：

>>> from math import pi
>>> pi * (5 ** 2)
78.53981633974483
>>> pi * (7 ** 2)
153.93804002589985
>>> pi * (10 ** 2)
314.1592653589793

能用，但有三个问题：① 同一个公式抄了三遍；② 想改公式（比如改成算周长）得改三处；③ 代码里看不出「这是在算圆面积」这个意图——读代码的人得自己从 pi * (r ** 2) 里反推。

如果要算一百个圆呢？如果半径要等到程序运行时才知道呢？

解决办法是抽象（abstraction）：把这组操作打包，起一个名字，之后按名字使用，不再关心里面怎么算的。这就是函数（function）——也是这门课名字里那个「构造（Structure）」的第一层含义。

>>> from math import pi
>>> def circle_area(radius):
...     return pi * (radius ** 2)
...
>>> circle_area(5)
78.53981633974483

把 def 语句拆开

逐个部件对号入座（这些术语后面会反复用到，请务必记准）：

def circle_area(radius):
    return pi * (radius ** 2)

再看使用的一侧：

circle_area(5)

这叫调用表达式（call expression）：函数名 + 一对括号 + 括号里用逗号分隔的输入。这里的 5 叫实参（argument）——它是你实际传进去的那个值。

函数可以有 0 个或多个输入，也可以返回 1 个或多个输出值（返回多个值时用逗号分隔；严格说那是一个元组 tuple，后面的讲次会讲）。

>>> def circle_area(radius):
...     return pi * (radius ** 2)
...
>>> circle_area
<function circle_area at 0x104a1d3a0>

内建函数

Python 自带一批内建函数（builtins），不用 import 就能直接用：

>>> max(1, 2, 3)
3
>>> min(1, 2, 3)
1
>>> len('hello')
5
>>> print('hello world')
hello world

max / min 取最大最小，len 取长度，print 往屏幕上打字（第 8 节会仔细讲它跟 return 的区别）。

>>> sum(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sum() takes at most 2 arguments (3 given)
>>> sum([1, 2, 3])
6

5. 调用表达式的求值规则

现在回到本讲的母题。circle_area(5) 这个表达式被求值时，Python 到底做了什么？答案是三步，顺序固定，永不改变：

把规则用在一个嵌套的例子上

下面这个表达式是本讲最值得手工推演的一行代码：

>>> from operator import add, mul
>>> mul(add(2, mul(4, 6)), add(3, 5))
208

不要试图心算。按规则一步步来：

把这个过程画出来，就是一棵表达式树（expression tree）——每个调用是一个节点，它的算子和算子数是它的子节点，每个节点上方的方框写着这棵子树求值出来的值：

求值顺序真的会被观察到吗

「从左到右」听起来像是无关紧要的细节：mul(a, b) 里先算 a 还是先算 b，结果不都一样吗？

对于纯计算确实一样。但只要算子数里有副作用（比如打印），顺序立刻就看得见了：

>>> def loud(x):
...     print('DEBUG: 正在求值', x)
...     return x
...
>>> from operator import add
>>> add(loud(1), loud(2))
DEBUG: 正在求值 1
DEBUG: 正在求值 2
3

两行 DEBUG 的先后顺序，就是「从左到右求值算子数」这条规则的直接证据。这个技巧（用 print 观察求值顺序）在后面学短路求值、高阶函数时会非常有用。

>>> def circle_area(radius):
...     return pi * (radius ** 2)
...
>>> circle_area(5, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: circle_area() takes 1 positional argument but 2 were given

6. 环境图：「施加」那一步里到底发生了什么

上一节的第 ③ 步——「把算子施加到算子数上」——被一句「运行函数体里的代码」带过了。但这一步内部还有结构，而且这个结构是 61A 后半程（高阶函数、递归、闭包、面向对象）的全部地基。所以这里把它拆开。

拆开的工具叫环境图（environment diagram）：一张记录「此刻有哪些帧、每个帧里有哪些绑定」的图。它不是 Python 的语法，是我们手工模拟 Python 的记号。你要能拿一张纸把它画出来——考试会考，调试时更靠它。

把 circle_area(5) 完整走一遍

from math import pi

def circle_area(radius):
    return pi * (radius ** 2)

area = circle_area(5)

第 7 步是整张图里最值得盯着看的地方，它回答了本课的第二个母题：名字是怎么被找到的？

为什么形参必须待在自己的帧里

把 radius 关在 f1 里，好处在连续调用时才看得清楚：

>>> circle_area(5)
78.53981633974483
>>> circle_area(7)
153.93804002589985
>>> radius
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'radius' is not defined

两次调用各建各的帧（f1 和 f2），radius 在 f1 里是 5、在 f2 里是 7，互不干扰。而在全局帧里查 radius 会 NameError——因为它从来就不在全局帧里，它只活在函数调用的那个帧里。

函数调用函数

函数体里当然可以调用别的函数，这时会有多个帧同时存在：

def square(x):
    return x * x

def sum_of_squares(a, b):
    return square(a) + square(b)

sum_of_squares(3, 4)

还要注意 f2 和 f3 里的两个 x：它们同名，但分属两个不同的帧，是两个毫不相干的绑定，一个是 3 一个是 4。名字冲突在这套机制下根本不会发生。

7. 函数的完整写法：文档、默认值、类型提示

circle_area 已经能用了，但它还缺一样东西：别人（包括三周后的你）怎么知道该怎么用它？ 参数是什么意思？半径能不能不传？返回的是什么？

下面是这个函数的「完整版」，本讲要求认识它的每一个部件：

def circle_area(radius: float = 1) -> float:
    """Returns the area of a circle
    with the given radius.

    >>> from math import pi
    >>> circle_area()
    3.141592653589793
    >>> circle_area(5)
    78.53981633974483
    """
    return pi * (radius ** 2)

第一行 def circle_area(radius: float = 1) -> float: 叫函数签名（function signature）。它承载了三种信息：

默认参数

radius = 1 给形参一个默认值：调用时不传这个实参，它就用 1。

>>> circle_area()
3.141592653589793
>>> circle_area(5)
78.53981633974483

circle_area() 括号里空着也是一个合法的调用表达式（0 个算子数），此时 radius 绑定到默认值 1，算出 π×1² = π。这也解释了为什么第一个输出恰好是 π 本身。

类型提示

radius: float 和 -> float 是类型提示（type hints）：分别说明「这个参数应该是浮点数」和「返回值是浮点数」。

>>> circle_area('hello')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in circle_area
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Docstring 与 doctest

紧跟在签名下面的那个三重引号字符串叫 docstring（文档字符串），用来说明这个函数做什么。它必须紧贴签名下一行，位置错了就只是一个被丢弃的普通字符串。

docstring 里可以放 doctest：以 >>> 开头的行是「假设在解释器里敲这一句」，下一行是「应该看到的输出」。它一身兼三职：

doctest 真的能跑。假设上面的函数存在 demo.py 里（别忘了文件开头要有 from math import pi）：

$ python3 -m doctest -v demo.py

这条命令会执行 docstring 里的每一行 >>>，把实际输出和你写的期望输出逐字比对，不一致就报告。

def greet(name):
    """
    >>> greet('Ann')
    'Hello, Ann'
    """
    return 'Hello, ' + name

8. return 与 print：本讲最容易出事的地方

如果本讲只能记住一件事，就记这一件。这个混淆会跟着人跑很久，而且它不会报错——代码看起来完全正常，直到某个地方莫名其妙地崩掉。

「拿去用」具体指什么？指把返回值当成另一个表达式的一部分：赋值给名字、参与运算、当成另一个函数的实参。这些事情 print 的输出统统做不到，因为它只是屏幕上的一些字符，程序里根本没有那个值。

对照实验

>>> def square_return(x):
...     return x * x
...
>>> def square_print(x):
...     print(x * x)
...

在解释器里单独调用，两者看起来一模一样：

>>> square_return(4)
16
>>> square_print(4)
16

但这两个 16 的来历完全不同：

差别一旦「拿去用」就暴露了：

>>> square_return(4) + 1
17
>>> square_print(4) + 1
16
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

请仔细看第二个：屏幕上先出现了 16，然后才崩。这正是这个 bug 如此难抓的原因——你明明看见了 16，怎么会说是 None？因为那个 16 是 print 打出来的字符，而 square_print(4) 这个表达式的值是 None，None + 1 当然崩。

None：什么都没有的那个值

本讲课件专门用一页讲它：

>>> def square(x):
...     x ** 2
...
>>> square(2)
>>> print(square(2))
None

这段代码里藏着三个必须分开理解的事实：

print 自己也返回 None——它的工作就是产生「显示」这个副作用，没有值可以交出来：

>>> print(print('hello'))
hello
None

按求值规则走一遍：先求值内层算子数 print('hello')，它打出 hello（第一行），返回 None；然后外层 print(None) 把这个 None 打出来（第二行）。这里的 None 是被显式 print 的，所以看得见。

完整对照表

最后一行值得单独试一次，它是 doctest 里最常见的失分点：

>>> 'hello'
'hello'
>>> print('hello')
hello

def bad(x):
    return x * 2
    print('DEBUG: 算完了')     # 这一行永远不会执行

纯函数与非纯函数

这个区分建立在上面的基础上：

为什么在意这个区分？因为纯函数是可以放心嵌套的。square(square(2)) 完全没问题，因为内层调用只是求出一个值。而嵌套非纯函数就会出现 print(print('hello')) 那种奇观——两个 None 在中间传来传去。

更实际的理由：纯函数好测试。给定输入必得同样输出，一行 doctest 就能钉死它的行为。而一个只 print 不 return 的函数，doctest 写起来就别扭得多。61A 的作业绝大多数要求你写纯函数——题目让你 return 时，就不要用 print 糊弄过去。

9. 异常 I：三类错误与栈追踪

程序出问题时，会发生一个异常（exception），也叫错误（error）。术语上说异常被抛出（raised / thrown）。

本讲把错误分成三类，按调试难度递增排序。这个排序本身就是这一节最有价值的信息：

语法错误

>>> def square(x:
...     return x * x
...
  File "<python-input-21>", line 1
    def square(x:
              ^
SyntaxError: '(' was never closed

括号没闭合，Python 连「这段代码是什么意思」都解析不出来，所以整个文件一行都不会执行。这也是它最好调的原因：错误信息里有行号，有一个 ^ 指着出问题的字符，而且不用管程序逻辑对不对。

常见的语法错误还有：def 或 if 后面忘了冒号、缩进对不齐（IndentationError）、引号没配对、在条件里把 == 写成 =。

运行时错误

>>> def divide(a, b):
...     return a / b
...
>>> divide(5, 0)
Traceback (most recent call last):
  File "<python-input-23>", line 1, in <module>
    divide(5, 0)
    ~~~~~~^^^^^^
  File "<python-input-22>", line 2, in divide
    return a / b
           ~~^~~
ZeroDivisionError: division by zero

def divide(a, b): return a / b 这段代码本身完全合法——a / b 是个正经的表达式。问题出在运行时传进来的 b 恰好是 0，除零没有意义，于是 Python 抛出 ZeroDivisionError。

换句话说：同一段代码，divide(5, 2) 好好的，divide(5, 0) 就崩。 错不在代码的形状，在运行时的值。这就是运行时错误比语法错误难调的原因——你得知道出事时那些变量各是什么。

你会大量遇到的运行时错误：

逻辑错误：最危险的一类

>>> def square(x):
...     return x * 2
...
>>> square(3)
6

没有任何报错。x * 2 是完全合法的 Python，运行时也不会崩。但函数叫 square，它应该返回 9，不是 6——* 应该是 **。

Python 帮不了你，因为它不知道你想要什么。它只是忠实地执行了你写的东西。这类错误只能靠两样东西发现：

• 测试——doctest 里写死 square(3) 应得 9，跑一遍就抓到了。这正是为什么第 7 节说「先读 doctest」。
• 自己动手推演——拿一个具体输入，按求值规则一步步走，看每一步的中间值是不是你预期的。

读栈追踪

运行时错误会给你一份栈追踪（stack trace / traceback）。它信息量很大，但必须从下往上读：

拿前面 divide(5, 0) 那份追踪逐块拆：

10. 调试：print 调试与 assert

print 调试

抓逻辑错误的基本功：在程序的关键位置把感兴趣的变量打印出来，看它们在哪一步偏离了你的预期。方法土，但极其有效——尤其是当你还没学过调试器的时候。

看课件里的例子——求一元二次方程的正根：

>>> from math import sqrt
>>> def quadratic_formula_positive(a, b, c):
...     discriminant = b * 2 - 4 * a * c
...     print("DEBUG: discriminant is", discriminant)
...     temp = (-b + sqrt(discriminant)) / (2 * a)
...     print("DEBUG: temp is", temp)
...     return temp
...
>>> quadratic_formula_positive(1, 3, 2)
DEBUG: discriminant is -2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in quadratic_formula_positive
    temp = (-b + sqrt(discriminant)) / (2 * a)
ValueError: math domain error

两条 DEBUG 只打出了第一条，第二条没来得及打就崩了。这本身就是有用的信息：问题出在第一条和第二条之间那一行。而第一条打出来的值 -2 直接指向真正的 bug：

assert：与其调 bug，不如不让 bug 发生

调试是事后的。有没有事前的办法？有，叫防御式编程（defensive programming）：把自己对程序的假设明确写进代码里，一旦假设被违反就立刻报错。

assert 语句就是干这个的。语法是 assert 条件, '出错时的消息'（消息可选）。条件为真时什么也不发生；条件为假时抛出 AssertionError。

>>> def divide(a, b):
...     assert b != 0, 'divisor cannot be 0'
...     return a / b
...
>>> divide(5, 0)
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    divide(5, 0)
    ~~~~~~^^^^^^
  File "<python-input-0>", line 2, in divide
    assert b != 0, 'divisor cannot be 0'
           ^^^^^^
AssertionError: divisor cannot be 0

对比第 9 节没加 assert 的版本，它报的是 ZeroDivisionError: division by zero。两者都崩了，区别在哪？

关键收益是「早失败」：错误在离根源最近的地方被抓住。真实程序里最难调的 bug，往往是一个坏值在第 10 行产生，一路传到第 200 行才引发崩溃——那时你面对的栈追踪指着第 200 行，而错在第 10 行。assert 就是在坏值传播开之前把它拦下来。

>>> assert(1 == 2, 'boom')
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

三种手段的分工

本讲小结

动手练习

练习 1：求值顺序

下面的代码会输出什么？按什么顺序？

from operator import add

def f(x):
    print('f', x)
    return x + 1

def g(x):
    print('g', x)
    return x * 2

print(add(f(1), g(2)))

f 1
g 2
6

练习 2：这个函数返回什么

下面三个函数，a(3)、b(3)、c(3) 各返回什么？在解释器里直接敲 a(3) 时，屏幕上各会出现什么？

def a(x):
    return x + 1

def b(x):
    print(x + 1)

def c(x):
    print(x + 1)
    return x + 1

练习 3：找出错误的类型

下面每段代码属于哪一类错误（语法 / 运行时 / 逻辑）？会不会报错？

# (1)
def f(x)
    return x

# (2)
def g(x):
    return x / (x - 5)
g(5)

# (3)
def average(a, b):
    return a + b / 2
average(2, 4)

# (4)
from math import sqrt
sqrt(-1)

练习 4：画环境图

写出下面代码执行完之后，全局帧里有哪些绑定，以及过程中建了几个帧。result 最终是多少？

def double(x):
    return x * 2

def add_then_double(a, b):
    total = a + b
    return double(total)

result = add_then_double(3, 4)

练习 5：写代码 + doctest

写一个函数 bmi(weight, height)，返回体重指数 \(\text{BMI} = w / h^2\)（w 单位千克，h 单位米）。要求：给身高一个默认值 1.7；用 assert 保证身高为正；写一条 doctest。

def bmi(weight: float, height: float = 1.7) -> float:
    """Returns the body mass index for the given weight (kg)
    and height (m).

    >>> bmi(68, 1.7)
    23.529411764705884
    >>> bmi(68)
    23.529411764705884
    """
    assert height > 0, 'height must be positive'
    return weight / (height ** 2)