第 7 章　流程控制：条件与分支

7.1程序为什么需要「选择」

回顾前几章的程序：它们都是死板的直线——从上到下，一句句执行，没有岔路。但现实的问题几乎都需要「看情况」：

• 「如果余额足够，就扣款；否则提示余额不足。」
• 「如果成绩 ≥ 60，就显示及格；否则显示不及格。」
• 「如果今天是周末，就睡懒觉；否则早起。」

这种「根据条件决定走哪条路」的能力，叫 流程控制（control flow）里的条件分支（branching）。它让程序从「只会照着做」进化成「会看情况做」——这是程序「智能感」的第一个来源。

深入一步：程序世界只有三种「走法」

把视角拉高一点：无论多大的软件，代码的走向其实只有三种基本形态——顺序（一句接一句往下走）、分支（在岔路口挑一条走）、循环（绕圈重复）。这不是经验之谈，而是被严格证明过的结论：1966 年，计算机科学家 Böhm 与 Jacopini 证明了「任何可以写出来的程序，都能只用顺序、分支、循环这三种结构组合出来」，它后来被称为结构化程序设计的基石定理。本教材安排的章节次序，正是沿着这条定理铺开的：顺序结构在前面几章不知不觉地用熟了，本章补上分支，下一章补上循环，三块拼图凑齐，你就有了写出任何程序的全部积木。

三种结构里，顺序是 CPU 的默认状态——它生来就会「取一条指令、执行、再取下一条」；分支和循环则都要靠上一章说的「跳转指令」来实现。换句话说：程序的全部「活力」，都来自对默认顺序流的打断。值得再想一层的问题：分支到底「智能」在哪里？其实一点都不神秘——程序并不「理解」条件，它只是把条件算成一个布尔值，然后按真值机械地选路。所谓「程序会判断」，本质是「数据决定路径」。分支的价值不在聪明，而在于让同一段代码面对不同数据时表现出不同行为——这一件事就足以支撑起检查、告警、放行、计费等一切「看情况」的业务规则。

temp = 318
if temp > 300:
    print("刹车温度超限，请等待降至 250°C 以下再继续")
print("检查流程继续")

辨析：分支与循环是仅有的两种「打断」

顺序执行的程序像笔直的公路；分支是岔路口（选一条，不回头），循环是环岛（绕回起点再来一圈）。两者在底层都靠「改写程序计数器」实现，区别只是方向：分支往前跳，循环往回跳。后面每一章——函数、列表、文件——都建立在这三种结构的组合之上，所以这一章值得慢下来，把每个细节真正吃透。

再进半步：不要发明「第四种走法」

结构定理的另一半含义常被忽略：既然三种结构已经「足够」，就不必也不该发明第四种走法。初学者最常发明的第四种走法，是用复制粘贴一百行来代替循环，或用一堆长得一样的独立 if 来代替 elif 链——程序照样能跑，但你正在放弃语言已经递到手上的最佳工具，并且给未来埋下一堆「改一处漏一处」的隐患。读代码时识别「这里其实在重复」、写代码前自问「这该用哪种结构」，本身就是程序设计直觉的第一课：结构选对，代码就短一半。

7.2if：条件为真才执行

最基础的分支是 if 语句。它的结构是：

if 条件:
    要执行的代码   # 注意前面有缩进

它的含义是：如果「条件」为 True，就执行下面缩进的代码；如果为 False，就跳过它，什么也不做。

看一个完整例子，并逐行解释：

age = 20
if age >= 18:
    print("你是成年人了")
print("程序结束")

1. age = 20：把 20 存进变量 age。
2. if age >= 18:：计算 age >= 18，即 20 ≥ 18，结果是 True。
3. 因为条件为 True，执行缩进的 print("你是成年人了")，屏幕打印这句话。
4. print("程序结束")：这条没有缩进，不属于 if，无论条件真假都会执行。

深入一步：条件位置上的「真值测试」

if 冒号前面的那个「条件」，在 Python 里要经历一个严谨的求值过程：先把表达式的值算出来，再做一次「真值测试」。比较运算 age >= 18 的结果是一个货真价实的布尔值（True 或 False），if 拿到它直接定夺。但 Python 的宽容在于：即使条件位置放的不是布尔值，它也能测——数字 0、空字符串 "" 会被判为「假」，其余几乎一切（非零数字、非空字符串）都是「真」。这个机制叫真值测试（truthiness）。

