分支 — 让程序做选择Copy Anchor Link

这一章起,程序有了判断力。 前面的程序都是「从上往下一条路走到底」; 这一章学会让程序走到岔路口时看条件选路——温度合适就建议去爬山, 不合适就劝你在家。三种分支结构,加上 Python 最有特色的缩进规矩,全在这一章。

1. 这一章在全书链条里的位置Copy Anchor Link

原书把流程控制(program 的执行顺序控制)列为五大语句族:分支、for 循环、 while 循环、break/continue 跳过、try-except 错误处理¹。这一章讲第一种—— 分支;第 08 章讲循环;后两种本书没展开(边界节会交代)。 分支之所以排在循环前面,是因为循环的身体里几乎必然装分支,先学走再学跑。

2. 顶层全景:三种分支,一档比一档多路Copy Anchor Link

  可选     if 条件:            条件真就做,假就跳过(可以什么都不发生)
  二选     if 条件: / else:    真走 A,假走 B(必发生其一)
  多选     if / elif / else:   从上到下找第一个真的,执行它,其余全跳过

  图说:三种结构的差别只在「假的时候怎么办」:跳过 / 走另一半 / 再看下一个条件。

3. 核心原理一:缩进是语法,不是排版Copy Anchor Link

进这一章第一个规矩,也是 Python 和别的语言最大的不同:代码块靠缩进划分。 看骨架²:

  if condition:
␣␣ statements        ← 这一行比 if 退进两个空格,表示「我属于 if 的块」

三个零件逐个说²:

• if 是关键字,声明「分支开始了」;
• condition 是条件,任何产出 True/False 的表达式(第 04 章的比较和逻辑运算 就是为此而生的);
• 冒号 : 收尾,表示「头的部分到此为止」;
• 下一行退两个空格的语句,才是条件为真时要执行的内容。

原书强调:只有条件算出 True,缩进块里的语句才执行;False 就当作它们不存在²。 别的语言用花括号 {} 画块,Python 用缩进——格式即语法,缩错一格就是 另一个程序。这是初学者第一个真正的「风格即法律」时刻。

主线例子:x = 5 的五连判Copy Anchor Link

原书拿 x = 5 连续做了五个可选分支³:

x = 5
if x < 0:
  print('x is negative!')      # 5 < 0 为 False,不打印
if x > 10:
  print('x is more than 10!')  # False,不打印
if x % 2 == 0:
  print('x is even!')          # False,不打印
if x > 0:
  print('x is positive!')      # True,打印这一行
if x % 2 != 0:
  print('x is odd!')           # True,打印这一行

  输出:x is positive!
        x is odd!

  图说:五个 if 各自独立、挨个过堂;条件假的块整个消失,不产生任何痕迹。
  每个条件都是第 04 章的式子:% 2 == 0 问奇偶,> 0 问正负——分支没有新运算,
  它只是给旧运算装了开关。

再加一组更接近生活的例子(书里原例,温度 72 华氏度):

degree = 72
if degree < 60 or degree > 80:
  print('Not good for hiking!')   # 72 不在「< 60 或 > 80」里,False
if degree >= 60 and degree <= 80:
  print('Enjoy the hiking!')      # True,打印

输出是 Enjoy the hiking!⁴——用 and/or 组合区间条件,是分支里的日常操作。

练习里藏着的技巧:大小写不敏感判断Copy Anchor Link

练习有一题很妙:判断用户输入是不是 stop(不限大小写:stop、Stop、STOP 都算)⁵。正解不是列出所有拼写,而是先归一化再比较:

word = input('Enter some word: ').upper()  # 输入先整个转大写
if word == 'STOP':
  print('Bye')                              # 用户敲 stop / Stop / STOP 都进得来

输入 stop 也输出 Bye⁵。这一手「normalize-then-compare」(先统一形态 再比较)是字符串比较的通用套路,后面查密码、查命令全靠它。

4. 核心原理二:if-else — 必居其一的两条路Copy Anchor Link

