控制：布尔值、条件语句与 while 循环

0. 本讲导读

上一讲把「一个表达式被求值时到底发生了什么」讲清楚了：求值算子、求值算子数、把函数施加到实参上、新建一帧、在帧里绑定形参、执行函数体。有了这套机制，你已经能写出 square、area 这样的函数。

但你写出来的每一个程序都还是一条直路：从上到下，每条语句不多不少执行一次。这样的程序有两件事做不了。

第一件：做不了选择。「求绝对值」这个需求本身就带着一个岔路——输入是负数走一条路，不是负数走另一条路。你没法用一串顺序执行的语句表达「只在某种情况下才执行这几行」。

第二件：做不了重复。「把 1 到 100 全加起来」如果只能顺序执行，你就得手写 100 行 total = total + 1、total = total + 2……那把 1 加到 1000000 呢？更要命的是，重复多少次往往在写代码的时候还不知道——它取决于运行时传进来的那个 n。

本讲补上的正是这两样：分支（branching）用 if / elif / else，迭代（iteration）用 while。而这两样都要先有一个能判断真假的「条件」，所以本讲从布尔值（boolean）讲起。这三块内容合称控制流（control flow）——它决定了「下一条被执行的语句是哪一条」。

往后看：下一讲的高阶函数会把函数当成值传来传去，届时你写的那些被传来传去的小函数，函数体里几乎都装着本讲的 if 和 while。本讲的 sum_digits 就是 Lab 01 的最后一题，而 HW 01 的 Hailstone 是一道纯粹的 while 循环题。这一讲学不扎实，后面每一讲都会卡。

1. 布尔值：程序里的「是」与「否」

布尔值（boolean）是一种原始数据类型（primitive data type），整个类型只有两个值：True 和 False。它用来表示真值（truth value），也就是「是非问句的答案」：

• 你的年龄满 18 了吗？
• 作业和家务都做完了吗？
• 灯开着吗？

为什么要专门有这么一个类型？因为分支和循环都需要一个「往哪走」的依据，而这个依据必须能被程序算出来。把「是非」变成一个可以计算、可以传递、可以命名的值，控制流才有立足点。

>>> age = 21
>>> age > 18
True
>>> age > 21
False

这里最容易被跳过、但其实最重要的一点：age > 18 是一个表达式。它跟 2 + 3 是同一类东西——被求值之后得到一个值。2 + 3 求值成 5，age > 18 求值成 True。不要把它读成「一句问话」，它就是一个值，跟 5 一样普通。

既然是值，就能绑定到名字上，也能被别的表达式当成子表达式使用：

>>> hw_done = True
>>> chores_done = False
>>> can_scroll = hw_done and chores_done
>>> can_scroll
False

第三行执行的是一条赋值语句：先求值右边的 hw_done and chores_done（用到了下一节要讲的逻辑运算符），得到 False，再把名字 can_scroll 绑定到这个值上。名字绑定的规则跟上一讲完全一样，值恰好是布尔值而已。

>>> can_scroll = true
Traceback (most recent call last):
  ...
NameError: name 'true' is not defined

2. 真假性：为什么 if 0: 进不去

如果 Python 只允许布尔值出现在条件的位置，事情会简单很多，但 Python 不是这样设计的。在 Python 里，所有数据类型都能表现得像布尔值，哪怕它根本不是布尔值。

规则只有一句话——记住 falsy 的那张短名单，剩下的全是 truthy：

• falsy（假值）：False、0、0.0、None，以及空容器，例如空字符串 ''。
• truthy（真值）：其他一切。

助记：「是零，或者代表『什么都没有』，就是 falsy」。

下面这张表里的几个值，几乎每个初学者都会栽一次：

>>> -1 == True
False
>>> 1 == True
True

3. 布尔表达式：比较运算符与逻辑运算符

布尔表达式（boolean expression）就是求值成某个 truthy 或 falsy 值的表达式。构造它的方式是：拿值或名字，用运算符拼起来。可用的运算符分两类。

比较运算符

>>> if x = 3:
  File "<stdin>", line 1
    if x = 3:
       ^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