count = 0
if count:              # 0 被判为假，这行不打印
    print("有剩余")
if "保养记录":           # 非空字符串，判为真
    print("记录存在")

（机器实测：只打印「记录存在」。）真值测试让代码可以写得像自然语言——「如果有记录就……」「如果还有剩余就……」。不过对初学者，更稳妥的习惯是把条件写成明确的布尔表达式（count > 0、records != ""），让意图一目了然；简写留给熟练以后再享受。

还有一个值得停一秒的事实：True 和 False 本身也是值，可以存进变量、可以互相比较。判断条件的本质，是程序在运行的那个瞬间，把一串数据「归约」成一个布尔值，再交给 if 去选路。第 6 章学的运算符优先级，决定了这串归约的先后次序——这也是复杂条件建议加括号的原因：括号不是给机器看的，是给人看的。

oil = 3.2
if oil < 4.5:
    print("警告：滑油油量偏低")
print("检查结束")

辨析：单分支 if 什么时候够用？

「告警后继续」和「告警后停下」是两种不同的业务：前者是提示类（油量偏低，但检查单还得走完），用单分支；后者是否决类（重量超限，直接拒绝放行），「不满足时必须做另一件事」，这就需要 else（或第 9 章的 return）。写分支前先问自己：条件不满足时，是真的什么都不用做，还是必须做另一件事？想清楚这句，if 要不要带 else 就自动清楚了。这是从「会写语法」到「会写逻辑」的第一道分水岭。

再进半步：if flag == True 为什么是坏味道

既然条件位置上放的是「真值」，那么 if flag == True: 就是绕了远路——先拿 flag 和 True 比较出一个布尔值，再让 if 对这个布尔值做真值测试。直接写 if flag:，语义完全相同、短了一半。类似地，if flag == False: 应写成 if not flag:。这不是语法错误，而是可读性坏味道：它悄悄暗示「作者还没想通布尔值本身就能当条件用」。反过来倒是提醒我们：真值测试虽好，只该用在「变量本身就是布尔含义」的场合——存的是温度、油量这类数值时，还是老老实实写 temp > 300，把比较做完整。

7.3else 与 elif：多路分支

光有 if 只能「做或不做」。要处理「二选一」，需要 else：

score = 55
if score >= 60:
    print("及格")
else:
    print("不及格")

else 的含义是：「否则」——if 的条件不成立时，就执行 else 下面缩进的代码。它和 if 是一对，永远只走其中一个。

elif：三选一、多选一

当情况超过两种，用 elif（else if 的缩写，意为「否则如果」）串联：

score = 85
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

它的执行规则是从上到下依次判断，第一个为真的分支被执行，其余全部跳过。score = 85 时：第一个条件 85≥90 为假，跳过；第二个条件 85≥60 为真，打印「及格」，后面的 else 不再执行。

深入一步：elif 链的「拦截」本质与区间顺序

elif 链的规则只有一条：自上而下依次测试，第一个为真的分支生效，其余全部跳过。这句话里藏着一个强大的推论：排在前面的条件「拦截」了它覆盖的区间，后面的条件根本不必再管前面已经排除的情况。比如成绩五档：

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

能走到 elif score >= 80 这一行的，必然已经不满足 >= 90——所以这里不必写 80 <= score < 90，只写下边界就够。这就是「区间条件沿同一方向排列（从高到低只写下边界，或从低到高只写上边界）」的写法。它的反面是危险的顺序错误：若把 score >= 60 挪到最前面，一个 95 分的学生会在第一关就被判成「及格」，后面所有条件再无机会执行——这不是语法错误，程序照常运行，只是逻辑错了。这种「静默的逻辑错误」比报错可怕得多：机器不吭声，结果悄悄错。

再看边界值的归属：score 恰好等于 90 走「优秀」（≥ 先到先得），恰好等于 60 走「及格」。写完任何一条 elif 链，把每个边界值各代入一次是固定动作——边界，永远是分支逻辑最容易出错的地方。

weight = 45
if weight <= 20:
    fee = 0
elif weight <= 40:
    fee = (weight - 20) * 25