可选分支的缺点是:条件为假时程序什么都不做,而很多时候你恰恰想「不做 A 就做 B」。else 就是来补这个的——它不带条件,意思是「if 的条件为假 就归我」⁶:

x = 5
if x <= 0:
  print('x is non-positive!')
else:
  print('x is positive!')    # 打印这行

走一遍:x <= 0 是 False → 跳过 if 块 → 落进 else 块 → 打印 x is positive!⁷。

「必居其一」是 else 的灵魂:两个块永远恰好执行一个,没有「都不执行」 也没有「都执行」。这让它成为程序里「兜底」的标准姿势——前面所有特例 被前面的条件拦截,剩下的一律走 else。

练习里的嵌套结构也值得收入囊中(关心学习吗 → 做完实验了吗,两层 if-else 套在一起)⁸:

care = input('Do you care about your learning outcome? Yes or No:')
if care == 'Yes':
  finish = input('Have your finished this lab? ')
  if finish == 'Yes':
    print('Good job!')
  else:
    print('Get it done ASAP!!!!!!')
else:
  print('As long as you are happy.')

输入 Yes 再输入 No,输出 Get it done ASAP!!!!!!⁸。 注意缩进在嵌套里的表现:内层 if-else 整个缩进在外层 if 的块里, 缩进的深度就是嵌套的深度——这正是「缩进即语法」看得最清楚的地方。

5. 核心原理三:if-elif-else — 多选一,先到先得Copy Anchor Link

两个以上的岔路,用 elif(else if 的缩写)接力⁹:

if condition1:
  块 1
elif condition2:
  块 2
else:
  块 3     # else 可省

执行语义一句话:从上往下,找第一个为真的条件,执行它的块,然后整个结构结束—— 就算后面还有为真的条件,也不再看。这个「先到先得」的规则是 elif 链最容易 被误解的地方,用一个书里的例子钉死它¹⁰:

x = 10
if x % 2 == 0:
  print('x is divisible by 2')   # 10 是偶数,True,打印这行
elif x % 3 == 0:
  print('x is divisible by 3')   # 10 不能被 3 整除,而且——根本轮不到判断

输出只有 x is divisible by 2。若把两条 if 拆成两个独立的 if, 一个数可能两条都中(比如 6);换成 if-elif,一个数至多中一条—— 这是「选哪个」与「逐个体检」的区别¹⁰。

主线例子:成绩分档Copy Anchor Link

多分支的教科书应用是分档。书里的成绩程序¹¹:

x = int(input('Please enter a point-based grade in 0-100:'))
if x >= 90:
  print('A')
elif x >= 80:
  print('B')
elif x >= 70:
  print('C')
elif x >= 60:
  print('D')
elif x >= 0:
  print('F')

输入 -1 的走法,一步一格看:

  ① x = -1
  ② x >= 90? -1 >= 90 → False,下一条
  ③ x >= 80? False,下一条
  ④ x >= 70? False,下一条
  ⑤ x >= 60? False,下一条
  ⑥ x >= 0 ? -1 >= 0 → False,下一条
  ⑦ 没有 else,链结束 —— 什么都不打印(原书演示输入 -1,输出空白)[^11]

  图说:elif 链从上往下筛,第一个真的接管,其余条件短路。
  这里还暴露一个设计洞:负数分数掉出所有档位,程序沉默——
  若补 else: print('ERROR'),负数就有了去处(这是章末案例的做法,见下)。

6. 案例走查:四个小程序Copy Anchor Link

先补一个练习区的重头戏:年龄段五分类(1 岁内 infant、1–13 child、 13–20 teenager、20–65 adult、其余 senior)¹²。它的条件和前面的成绩分档 有个关键差别——每个 elif 只写下界,靠「先到先得」自动封顶:

age = int(input('Enter your age as an integer: '))
if age <= 1:
  print('You are an infant')
elif age < 13:
  print('You are a child')
elif age < 20:
  print('You are a teenager')
elif age < 65:
  print('You are an adult')