逻辑运算符

三个：and、or、not。它们不是函数，是特殊形式——后面会看到它们的求值规则和普通调用表达式不一样。先看「结果长什么样」的真值表。

and：两边都为真，结果才为真。

or：至少有一边为真，结果就为真。

not：把当前真假翻转。它只有一个操作数。

真值表告诉你结果的真假，但它没告诉你结果究竟是哪个值，也没告诉你 Python 为了算出这个结果做了多少事。这两件事正是下一节的主题，也是这一讲最容易在考试里丢分的地方。

4. 短路求值：and 和 or 到底返回什么

先看一个反直觉的现象：

>>> True and 0
0
>>> 0 or ''
''
>>> 1 and 2
2
>>> '' or 'hi'
'hi'

True and 0 的值不是 False，是 0。1 and 2 的值不是 True，是 2。真值表没骗你（0 确实是 falsy，2 确实是 truthy），但它没说全。

真正的求值规则

求值 <左> and <右>：

求值 <左> or <右>：

把这两条压成一句话：整个表达式的值等于「最后看过的那个操作数」的值，而不一定是布尔类型。

为什么要这样设计？动机是不做多余的计算。and 一旦碰到第一个 falsy 值，结果就已经注定是假了，再算下去没有意义；or 一旦碰到第一个 truthy 值，结果注定为真。能提前退出就提前退出——这就是短路（short circuiting）。

注意 not 不一样：not 永远返回真正的 True 或 False，不返回操作数本身。not 0 是 True，不是 0；not '' 是 True。

运算符优先级

没有括号时，Python 按固定的紧密程度分组。跟本讲相关的部分，从紧到松是：

「紧」的意思是它先把两边的东西抓过去结合。所以 i % 2 == 0 and i % 3 == 0 不需要任何括号——% 比 == 紧，== 比 and 紧，自动分组成 ((i % 2) == 0) and ((i % 3) == 0)，正是我们想要的。

把两件事合起来推演

看幻灯片上那个例子。6 / 0 是一个必然会抛 ZeroDivisionError 的表达式，但下面这行代码平安无事，值是 5：

>>> 5 or (6 / 0) and not None
5

>>> (5 or (6 / 0)) and not None
True

短路的实际用途：守卫

短路不只是个考点，它是写健壮代码的常用手段。想判断「n 不为零，且 100 除以 n 大于 5」：

>>> n = 0
>>> n != 0 and 100 // n > 5
False

安全，因为 n != 0 求值成 False（falsy），and 立刻短路，100 // n 没被计算。左边这个条件叫守卫（guard）：它挡在危险操作前面。

把两边换个位置就崩：

>>> n = 0
>>> 100 // n > 5 and n != 0
Traceback (most recent call last):
  ...
ZeroDivisionError: integer division or modulo by zero

因为 and 必须先求值左操作数，而左操作数里就有 100 // 0。and 和 or 的两边不能随便交换顺序——真值表里它们看着对称，求值过程里它们一点也不对称。

5. 语句、子句与代码块：缩进是语法，不是排版

要讲控制流，先得把「语句」这个词说清楚。

语句（statement）是被解释器执行（execute）以完成某个动作的东西。这和表达式（expression）形成对照：表达式被求值（evaluate），产生一个值。

一条语句可以只占一行（简单语句，如 x = 3），也可以管着一大片代码（复合语句 compound statement）。复合语句的形状长这样：

<header>:
    <statement>
    <statement>
    ...
<separating header>:
    <statement>
    <statement>
    ...
...

三个术语要分清：

• header（头部）：以关键字开头、以冒号结尾的那一行。header 决定这条语句是什么类型——看到 def 就是函数定义，看到 if 就是条件语句，看到 while 就是循环。
• suite（代码块）：header 下面那一整块缩进的语句。
• clause（子句）：一个 header 加上它控制的那个 suite，合起来叫一个 clause。一条复合语句可以由多个 clause 拼成（比如 if 加 elif 加 else 是三个 clause、一条语句）。