else:
    fee = (40 - 20) * 25 + (weight - 40) * 40
print("托运费：", fee, "元")

辨析：elif 链 vs 连续多个独立 if

elif 链是「互斥的多选一」：最多走一条。写成多个独立的 if，则是「各自判断、可能全中」：把五档成绩写成 5 个独立 if，85 分会同时满足 >= 80 与 >= 60 两条，打印两行。判断标准一句话：各分支互相排斥（一个值只能属于一档）用 elif 链；各条件互不干扰、可同时成立（「超重提示」和「超尺寸提示」可以同时发生）用独立 if。选错结构，逻辑从第一行就错了。

7.4底层原理：条件判断就是「跳转」

现在扒开 if 的「外衣」，看它在硬件层面到底是什么。这需要回到第 1 章的「取指-译码-执行」循环。

CPU 里有一个叫 程序计数器（Program Counter，PC）的寄存器，它始终指向「下一条要执行的指令」的地址。正常情况下，每执行完一条指令，PC 就自动加 1，指向下一条——这就是程序「从上到下」执行的硬件真相。

而 if 语句，翻译成机器码后，本质是两类指令的配合：

1. 比较指令（CMP）：比较两个数，把结果（相等、大于、小于）记到一个标志位里。
2. 条件跳转指令（如 JE「相等就跳」、JNE「不等就跳」）：根据标志位，直接改写 PC 的值，让 CPU 跳到别的地方去执行，而不是顺序往下。

深入一步：比较不改值，只「立旗」

把 if 的底层再挖深一层。比较指令（如 CMP）有个反直觉的设计：它不产生结果数字，只是把比较的「结论」记录到几个一位的开关里——这些开关叫标志位（flags），一些资料也称条件码。最常用的三个：ZF（零标志，两数相等时亮起）、SF（符号标志，差为负时亮起）、CF（进位/借位标志，减法发生借位时亮起）。可以把标志位想象成一排指示灯：比较指令负责「点灯」，跳转指令负责「看灯办事」——JE 见 ZF 灯亮就跳，「小于就跳」的指令看 SF 与 CF 的组合。条件跳转一旦决定跳，就把「灯的结论」换成对程序计数器 PC 的一次改写。整个 if 的机器生涯，就是点一次灯、看一次灯、（可能）改一次 PC。

再看 else 的真相：机器码里根本没有 else 这个东西。所谓 else 分支，只是「if 分支末尾那条无条件跳转（JMP）所绕开的那段代码」。if/else 在高级语言里是对称的一对，在机器层面则完全不对称——一个靠条件跳转进入，一个靠无条件跳转绕过。你写 else: 时的轻松，是编译器替你安排好跳转的结果。

顺带一提：现代 CPU 为了跑得快，会在还没算完条件之前就猜一把「跳不跳」，这叫分支预测。猜对了白赚时间，猜错就得把已经开始的工作作废重来。所以「条件简单、分支规整」的代码不只是好看，也真的更快——好结构会在硬件层面收到回礼。

age = 16
if age >= 18:
    print("成年")
else:
    print("未成年")
print("检查结束")

① CMP age, 18      # 比较：把"谁大谁小"记入标志位
② JL  ⑤            # 若 age < 18，跳到 ⑤（跳过 if 分支）
③ 打印 "成年"      # ← if 分支
④ JMP ⑥            # 无条件跳到 ⑥（绕过 else 分支）
⑤ 打印 "未成年"    # ← else 分支
⑥ 打印 "检查结束"   # ← 汇合点

工程应用与辨析

这套「点灯 + 看灯跳转」的机制，从上世纪的真空管计算机一路沿用到今天的手机芯片，几乎没有变过。无论你将来写 Python、C 还是 Java，if 的底层都是同一件事。这给初学者一个重要的安慰：语法千差万别，内核只有一套——把「比较点灯、跳转改道」想明白，你就拿到了一把跨语言通用的钥匙。反过来，「程序跑飞」「指令乱序」这类故障，根源也常在跳转：控制流是程序的生命线，改写 PC 的权力必须被严加管束——这也是为什么高级语言要发明 if/else 这样的结构化语法，把危险的跳转权从你手里收走、交给编译器。