else:
  print('You are a senior citizen')

拿 age = 15 走一遍:第 1 条 15 <= 1 False;第 2 条 15 < 13 False; 第 3 条 15 < 20 True,打印 teenager——后面的条件不再看。 「上界」由链的顺序保证:能流到你这条 elif,说明前面所有更宽的条件都没中。 elif 链的书写心法:条件按区间从窄到宽排队,每个条件只写一端。 (月份天数题是同构练习:1/3/5/7/8/10/12 月 31 天、2 月 28 天、其余 30 天, 用一条长 or 条件接 elif month == 2 接 else,三行收工¹³。)

GenAI 互动区还点了一题「用 if-else 写闰年」¹⁴——第 04 章那个逻辑表达式 现在可以升级成带解释输出的分支版:

year = int(input('Enter a year: '))
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
  print(f'{year} is a leap year')
else:
  print(f'{year} is not a leap year')

逻辑内核一字未改(第 04 章闰年式),套个 if-else 就能说出人话来—— 表达式负责想,分支负责说,这六个字就是这章的分工。

章末四个案例把分支用到实战强度,我们走两个数字最全的。

案例一:税计算器 — 分段计费的翻译题Copy Anchor Link

规则:收入 10 万以内税率 1%;10 万到 50 万税率 5%;超过 50 万的部分, 前 50 万按 5%,超出部分每美元加收 2%¹⁵。

income = float(input('What is the gross income of the year? '))
if income <= 100000:
  tax = income * 0.01
elif income <= 500000:
  tax = income * 0.05
else:
  tax = 500000 * 0.05 + 0.02 * (income - 500000)
print(f'The tax is {tax:.2f}')

原书演示:收入 600000,输出 The tax is 27000.00。验算: 500000 × 0.05 + 0.02 × 100000 = 25000 + 2000 = 27000 ✓¹⁶。 翻译要点:else 分支的算式必须「把前 50 万按老税率、超出部分按新税率」 拆开写——分段规则对应分段算式,这条对应关系就是税表的代码形态。

边界值是分段程序的高发事故区,拿两个临界点各走一遍(数字是我们按规则推的, 用来演示判断路径):

  收入 = 100000:第 1 条 100000 <= 100000 → True(临界值归低档)
                  tax = 100000 × 0.01 = 1000
  收入 = 500000:第 1 条 False;第 2 条 500000 <= 500000 → True(临界值仍归中档)
                  tax = 500000 × 0.05 = 25000
                  —— 注意:if-elif 的 <= 让临界值「就低不就高」,这与直觉一致:
                    恰好在分段点上,按左边那段算。

(对照:案例四的出租车费是同一模式——fare = 5 / 5 + (miles-10) / 15 + 1.5*(miles-20),25 英里车费 22.5,验算 15 + 1.5×5 = 22.5 ✓¹⁷。)

案例二:四则计算器 — 嵌套分支 + 除零防线Copy Anchor Link

案例三(星期几)也值得补一刀完整的走查,因为它展示了 elif 长链的「排他性」¹⁸: 输入 4 时,链上七条 day == 'N' 条件挨个过——'1'、'2'、'3' 全 False, '4' 终于 True,打印 Thursday,后面三条条件连同 else 全部短路。 若用户敲 9,七条全 False,落进 else 打印 ERROR——八条分支排他地覆盖 了「1–7 加其余全部」的输入空间,这就是带兜底的 elif 链 completeness (完备性)的样子:每个输入恰好有一个去处。

问两个数、问运算符,按运算符分派计算;除法多一道内层 if 查除数不为零¹⁹:

if operator == '/':
  if y != 0:
    print(x, operator, y, '=', x / y)
  else:
    print('Error: Division by zero is not allowed')

输入 3、4、+,输出 3.0 + 4.0 = 7.0²⁰。这是全书第一次出现 「防错误输入」的代码——第 06 章「假设用户配合」的免责声明,在这里被 拆了一个小口:除零这一种灾难被提前拦下。输入非法运算符(比如 %)呢? 四个条件全 False,程序沉默——兜底 still 缺席,这是留给你的练习。