核心关系一句话：一个 clause 的 header「控制」跟在它后面的那个 suite——控制它执不执行、执行几次。

到目前为止你只学过一种复合语句：def。def square(x): 是 header，下面缩进的 return x * x 是 suite。本讲要加的 if 和 while，语法形状跟它一模一样，区别只在于 header 决定的执行规则不同：

suite 的执行规则本身很简单：按从上到下的顺序执行里面的每一条语句。复杂的部分全在 header 上——header 决定这个 suite 是执行 0 次、1 次还是 n 次。

TabError: inconsistent use of tabs and spaces in indentation

>>> if 1
  File "<stdin>", line 1
    if 1
        ^
SyntaxError: expected ':'

>>> def f():
... return 1
  File "<stdin>", line 2
    return 1
    ^
IndentationError: expected an indented block after function definition on line 1

6. 条件语句：if / elif / else

动机很直白：怎样才能让一组语句只在某些情况下才执行？ 比如一个课程网站，如果当前用户是助教就显示学生名册，否则把名册页藏起来。用顺序执行的语句写不出「否则」。

解决办法是条件语句（conditional statement），俗称 if 语句。

if <expression>:
    <suite>
elif <expression>:
    <suite>
else:
    <suite>

执行规则（要背下来）

请特别注意规则里的两个词：truthy（不是「等于 True」）和跳过剩下的全部。前者呼应第 2 节，后者是第 8 节 fizzbuzz 那个 bug 的根源。

例子：绝对值

def absolute_value(x):
    if x < 0:
        return -x
    elif x == 0:
        return 0
    else:
        return x

（实际写代码时当然直接用内置的 abs，这里是为了拆开看清楚控制流。）

这条 def 语句的 suite 里只有一条语句——那条由三个 clause 组成的条件语句。三个 clause 分别是 if x < 0: 及其 suite、elif x == 0: 及其 suite、else: 及其 suite。

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

f1: absolute_value  [parent=Global]
    x        ──→ -3
    返回值    ──→ 3        # 由 return -x 产生，函数随即结束

换两个输入再走一遍，重点体会「跳过剩下的全部」：

简化：为什么可以删掉中间那个 clause

def absolute_value(x):
    if x < 0:
        return -x
    else:
        return x

这一版和上一版逻辑等价。怎么确信？把输入空间分区，逐区对比输出——这是判断两段代码是否等价的通用手法，比「看着差不多」可靠得多。

关键在第二行：x == 0 时，return 0 和 return x 给出同一个值，所以那个 elif 是多余的。elif 和 else 本来就都是可选的，而且 elif 可以写任意多个。

三个真实会犯的错

def absolute_value(x):
    if x < 0:
        print(-x)
    else:
        print(x)

>>> y = absolute_value(-3)
3
>>> y + 1
Traceback (most recent call last):
  ...
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

def f(x):
    if x > 0:
        return "pos"

>>> f(-1)
>>> print(f(-1))
None

7. while 循环：把一段代码重复到条件不成立

动机：我想让一组语句执行很多次。 笨办法是复制粘贴代码块——写 1 加到 100 就复制 100 遍。这不只是累，而是根本行不通：重复次数常常取决于运行时才知道的 n，你在写代码的时候压根不知道要粘几遍。

正经办法是迭代（iteration）。while 循环是一种迭代语句：只要某个布尔条件为真，就执行循环体里的全部内容。

while <condition>:
    <suite>

Demo：把 1 到 100 全加起来

先看错的那版：

>>> i = 1
>>> total = 0
>>> while i <= 100:
...     total += i
...
<runs forever, infinite loop>

正确的版本只多一行：

>>> i = 1
>>> total = 0
>>> while i <= 100:
...     total += i
...     i += 1
...
>>> total
5050

逐轮追踪（只列头尾，中间同理）：

注意最后一行：循环体一共执行了 100 次，但条件被求值了 101 次。最后那次求值为假，才把控制流放出来。写循环时想清楚「条件最后一次为假时各个名字是什么值」，能省掉大量差一错误。

循环三要素

顺带说清 +=