证据窗口：亲眼看一眼 if 的字节码

「跳转」不是比喻，是可以亲眼看到的。Python 自带一个 dis 模块，专门把代码反汇编成解释器逐条执行的指令。把 if x > 18: pass 喂给它，会看到两步关键动作：先 COMPARE_OP（做比较、点灯），紧接着 POP_JUMP_IF_FALSE——名字里赫然写着 jump：条件为假就跳到另一处继续执行（不同 Python 版本的指令名略有出入，但「比较 + 跳转」的本质不变，机器实测即此两条）。你写下的是缩进整齐的高级代码，解释器执行的仍是这套机器级老手艺——第 7 章讲的「结构」，到最底层真的就是「跳转」。

7.5布尔逻辑：把多个条件串起来

上一章学的逻辑运算符 and、or、not，在这里派上大用场——用来组合多个条件：

age = 20
has_license = True

if age >= 18 and has_license:
    print("可以开车")
else:
    print("不能开车")

这里 age >= 18 and has_license 是一个组合条件：只有当「年龄够 且 有驾照」两者都满足时，整体才是 True。

# 或：满足其一即可
if is_weekend or is_holiday:
    print("可以睡懒觉")

# 非：取反
if not is_student:
    print("不是学生，需要买全票")

组合条件的求值顺序：先算比较（age >= 18 → True），再算逻辑（True and has_license → True）。整个 if 语句只关心最终那个布尔值。

深入一步：短路求值——能省则省的聪明机制

and 和 or 在求值时有个重要特性：短路求值（short-circuit evaluation，第 6 章见过它的影子，这里看它在 if 里的实战）。A and B：先算 A，若 A 为假，整体必为假，B 根本不会被计算；只有 A 为真才轮到 B。A or B 反过来：A 为真则整体必真，B 被短路。像电路一样记：and 是串联——断一处全断；or 是并联——通一处全通。

短路不只是省时间，它是一种保护机制。经典场景是「先确认、再使用」：判断「记录存在 且 数值达标」时，前半句为假（没有记录）就不该再去碰「数值」——短路让后半句自动免于执行，天然避免「对着不存在的东西做检查」。工程代码里大量防御式判断，都靠这个机制默默兜底。

再补一条进阶事实：and/or 返回的不一定是 True/False，而是「决定结果的那个操作数」——比如 0 or "备用" 的结果是 "备用"。初学阶段不必深究，记住口诀「and 找假、or 找真、找到即返回」即可，它同时也是理解短路的钥匙。

year = 2024
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print(year, "是闰年")
else:
    print(year, "不是闰年")

三个高频布尔陷阱

布尔表达式有三个新手陷阱，值得单独点名：

1. 把 == 写成 =。if x == 5: 是问「x 等于 5 吗」，if x = 5: 则试图在条件里赋值——Python 直接报 SyntaxError（机器实测如此，报错信息还贴心提示「你是不是想写 ==」）。不少语言里这个笔误会悄悄变成赋值、让条件恒真，酿成极难发现的 bug；Python 在语法层面帮你挡住了这个坑，这是它对新手最实在的善意之一。
2. 链式比较是合法的优雅写法。if 18 <= age < 60: 完全等价于 18 <= age and age < 60，读起来就是数学语言（机器实测：age 为 38 时为 True）。但别顺手写出 18 < age > 60——它语法合法，语义却是「age > 18 且 age > 60」，与「18 到 60 之间」毫无关系。合法≠合理，链式比较只留给真正的区间。
3. 浮点数别用 == 判相等。0.1 + 0.2 == 0.3 的结果是 False——第 5 章讲过，二进制浮点存不下精确的 0.1 与 0.2，误差在运算中暴露。正确姿势是「容差」：abs(0.1 + 0.2 - 0.3) < 1e-9，即「差小到可忽略就算相等」（机器实测 True）。凡是浮点比较，一律想到容差。

再补一个优先级细节：not 的优先级低于比较运算，所以 not 3 == 5 等价于 not (3 == 5)——先比较、再取反（机器实测为 True）。拿不准时，括号永远是最可靠的朋友。

辨析：not 的位置决定含义