案例三:星期几 — 七连 elif + 兜底 elseCopy Anchor Link

七个数字对七天,八条分支排开,最后的 else 接住所有非法输入打 ERROR¹⁸。 输入 4 输出 Thursday。这个案例的完整形态(含兜底)就是前面成绩分档 程序的「修正版」——两相对照,「要不要 else」的答案呼之欲出: 档位规则总有漏洞,else 是给规则擦屁股的。

练习里的停车计费:分段规则再练一次Copy Anchor Link

规则:前半小时 5 美元;到 2 小时共 20;超 2 小时后每小时加 5²¹:

hours = float(input('Enter the hours of parking as a float number:'))
if hours <= 0.5:
  fee = 5
elif hours <= 2:
  fee = 5 + 15
else:
  fee = 5 + 15 + 5 * (hours - 2)
print(fee)

输入 5.5,输出 37.5:验算 5 + 15 + 5×3.5 = 37.5 ✓²¹。 和税计算器同款骨架——三个案例其实在反复教同一件事:人话里的「分段」, 代码里的 if-elif-else。

7. 练习走查:六道小题,三个模式Copy Anchor Link

正文练习区有六道小题,两两成组,各示范一个可以带走的小模式²²:

模式一:取余当试纸(第 1–3 题)。 判断偶数 n % 2 == 0、奇数 n % 2 != 0、 能被 6 整除 n % 6 == 0——同一个 % 换一个除数,就是一张新试纸。 第 3 题输入 23,23 % 6 = 5 ≠ 0,条件为假,输出空白:演示里特意选了一个 除不尽的数,让「假就消失」看得见²²。 注意演示输入的设计:判断偶数时书里输入 3(输出空白),判断奇数时输入 3 (输出 It is odd)——同一个输入,条件不同,结果一有一无,把 「条件为假就消失」演示得淋漓尽致²²。

模式二:字符串相等当开关(第 4–5 题)。 word == 'STOP' 把一句输入 变成一个开关,撞对暗号才放行(输入 STOP 输出 Bye,其余输入一片沉默)²²。 第 5 题在前面挂了 .upper(),就是 §3 的归一化技巧实战⁵。

模式三:双问核对(第 6 题,密码设置)。 问两遍密码,password1 == password2 才放行,输出 You are all set²³。这是「确认输入」的最小实现——注册页那个 「再输一次密码」的祖先是也。

二选练习里的另两题也值得点名:「心情检查」(happy == 'Yes' 则 Fantastic! 否则 How can I help?)是 if-else 的纯骨架;「植物浇水」把区间规则 (level < 3 浇水)套进 if-else,还演示了多行提示语:input 的提示字符串 用三引号跨行写,用户看到的说明可以是一段话²⁴。

8. 缩进事故博物馆(新手的第一个坑场)Copy Anchor Link

缩进即语法,意味着缩进错误是真错误。三个最常见的事故,全部来自真实的新手日常 (机制依据本章语法,具体案例是我们的归纳)²⁵:

  事故一:忘了缩进
    if x > 0:
    print('positive')     → IndentationError: if 的块没了,冒号后面是空的

  事故二:缩进参差不齐
    if x > 0:
      print('a')
        print('b')        → IndentationError: 同一块里两个深度

  事故三:else 对错了人
    if care == 'Yes':
      if finish == 'Yes':
        print('Good job!')
    else:                   → 这个 else 配的是内层 if,不是外层!
      print('As long as you are happy.')

事故三最阴:不报错,但逻辑整个拧了——用户答 No(不关心学习)也收不到 As long as you are happy.,因为 else 被内层 if 抢走了。 对策一句话:else 永远配它前面最近的那个同深度的 if;拿不准就画缩进线, 把每个 if 和它的 else 用同色笔连起来。 (编辑器里通常有竖向缩进参考线,打开它;事故三的代码在编辑器里能一眼看出 else 缩得比外层 if 深。)