total += i 完全等价于 total = total + i。它是一条赋值语句，执行过程是：先求值右边的 total + i，再把结果重新绑定到左边的名字 total。同理 i += 1 是 i = i + 1，y //= 10 是 y = y // 10，i -= 1 是 i = i - 1。

>>> total += 1
Traceback (most recent call last):
  ...
NameError: name 'total' is not defined

同一件事的其他写法

>>> i = 1                   >>> i = 100
>>> total = 0               >>> total = 0
>>> while i < 101:          >>> while i > 0:
...     total += i          ...     total += i
...     i += 1              ...     i -= 1
...                         ...
>>> total                   >>> total
5050                        5050

右边这版值得看一眼：条件从 i <= 100 变成 i > 0，更新从 += 1 变成 -= 1。它循环体也执行 100 次，加的是 100、99、98……1，顺序反了但和不变。

while 循环和环境图

把上面这段代码放在全局帧里跑，环境图是这样的：

Global frame
    i      ──→ 1 → 2 → 3 → … → 100 → 101      # 同一个名字被反复重新绑定
    total  ──→ 0 → 1 → 3 → 6 → … → 5050

（整个过程中一共只有一个帧。while 不新建帧。）

8. 实战一：add_all_even_div_three

随堂练习的起始代码在 02.py。题面：实现 add_all_even_div_three(n)，接收一个正整数 n，返回 1 到 n 之间既是偶数、又能被 3 整除的所有数之和。

def add_all_even_div_three(n):
    """
    Return the sum of all even numbers from 1 to n that are divisible by 3.

    >>> add_all_even_div_three(10) # 6
    6
    >>> add_all_even_div_three(20) # 6 + 12 + 18
    36
    >>> add_all_even_div_three(30) # 6 + 12 + 18 + 24 + 30
    90
    """

题目到底要什么

把 doctest 翻译成人话，重点看第三个：n = 30 时答案是 6 + 12 + 18 + 24 + 30 = 90。30 本身被算进去了。 这告诉你「从 1 到 n」是闭区间，n 要包含在内。这个细节直接决定循环条件写 <= 还是 <。

另一个边界：n = 1 时，1 到 1 之间没有满足条件的数，函数应当返回 0（空和）。doctest 没测这条，但一个把 total 初始化为 0 的实现自动就对了。

怎么想到的

第 4 步是这道题真正的思维跨度：题目用自然语言描述的性质，你得翻译成一个能求值成布尔值的算术表达式。 后面两道题会一再用到 %。

代码

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

def add_all_even_div_three(n):
    i = 1
    total = 0
    while i <= n:
        if i % 2 == 0 and i % 3 == 0:
            total += i
        i += 1
    return total

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

这张表里有四行错误全部源自缩进。回到第 5 节那句话：在 Python 里缩进是语法。i += 1 和 return total 各自属于哪个 suite，是这道题唯一真正的难点。

def add_all_even_div_three(n):
    i = 1
    total = 0
    while i <= n:
        if i % 2 == 0 and i % 3 == 0:
            total += i
        i += 1
        return total          # 错：缩进多了一层

手动验证：n = 10

doctest 说答案是 6。逐轮追踪一遍，顺便观察 and 的短路：

注意第 1、3、5、7、9 行：i 是奇数时左操作数就是 False，and 短路，i % 3 == 0 那半边根本没算。短路不只是考试题，它在每一次循环里都在悄悄省事。

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

f1: add_all_even_div_three  [parent=Global]
    n      ──→ 10                        # 形参，由实参 10 绑定，全程不变
    i      ──→ 1 → 2 → 3 → … → 10 → 11   # 循环体里被反复重新绑定
    total  ──→ 0 → … → 6                 # 只在 i = 6 那一轮变过
    返回值  ──→ 6

三点值得记：

• n 也住在 f1 里，它是形参绑定的名字，和 i、total 平起平坐。
• i 和 total 是函数体里第一次赋值时创建的局部名字。它们只存在于 f1，函数返回后这一帧就不再被用到，外面看不到 i 和 total。在全局作用域里敲 i 会得到 NameError。
• 循环跑了 10 轮，图上始终只有 f1 这一个帧。