not (a and b) 与 (not a) and (not b) 是两回事：前者是「两者不同时成立」，后者是「两个都不成立」。逻辑学里的德摩根定律能把它们互相改写：not (A and B) 等价于 (not A) or (not B)。写复杂否定条件时，先用这条定律把 not 推到每个条件跟前再取反，往往比硬憋一个巨型括号清爽得多——「先化简、再编码」，是布尔逻辑的通用工作法。

短路的保护用法：先守门，再计算

短路还有一种极实用的保镖写法：把「便宜的检查」放左边，「危险的计算」放右边。比如计算速度比必须除以 speed，就必须先确认它不是 0，否则会抛出除零错误：

for speed in [0, 2]:
    if speed != 0 and 100 / speed > 5:
        print("速度比偏高")
    print("speed =", speed, "检查完成")

speed 为 0 时，左半 speed != 0 已经是 False，and 当场短路，100 / speed 根本不会被求值——除零错误被挡在门外（机器实测：speed=0 只打印「检查完成」，speed=2 两行都打印）。这招在工程代码里随处可见：先判空再取值、先判零再除法、先判存在再访问。「守门员站左边，攻手站右边」，是复合条件的排兵布阵口诀。

7.6缩进：Python 的「代码块」

你可能已经注意到，Python 的 if 语句里，属于 if 的代码要缩进（前面空几个空格）。这不是排版习惯，而是 Python 的语法规则。

在 Python 里，缩进决定「哪些代码属于同一个代码块」。同一层缩进的代码，属于同一个块，一起执行、一起被跳过。

if age >= 18:
    print("第一句")      # 缩进了，属于 if
    print("第二句")      # 同样缩进，也属于 if
print("第三句")          # 没缩进，不属于 if，永远执行

当 age = 15 时，前两句被一起跳过，只打印「第三句」；当 age = 20 时，三句都打印。

深入一步：缩进是如何被「读」进去的

Python 读你的代码时，会先把文本切成一个个记号（token）。对缩进的处理发生在很早的词法阶段：行首突然多出的空白会被切出一个 INDENT 记号，突然变少会切出 DEDENT 记号。语法分析器就靠这两个记号知道「这里新开了一层块」「这里退回上一层」——缩进不是注释、不是装饰，而是语法结构本身。这也解释了为什么「看着对」不行：Tab 和空格在屏幕上几乎一样，对词法器却是两个不同的字符，混用等于埋雷。

嵌套的分支带来嵌套的缩进：if 里再套 if，每深一层就右移一格。层级越深，读者脑子里要同时挂起的「上下文」越多。工程经验法则是嵌套尽量不超过 3 层；更深时优先考虑改写——比如把多层嵌套改成一串 elif（就像 7.3 节的五档链，天然只有一层），或把内层逻辑打包成函数（第 9 章）。「缩进深度」甚至被当作代码复杂度的直观量尺：一屏装不下你的缩进，多半说明逻辑该拆了。

temp = 38
level = "正常"
if temp > 37:
    level = "偏高"
    if temp >= 39:
        level = "高热"
print("结论：", level)

辨析：缩进是语法，风格是风格

分清两件事：缩进的层级由语法强制——错了就报错，或逻辑悄悄变；缩进的宽度（一层 4 格还是 2 格）是风格约定——Python 官方风格指南 PEP 8 建议 4 个空格，全世界的 Python 代码基本都遵守它，入乡随俗即可。真正不能碰的红线只有两条：同一块内缩进必须一致；Tab 与空格不能混。现代编辑器都能把按下的 Tab 自动换算成 4 个空格，确认这个设置打开，就能从源头免疫一大类「看着一样、实则不同」的隐形报错。

混用 Tab 与空格：专属报错 TabError

「不能混」不是口头警告——同一文件里同一层缩进有时用 Tab 有时用空格，Python 会直接拒绝编译，并给出一条专属报错：TabError: inconsistent use of tabs and spaces in indentation（机器实测原文如此），比普通的 IndentationError 更明确地指向「混用」。混用的常见来源不是手敲，而是从网页或聊天窗口复制代码时悄悄带进来的真实 Tab 字符。遇到 TabError 不必慌：在编辑器里打开「显示空白字符」，把整块代码重新统一缩进一遍（全空格最省心），报错即消失。看到报错能一秒定位到「缩进混用」，你就比大多数初学者快了一步。