9. 作者的判断与证据Copy Anchor Link

• 三种分支的命名(optional / alternative / multiple)是原书的组织骨架²⁶, 对应 if / if-else / if-elif-else——分类清晰,且与流程图一一配对 (原书每节配一张流程图,我们未复制图,结构描述足够复原)。
• 「缩进两空格」是原书的演示选择;Python 官方风格指南的推荐是四空格²⁷。 两者都合法——缩进的量随意,一致性才是法律(同行混用会报 IndentationError)。书里没提这一点,我们补上。
• 章末 GenAI 提问区有一问「if-elif-else 没覆盖所有情况怎么办」¹⁴—— 正文没答:答案是补 else 兜底,或显式接受沉默。案例一(税)用了 else, 成绩分档没用,两种风格并存于同一章,书没有裁决。

10. 边界与局限Copy Anchor Link

• 分支只能「二值判断」,没有 switch。 多选一靠 elif 长链,Python 直到 3.10(2021 年发布)才加入 match-case 语句。本书没提 match——遇到七连 elif 觉得丑时,知道有 match 这个现代替代品即可(补充,不在书里)。
• 条件之外的真值判断没讲。 if x: 里的 x 可以是任何值——空字符串、 0、空列表算 False,其他算 True(truthiness,真值性:任何值在要布尔的地方 自动换算成「算不算数」)。这是 Python 的重要机制,本书全部条件都是比较运算, if 裸值判断一次没出现——撞到 if items: 这样的代码,知道它等价于 if len(items) > 0: 即可。
• 没有 try-except。 流程控制五族里,错误处理一族本书只在清单里点了名¹, 后文再也没有展开——第 06、07 章的「假设用户配合」其实都是缺了它之后 的权宜。想写「崩了也不死」的程序(比如 input 收到字母时优雅提示重输, 而不是 ValueError 当场暴毙),得自己另学。
• 嵌套过深的警告在 GenAI 区问了没答¹⁴:嵌套 if 超过三层,人就读不动了—— 对策是拆函数(第 09 章)或改逻辑为扁平的 elif 链。
• 分支里的重复代码没人管。 四个案例里,税计算器和出租车费的骨架一模一样 (分段规则 → if-elif-else → 打印),却整段重复书写。对这种「同一骨架填不同算式」 的重复,函数的解药在第 09 章,数据驱动表(字典或列表查表)的解药在第 14 章—— 学完回头重构这四个案例,是最好的复习。

11. 可带走的Copy Anchor Link

读法建议:这一章方法密度高,但骨架就一句——条件造布尔,缩进划块,elif 排队。 下面八条按「语法四条、心法四条」读。

1. 分支三形态:if(可不做)/ if-else(必居其一)/ if-elif-else(多选一,先到先得);表达式负责想,分支负责说²⁶⁹。
2. 缩进就是语法:块属于谁,看谁缩得浅;嵌套靠缩进深度表示;else 配最近同深度的 if²⁸。
3. elif 链至多执行一块;同一条件拆成多个独立 if 可能多块都中(比如 6 对 「被 2 整除 / 被 3 整除」两条都 True)——语义不同,选结构前先问自己 「允许多个同时成立吗」¹⁰。
4. 区间条件用 and/or 组合:degree >= 60 and degree <= 80; 反向写法 degree < 60 or degree > 80 是同一区间的补集(城外)——两式必一真一假⁴。
5. 大小写不敏感:.upper() 归一化后再比——normalize-then-compare 是字符串判断的通用套路⁵。
6. 人话「分段」= 代码 if-elif-else,每段一个算式;税、停车费、出租车费同构¹⁵²¹。
7. 档位规则留 else 兜底,否则漏网之值(负数分数、非法输入)让程序沉默¹¹¹⁸。
8. 除零检查:if y != 0 是防御式编程的第一课——第 06 章「假设用户配合」的防线,从这里开始修¹⁹。

12. 原文地图Copy Anchor Link