def add_all_even_div_three(n):
    i = 6
    total = 0
    while i <= n:
        total += i
        i += 6
    return total

9. 实战二：fizzbuzz —— 条件顺序为什么要命

题面：实现 fizzbuzz(n)，接收一个正整数 n，打印 1 到 n 的数字，其中 3 的倍数换成 "fizz"，5 的倍数换成 "buzz"，同时是 3 和 5 的倍数换成 "fizzbuzz"。

>>> fizzbuzz(5)
1
2
fizz
4
buzz
>>> fizzbuzz(15)
1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizzbuzz

题目到底要什么

第一件要认清的事：这道题打印，不返回。doctest 里 >>> fizzbuzz(5) 下面那五行是 print 打出来的，不是返回值。

能不能用 return 蒙混？fizzbuzz(1) 那条碰巧看不出区别（return 1 也会让解释器显示 1），但 fizzbuzz(3) 要求输出三行，而一次函数调用只能 return 一次——return 一执行函数就结束了。「要输出多行」本身就排除了 return。

第二件：fizzbuzz 没有 return 语句，所以它返回 None。doctest 里看不到 None，是因为交互式解释器拿到 None 时什么都不显示。这正好是 return 与 print 的经典对照：

怎么想到的

回到第 6 节的执行规则：条件语句最多执行一个 suite，一旦某个条件为真，剩下的全部跳过。 而这三个条件不是互斥的——满足「3 和 5 的倍数」的数（15、30、45……）同时也满足「3 的倍数」和「5 的倍数」。用集合的说法，「fizzbuzz 的数」是「fizz 的数」的一个子集。

代码

02-sol.py 的实现（实测 doctest 通过）：

def fizzbuzz(n):
    i = 1
    while i <= n:
        if i % 3 == 0 and i % 5 == 0:
            print("fizzbuzz")
        elif i % 3 == 0:
            print("fizz")
        elif i % 5 == 0:
            print("buzz")
        else:
            print(i)
        i += 1

最特殊的 fizzbuzz 排第一，然后是两个单条件，最后 else 兜底。i += 1 在 while 的 suite 里、在整条条件语句之后、和 if 平级——它必须每轮都执行，不管走的是哪个分支。函数末尾没有 return，因为题目只要求打印。

逐步推演三个关键的 i

把顺序写反会发生什么（真实输出）

下面这版是初学者最常写出来的，看上去「三个条件都写全了」：

def fizzbuzz_bad(n):
    i = 1
    while i <= n:
        if i % 3 == 0:
            print("fizz")
        elif i % 5 == 0:
            print("buzz")
        elif i % 3 == 0 and i % 5 == 0:     # 永远走不到这里
            print("fizzbuzz")
        else:
            print(i)
        i += 1

fizzbuzz_bad(15) 的实际输出，最后一行是 fizz 而不是 fizzbuzz：

1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizz          <-- 应该是 fizzbuzz

10. 实战三：sum_digits —— 用算术把一个数拆开

这道题同时是 Lab 01 的最后一题（Q10）。题面：实现 sum_digits(y)，接收一个正整数，返回它各位数字之和。

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
    """

题目到底要什么

前三条 doctest 直白。值得琢磨的是最后两条——注释都写在脸上了：make sure that you are using return rather than print。

它是这样抓人的：如果你把结果 print 出来而不是 return，那么 sum_digits(123) 会先在屏幕上打一个 6，然后返回 None。a = sum_digits(123) 这行的期望输出是空（赋值语句不显示任何东西），但你的版本会打出一个 6，doctest 当场失败；就算蒙混过去，下一行 >>> a 期望显示 6，而 a 是 None，解释器什么都不显示，又失败。把返回值先存进一个名字再检查——这是 61A 全学期用来分辨 return 和 print 的标准手法，以后你会反复见到。

怎么想到的：手上只有一个整数

这是本讲最值钱的一次思维跨度，所以把弯路也写出来。

代码

讲义 02-sol.py 的版本：

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

逐行：

• total = 0：累加器初始化。空和是 0，所以 sum_digits(0) 会返回 0（循环一次都不进）——题目保证正整数，不用管，但知道这个行为有助于理解「循环体可能执行 0 次」。
• while y > 0:：只要 y 还有位数就继续。
• digit = y % 10：取出当前最低位，起个名字方便读。
• total += digit：累加。
• y //= 10：更新，砍掉最低位。这一句就是让循环能终止的那一句。
• return total：和 while 平级，循环彻底跑完才交出答案。

手动追踪：sum_digits(4224)

和 doctest 的 12 一致。注意第 4 轮：4 // 10 是 0（商 0 余 4），正是这一步把 y 送到了 0，循环才停下来。

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

f1: sum_digits  [parent=Global]
    y      ──→ 4224 → 422 → 42 → 4 → 0     # 形参也可以被重新绑定
    total  ──→ 0 → 4 → 6 → 8 → 12
    digit  ──→ 4 → 2 → 2 → 4               # 第一轮才被创建出来
    返回值  ──→ 12

>>> n = 4224
>>> sum_digits(n)
12
>>> n
4224

Lab 01 官方那一版：多重赋值

本仓库里 labs/lab01/lab01.py 中真实通过 ok 的写法是这样的：

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

它把「砍掉个位」和「取出个位」合并成一行。要看懂这一行，得知道多重赋值（multiple assignment）的执行规则：

def sum_digits_wrong(y):
    total = 0
    while y > 0:
        y = y // 10          # y 先被改了
        last = y % 10        # 这里取的是「砍过一位之后」的个位，取错了
        total = total + last
    return total

其余三个真实会犯的错

def sum_digits(y):
    total = 0
    while y > 0:
        digit = y % 10
        total += digit
        y //= 10
        return total          # 错：缩进多一层

>>> -123 // 10
-13
>>> -13 // 10
-2
>>> -2 // 10
-1
>>> -1 // 10
-1

自己动手跑一遍

把实现写进 02.py 之后，用讲义给的命令跑 doctest：

python3 -m doctest 02.py

没有任何输出就是全部通过。 这一点常让人困惑——很多人以为「什么都没显示」意味着命令没跑起来。想看细节就加 -v：

python3 -m doctest 02.py -v

失败时它会明确打出 Expected: 和 Got: 两段，逐字符对比。把这两段读清楚，往往比重读一遍自己的代码有用得多。

本讲小结

动手练习

五道题。先自己在纸上写出答案，再打开折叠对照——直接看答案等于没做。

练习 1：WWPD（布尔表达式）

写出下列每个表达式的值。不要只写「真」或「假」，要写出具体是哪个值。

>>> 1 and 0 or 2
>>> not 0 and 3
>>> '' or 0
>>> 0 or '' or None
>>> 2 or 1 / 0

练习 2：WWPD（条件语句）

下面这个函数把本该用 elif 的地方写成了两条独立的 if。写出 g(7)、g(3)、g(-1) 各自打印什么（一行一个）。

def g(x):
    if x > 5:
        print("big")
    if x > 0:
        print("positive")
    else:
        print("nonpositive")

练习 3：找 bug

下面这个函数想返回 1 到 n 之间所有偶数的和。f(6) 会发生什么？

def f(n):
    i = 1
    total = 0
    while i <= n:
        if i % 2 == 0:
            total += i
            i += 1
    return total

def f(n):
    i = 1
    total = 0
    while i <= n:
        if i % 2 == 0:
            total += i
        i += 1
    return total

练习 4：写代码

实现 count_digits(n)，返回正整数 n 的位数。count_digits(4224) 应得 4，count_digits(7) 应得 1，count_digits(1234567890) 应得 10。

def count_digits(n):
    count = 0
    while n > 0:
        count += 1
        n //= 10
    return count

练习 5：循环退出时的值

下面这个循环的条件是 i < n，但更新是 i += 2。h(5) 返回什么？h(6) 呢？h(0) 呢？

def h(n):
    i = 0
    while i < n:
        i += 2
    return i