Python书籍阅读与记录 6.11 II 特殊的列表——元组 以及 if语句

我感觉这样记录，对于我来说挺好的。因为我看两端对齐的语句容易走神，这样记录阅读的话，就很少出现之前的情况。

我写的初衷，也是自己来看，所以感觉写的不好的，请保留下意见，谢谢。

 

里面的每一个字我都看过，加粗 括号  下划线 等均是我的笔记。

 

我准备在接下来10天的时间把python从入门到实践看一遍，然后把其中的重点都写下来。
 

 

4.5 元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。 然而，有时候你需要创建一系列不可修

改的元素，元组可以满足这种需求。 Python 将不能修改的值称为不 可变

的 ，而不可变的列表被称为

元组 。

4.5.1  定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

例如，如果有一个大小不应改变的矩形，可将其长度和宽度存储在一个元组中，从而确保它们是不能修改的：

dimensions.py

❶ dimensions = (200, 50)

❷ print(dimensions[0])

print(dimensions[1])

我们首先定义了元组 dimensions （见 ❶ ），为此我们使用了圆括号而不是方括号。接下来，我们分别打印该元组的各个元素，使用的语法与访问列表元素时使用的语法相同

（见 ❷ ）：

200

50

下面来尝试修改元组 dimensions 中的一个元素，看看结果如何：

dimensions = (200, 50)

❶ dimensions[0] = 250

❶ 处的代码试图修改第一个元素的值，导致 Python 返回类型错误消息。由于试图修改元组的操作是被禁止的，因此 Python 指出不能给元组的元素赋值：

Traceback (most recent call last):

File "dimensions.py", line 3, in <module>

dimensions[0] = 250

TypeError: 'tuple' object does not support item assignment   # tuple  n. 元组   元组不支持项目分配

代码试图修改矩形的尺寸时， Python 报告错误，这很好，因为这正是我们希望的。

4.5.2 遍历元组中心的所有值

像列表一样，也可以使用 for 循环来遍历元组中的所有值：

dimensions = (200, 50)

for dimension in dimensions:

print(dimension)

就像遍历列表时一样， Python 返回元组中所有的元素，：

200

50

4.5.3 修改元组中的变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：

❶ dimensions = (200, 50)

print("Original dimensions:")

for dimension in dimensions:

print(dimension)

❷ dimensions = (400, 100)

❸ print("\nModified dimensions:")

for dimension in dimensions:

print(dimension)

我们首先定义了一个元组，并将其存储的尺寸打印了出来（见 ❶ ）；接下来，将一个新元组存储到变量 dimensions 中（见 ❷ ）；然后，打印新的尺寸（见 ❸ ）。这次， Python

不会报告任何错误，因为给元组变量赋值是合法的：

Original dimensions:

200

50

Modified dimensions:

400

100

相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

动手试一试

 

4-13 自

助

餐 ：有一家自助式餐馆，只提供五种简单的食品。请想出五种简单的食品，并将其存储在一个元组中。

使用一个 for 循环将该餐馆提供的五种食品都打印出来。

尝试修改其中的一个元素，核实 Python 确实会拒绝你这样做。

餐馆调整了菜单，替换了它提供的其中两种食品。请编写一个这样的代码块：给元组变量赋值，并使用一个 for 循环将新元组的每个元素都打印出来。

4.6 设置代码格式

随着你编写的程序越来越长，有必要了解一些代码格式设置约定。请花时间让你的代码尽可能易于阅读；让代码易于阅读有助于你掌握程序是做什么的，也可以帮助他人理解你

编写的代码。

为确保所有人编写的代码的结构都大致一致， Python 程序员都遵循一些格式设置约定。学会编写整洁的 Python 后，就能明白他人编写的 Python 代码的整体结构 —— 只要他们和你遵

循相同的指南。要成为专业程序员，应从现在开始就遵循这些指南，以养成良好的习惯。

4.6.1 格式设置指南

若要提出 Python 语言修改建议，需要编写 Python 改

进

 

案 （ PythonEnhancement Proposal ， PEP ）。 PEP 8 是最古老的 PEP 之一，它向 Python 程序员提供了代码格式设置指南。 PEP 8 的

篇幅很长，但大都与复杂的编码结构相关。

Python 格式设置指南的编写者深知，代码被阅读的次数比编写的次数多。代码编写出来后，调试时你需要阅读它；给程序添加新功能时，需要花很长的时间阅读代码；与其他程序

员分享代码时，这些程序员也将阅读它们。

如果一定要在让代码易于编写和易于阅读之间做出选择， Python 程序员几乎总是会选择后者。下面的指南可帮助你从一开始就编写出清晰的代码。

4.6.2 缩进 

PEP 8 建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间。

在字处理文档中，大家常常使用制表符而不是空格来缩进。对于字处理文档来说，这样做的效果很好，但混合使用制表符和空格会让 Python 解释器感到迷惑。每款文本编辑器都提

供了一种设置，可将输入的制表符转换为指定数量的空格。你在编写代码时应该使用制表符键，但一定要对编辑器进行设置，使其在文档中插入空格而不是制表符。

在程序中混合使用制表符和空格可能导致极难解决的问题。如果你混合使用了制表符和空格，可将文件中所有的制表符转换为空格，大多数编辑器都提供了这样的功能。

4.6.3 行长 

很多 Python 程序员都建议每行不超过 80 字符。最初制定这样的指南时，在大多数计算机中，终端窗口每行只能容纳 79 字符；当前，计算机屏幕每行可容纳的字符数多得多，为何还

要使用 79 字符的标准行长呢？这里有别的原因。专业程序员通常会在同一个屏幕上打开多个文件，使用标准行长可以让他们在屏幕上并排打开两三个文件时能同时看到各个文件

的完整行。 PEP 8还建议注释的行长都不超过72字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符。

PEP 8 中有关行长的指南并非不可逾越的红线，有些小组将最大行长设置为 99 字符。在学习期间，你不用过多地考虑代码的行长，但别忘了，协作编写程序时，大家几乎都遵守

PEP 8 指南。 在大多数编辑器中，都可设置一个视觉标志——通常是一条竖线，让你知道不能越过的界线在什么地方。  

注意

附录B介绍了如何配置文本编辑器，以使其：在你按制表符键时插入四个空格；显示一条垂直参考线，帮助你遵守行长不能超过79 字符的约定。

4.6.4 空行 

要将程序的不同部分分开，可使用空行。你应该使用空行来组织程序文件，但也不能滥用；只要按本书的示例展示的那样做，就能掌握其中的平衡。例如，如果你有 5 行创建列表

的代码，还有 3 行处理该列表的代码，那么用一个空行将这两部分隔开是合适的。然而，你不应使用三四个空行将它们隔开。

空行不会影响代码的运行，但会影响代码的可读性。 Python 解释器根据水平缩进情况来解读代码，但不关心垂直间距。

4.6.5 其它格式设置指南

PEP 8 还有很多其他的格式设置建议，但这些指南针对的程序大都比目前为止本书提到的程序复杂。等介绍更复杂的 Python 结构时，我们再来分享相关的 PEP 8 指南。

动手试一试

4-14 PEP 8 ：请访问 https://python.org/dev/peps/pep-0008/ ，阅读 PEP 8 格式设置指南。当前，这些指南适用的不多，但你可以大致浏览一下。

4-15 代

码审

核 ：从本章编写的程序中选择三个，根据 PEP 8 指南对它们进行修改。

每级缩进都使用四个空格。对你使用的文本编辑器进行设置，使其在你按 Tab 键时都插入四个空格；如果你还没有这样做，现在就去做吧（有关如何设置，请参

阅附录B ）。

每行都不要超过 80 字符。对你使用的编辑器进行设置，使其在第 80 个字符处显示一条垂直参考线。

不要在程序文件中过多地使用空行。

4.7 小结

在本章中，你学习了：如何高效地处理列表中的元素；如何使用 for 循环遍历列表， Python 如何根据缩进来确定程序的结构以及如何避免一些常见的缩进错误；如何创建简单的

数字列表，以及可对数字列表执行的一些操作；如何通过切片来使用列表的一部分和复制列表。你还学习了元组（它对不应变化的值提供了一定程度的保护），以及在代码变得

越来越复杂时如何设置格式，使其易于阅读。

在第 5 章中，你将学习如何使用 if 语句在不同的条件下采取不同的措施；学习如何将一组较复杂的条件测试组合起来，并在满足特定条件时采取相应的措施。你还将学习如何在

遍历列表时，通过使用 if 语句对特定元素采取特定的措施。

 

第5章 If语句

编程时经常需要检查一系列条件，并据此决定采取什么措施。在 Python 中， if 语句让你能够检查程序的当前状态，并据此采取相应的措施。

在本章中，你将学习条件测试，以检查感兴趣的任何条件。你将学习简单的 if 语句，以及创建一系列复杂的 if 语句来确定当前到底处于什么情形。接下来，你将把

学到的知识应用于列表，以编写 for 循环，以一种方式处理列表中的大多数元素，并以另一种不同的方式处理包含特定值的元素。

5.1 一个简单示例

下面是一个简短的示例，演示了如何使用 if 语句来正确地处理特殊情形。假设你有一个汽车列表，并想将其中每辆汽车的名称打印出来。对于大多数汽车，都应以首字母大写的

方式打印其名称，但对于汽车名 'bmw' ，应以全大写的方式打印。下面的代码遍历一个列表，并以首字母大写的方式打印其中的汽车名，但对于汽车名 'bmw' ，以全大写的方

式打印：

cars.py

cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:

❶ if car == 'bmw':

print(car.upper())

else:

print(car.title())

这个示例中的循环首先检查当前的汽车名是否是 'bmw' （见 ❶ ）。如果是，就以全大写的方式打印它；否则就以首字母大写的方式打印：

Audi

BMW

Subaru

Toyota

这个示例涵盖了本章将介绍的很多概念。下面先来介绍可用来在程序中检查条件的测试。

5.2 条件测试

每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式被称为条

条件

测

试 。 Python 根据条件测试的值为 True 还是 False 来决定是否执行 if 语句中的代码。如果

条件测试的值为 True ， Python 就执行紧跟在 if 语句后面的代码；如果为 False ， Python 就忽略这些代码。

5.2.1 检查是否相等

大多数条件测试都将一个变量的当前值同特定值进行比较。最简单的条件测试检查变量的值是否与特定值相等：

❶ >>> car = 'bmw'

❷ >>> car == 'bmw'

True

我们首先使用一个等号将 car 的值设置为 'bmw' （见 ❶ ），这种做法你已见过很多次。接下来，使用两个等号（ == ）检查 car 的值是否为 'bmw' 。这个相

等 运算

符

在它两边

的值相等时返回 True ，否则返回 False 。在这个示例中，两边的值相等，因此 Python 返回 True 。

如果变量 car 的值不是 'bmw' ，上述测试将返回 False ：

❶ >>> car = 'audi'

❷ >>> car == 'bmw'

False

一个等号是陈述；对于 ❶ 处的代码，可解读为 “ 将变量 car 的值设置为 'audi' ” 。两个等号是发问；对于 ❷ 处的代码，可解读为 “ 变量 car 的值是 'bmw' 吗？ ” 。大多数编程语言

使用等号的方式都与这里演示的相同。

5.2.2 检查是否相等时不考虑大小写

在 Python 中检查是否相等时区分大小写，例如，两个大小写不同的值会被视为不相等：

>>> car = 'Audi'

>>> car == 'audi'

False

如果大小写很重要，这种行为有其优点。但如果大小写无关紧要，而只想检查变量的值，可将变量的值转换为小写，再进行比较：

>>> car = 'Audi'

>>> car.lower() == 'audi'

True

无论值 'Audi' 的大小写如何，上述测试都将返回 True ，因为该测试不区分大小写。函数 lower() 不会修改存储在变量car 中的值，因此进行这样的比较时不会影响原来的变

量：

❸ >>> car = 'Audi'

❷ >>> car.lower() == 'audi'

True

❸ >>> car

'Audi'

在 ❶ 处，我们将首字母大写的字符串 'Audi' 存储在变量 car 中；在 ❷ 处，我们获取变量 car 的值并将其转换为小写，再将结果与字符串 'audi' 进行比较。这两个字符串相

同，因此 Python 返回 True 。从 ❸ 处的输出可知，这个条件测试并没有影响存储在变量 car 中的值。

网站采用类似的方式让用户输入的数据符合特定的格式。例如，网站可能使用类似的测试来确保用户名是独一无二的，而并非只是与另一个用户名的大小写不同。用户提交新的

用户名时，将把它转换为小写，并与所有既有用户名的小写版本进行比较。执行这种检查时，如果已经有用户名 'john' （不管大小写如何），则用户提交用户名 'John' 时将

遭到拒绝。

5.2.3 检查是否不相等

要判断两个值是否不等，可结合使用惊叹号和等号（ != ），其中的惊叹号表示不

，在很多编程语言中都如此。

下面再使用一条 if 语句来演示如何使用不等运算符。我们将把要求的比萨配料存储在一个变量中，再打印一条消息，指出顾客要求的配料是否是意式小银鱼（ anchovies ）：

toppings.py

requested_topping = 'mushrooms'

❶ if requested_topping != 'anchovies':

print("Hold the anchovies!")

❶ 处的代码行将 requested_topping 的值与 'anchovies' 进行比较，如果它们不相等， Python 将返回 True ，进而执行紧跟在 if 语句后面的代码；如果这两个值相

等， Python 将返回 False ，因此不执行紧跟在 if 语句后面的代码。

由于 requested_topping 的值不是 'anchovies' ，因此执行 print 语句：

Hold the anchovies!

你编写的大多数条件表达式都检查两个值是否相等，但有时候检查两个值是否不等的效率更高。

5.2.4 比较数字

检查数值非常简单，例如，下面的代码检查一个人是否是 18 岁：

>>> age = 18

>>> age == 18

True

你还可以检查两个数字是否不等，例如，下面的代码在提供的答案不正确时打印一条消息：

magic_number.py

answer = 17

❶ if answer != 42:

print("That is not the correct answer. Please try again!") answer （ 17 ）不是 42 ， ❶ 处的条件得到满足，因此缩进的代码块得以执行：

That is not the correct answer. Please try again!

条件语句中可包含各种数学比较，如小于、小于等于、大于、大于等于：

>>> age = 19

>>> age < 21

True

>>> age <= 21

True

>>> age > 21

False

>>> age >= 21

False

在 if 语句中可使用各种数学比较，这让你能够直接检查关心的条件。

5.2.5 检查多个条件

你可能想同时检查多个条件，例如，有时候你需要在两个条件都为 True 时才执行相应的操作，而有时候你只要求一个条件为 True 时就执行相应的操作。在这些情况下，关键

字 and 和 or 可助你一臂之力。

1. 使用and检查多个条件

要检查是否两个条件都为 True ，可使用关键字 and 将两个条件测试合而为一；如果每个测试都通过了，整个表达式就为 True ；如果至少有一个测试没有通过，整个表达式就

为 False 。

例如，要检查是否两个人都不小于 21 岁，可使用下面的测试：

❶ >>> age_0 = 22

>>> age_1 = 18

❷ >>> age_0 >= 21 and age_1 >= 21

False

❸ >>> age_1 = 22

>>> age_0 >= 21 and age_1 >= 21

True

在 ❶ 处，我们定义了两个用于存储年龄的变量： age_0 和 age_1 。在 ❷ 处，我们检查这两个变量是否都大于或等于 21 ；左边的测试通过了，但右边的测试没有通过，因此整个

条件表达式的结果为 False 。在 ❸ 处，我们将 age_1 改为 22 ，这样 age_1 的值大于 21 ，因此两个测试都通过了，导致整个条件表达式的结果为 True 。

为改善可读性，可将每个测试都分别放在一对括号内，但并非必须这样做。如果你使用括号，测试将类似于下面这样：

(age_0 >= 21) and (age_1 >= 21)

2. 使用or检查多个条件

关键字 or 也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。仅当两个测试都没有通过时，使用 or 的表达式才为 False 。

下面再次检查两个人的年龄，但检查的条件是至少有一个人的年龄不小于 21 岁：

❶ >>> age_0 = 22

>>> age_1 = 18

❷ >>> age_0 >= 21 or age_1 >= 21

True

❶ >>> age_0 = 18

>>> age_0 >= 21 or age_1 >= 21

False

同样，我们首先定义了两个用于存储年龄的变量（见 ❶ ）。由于 ❷ 处对 age_0 的测试通过了，因此整个表达式的结果为 True 。接下来，我们将 age_0 减小为 18 ；在 ❸ 处的测试

中，两个测试都没有通过，因此整个表达式的结果为 False 。

5.2.6 检查特定值是否包含在列表中

有时候，执行操作前必须检查列表是否包含特定的值。例如，结束用户的注册过程前，可能需要检查他提供的用户名是否已包含在用户名列表中。在地图程序中，可能需要检查

用户提交的位置是否包含在已知位置列表中。

要判断特定的值是否已包含在列表中，可使用 关键字in 。来看你可能为比萨店编写的一些代码；这些代码首先创建一个列表，其中包含用户点的比萨配料，然后检查特定的配料

是否包含在该列表中。

>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']

❶ >>> 'mushrooms' in requested_toppings

True

❷ >>> 'pepperoni' in requested_toppings

False

在 ❶ 处和 ❷ 处，关键字 in 让 Python 检查列表 requested_toppings 是否包含 'mushrooms' 和 'pepperoni' 。这种技术很有用，它让你能够在创建一个列表后，轻松地检

查其中是否包含特定的值。

5.2.7 检查特定值是否不包含在列表中

还有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用 关键字not in 。例如，如果有一个列表，其中包含被禁止在论坛上发表评论的用户，就可在允许用

户提交评论前检查他是否被禁言： banned_users.py

banned_users = ['andrew', 'carolina', 'david']

user = 'marie'

❶ if user not in banned_users:

print(user.title() + ", you can post a response if you wish.")

❶ 处的代码行明白易懂：如果 user 的值未包含在列表 banned_users 中， Python 将返回 True ，进而执行缩进的代码行。

用户 'marie' 未包含在列表 banned_users 中，因此她将看到一条邀请她发表评论的消息：

Marie, you can post a response if you wish.

5.2.8 布尔表达式

随着你对编程的了解越来越深入，将遇到术语

布尔

表达

式 ，它不过是条件测试的别名。与条件表达式一样，布尔表达式的结果要么为 True ，要么为False 。

布尔值通常用于记录条件 ，如游戏是否正在运行，或用户是否可以编辑网站的特定内容：

game_active = True

can_edit = False

在跟踪程序状态或程序中重要的条件方面，布尔值提供了一种高效的方式。

动手试一试

 

5-1 

条件

测试

：编写一系列条件测试；将每个测试以及你对其结果的预测和实际结果都打印出来。你编写的代码应类似于下面这样：

car = 'subaru'

print("Is car == 'subaru'? I predict True.")

print(car == 'subaru')

print("\nIs car == 'audi'? I predict False.")

print(car == 'audi')

详细研究实际结果，直到你明白了它为何为 True 或 False 。

创建至少 10 个测试，且其中结果分别为 True 和 False 的测试都至少有 5 个。

5-2 更多的条件测试

 ：你并非只能创建 10 个测试。如果你想尝试做更多的比较，可再编写一些测试，并将它们加入到 conditional_tests.py 中。对于下面列出的各种测

试，至少编写一个结果为 True 和 False 的测试。

检查两个字符串相等和不等。

使用函数 lower() 的测试。

检查两个数字相等、不等、大于、小于、大于等于和小于等于。

使用关键字 and 和 or 的测试。

测试特定的值是否包含在列表中。#  in

测试特定的值是否未包含在列表中。#  not in

5.3 if语句

理解条件测试后，就可以开始编写 if 语句了。 if 语句有很多种，选择使用哪种取决于要测试的条件数。前面讨论条件测试时，列举了多个 if 语句示例，下面更深入地讨论这个

主题。

5.3.1 简单的if语句

最简单的 if 语句只有一个测试和一个操作：

if conditional_test:

do something

在第 1 行中，可包含任何条件测试，而在紧跟在测试后面的缩进代码块中，可执行任何操作。如果条件测试的结果为 True ， Python 就会执行紧跟在 if 语句后面的代码；否则

Python 将忽略这些代码。

假设有一个表示某人年龄的变量，而你想知道这个人是否够投票的年龄，可使用如下代码：

voting.py

age = 19

❶ if age >= 18:

❷ print("You are old enough to vote!")

在 ❶ 处， Python 检查变量 age 的值是否大于或等于 18 ；答案是肯定的，因此 Python 执行 ❷ 处缩进的 print 语句：

You are old enough to vote! 在 if 语句中，缩进的作用与 for 循环中相同。如果测试通过了，将执行 if 语句后面所有缩进的代码行，否则将忽略它们。

在紧跟在 if 语句后面的代码块中，可根据需要包含任意数量的代码行。下面在一个人够投票的年龄时再打印一行输出，问他是否登记了：

age = 19

if age >= 18:

    print("You are old enough to vote!")

    print("Have you registered to vote yet?")

条件测试通过了，而两条 print 语句都缩进了，因此它们都将执行：

You are old enough to vote!

Have you registered to vote yet?

如果 age 的值小于 18 ，这个程序将不会有任何输出。

5.3.2 if-else语句

经常需要在条件测试通过了时执行一个操作，并在没有通过时执行另一个操作；在这种情况下，可使用 Python 提供的 if-else 语句。 if-else 语句块类似于简单的 if 语句，但

其中的 else 语句让你能够指定条件测试未通过时要执行的操作。

下面的代码在一个人够投票的年龄时显示与前面相同的消息，同时在这个人不够投票的年龄时也显示一条消息：

age = 17

❶ if age >= 18:

print("You are old enough to vote!")

print("Have you registered to vote yet?")

❷ else:

print("Sorry, you are too young to vote.")

print("Please register to vote as soon as you turn 18!")

如果 ❶ 处的条件测试通过了，就执行第一个缩进的 print 语句块；如果测试结果为 False ，就执行 ❷ 处的 else 代码块。这次 age 小于 18 ，条件测试未通过，因此执行 else 代

码块中的代码：

Sorry, you are too young to vote.

Please register to vote as soon as you turn 18!

上述代码之所以可行，是因为只存在两种情形：要么够投票的年龄，要么不够。 if-else 结构非常适合用于要让 Python 执行两种操作之一的情形。在这种简单的 if-else 结构

中，总是会执行两个操作中的一个。

5.3.3 if-elif-else 结构

经常需要检查超过两个的情形，为此可使用 Python 提供的 if-elif-else 结构。 Python 只执行 if-elif-else 结构中的一个代码块，它依次检查每个条件测试，直到遇到通过

了的条件测试。测试通过后， Python 将执行紧跟在它后面的代码，并跳过余下的测试。

在现实世界中，很多情况下需要考虑的情形都超过两个。例如，来看一个根据年龄段收费的游乐场：

4 岁以下免费；

4~18 岁收费 5 美元；

18 岁（含）以上收费 10 美元。

如果只使用一条 if 语句，如何确定门票价格呢？下面的代码确定一个人所属的年龄段，并打印一条包含门票价格的消息：

amusement_park.py

age = 12

❶ if age < 4:

print("Your admission cost is $0.")

❷ elif age < 18:

print("Your admission cost is $5.")

❸ else:

print("Your admission cost is $10.")

❶ 处的 if 测试检查一个人是否不满 4 岁，如果是这样， Python 就打印一条合适的消息，并跳过余下的测试。 ❷ 处的 elif 代码行其实是另一个 if 测试，它仅在前面的测试未通过

时才会运行。在这里，我们知道这个人不小于 4 岁，因为第一个测试未通过。如果这个人未满 18 岁， Python 将打印相应的消息，并跳过 else 代码块。如果 if 测试和 elif 测试都

未通过， Python 将运行 ❸ 处 else 代码块中的代码。

在这个示例中， ❶ 处测试的结果为 False ，因此不执行其代码块。然而，第二个测试的结果为 True （ 12 小于 18 ），因此将执行其代码块。输出为一个句子，向用户指出了门票

价格：

Your admission cost is $5.

只要年龄超过 17 岁，前两个测试就都不能通过。在这种情况下，将执行 else 代码块，指出门票价格为 10 美元。

为让代码更简洁，可不在 if-elif-else 代码块中打印门票价格，而只在其中设置门票价格，并在它后面添加一条简单的 print 语句： age = 12

if age < 4:

❶ price = 0

elif age < 18:

❷ price = 5

else:

❸ price = 10

❹ print("Your admission cost is $" + str(price) + ".")

❶ 处、 ❷ 处和 ❸ 处的代码行像前一个示例那样，根据人的年龄设置变量 price 的值。在 if-elif-else 结构中设置 price 的值后，一条未缩进的 print 语句 ❹ 会根据这个变

量的值打印一条消息，指出门票的价格。

这些代码的输出与前一个示例相同，但 if-elif-else 结构的作用更小，它只确定门票价格，而不是在确定门票价格的同时打印一条消息。除效率更高外，这些修订后的代码

还更容易修改：要调整输出消息的内容，只需修改一条而不是三条 print 语句。

5.3.4 使用多个elif代码块

可根据需要使用任意数量的 elif 代码块，例如，假设前述游乐场要给老年人打折，可再添加一个条件测试，判断顾客是否符合打折条件。下面假设对于 65 岁（含）以上的老

人，可以半价（即 5 美元）购买门票：

age = 12

if age < 4:

price = 0

elif age < 18:

price = 5

❶ elif age < 65:

price = 10

❷ else:

price = 5

print("Your admission cost is $" + str(price) + ".")

这些代码大都未变。第二个 elif 代码块（见 ❶ ）通过检查确定年龄不到 65 岁后，才将门票价格设置为全票价格 ——10 美元。请注意，在 else 代码块（见 ❷ ）中，必须将所赋的

值改为 5 ，因为仅当年龄超过 65 （含）时，才会执行这个代码块。

5.3.5 省略else代码块

Python并不要求if-elif 结构后面必须有else 代码块 。在有些情况下， else 代码块很有用；而在其他一些情况下，使用一条 elif 语句来处理特定的情形更清晰：

age = 12

if age < 4:

price = 0

elif age < 18:

price = 5

elif age < 65:

price = 10

❶ elif age >= 65:

price = 5

print("Your admission cost is $" + str(price) + ".")

❶ 处的 elif 代码块在顾客的年龄超过 65 （含）时，将价格设置为 5 美元，这比使用 else 代码块更清晰些。经过这样的修改后，每个代码块都仅在通过了相应的测试时才会执

行。

else 是一条包罗万象的语句，只要不满足任何if 或elif 中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数据。如果知道最终要测试的条件，应考虑使用

一个elif 代码块来代替else 代码块。这样，你就可以肯定，仅当满足相应的条件时，你的代码才会执行。

5.3.6 测试多个条件

if-elif-else 结构功能强大，但仅适合用于只有一个条件满足的情况：遇到通过了的测试后， Python 就跳过余下的测试。这种行为很好，效率很高，让你能够测试一个特定的

条件。

然而，有时候必须检查你关心的所有条件。在这种情况下，应使用一系列不包含 elif 和 else 代码块的简单 if 语句。在可能有多个条件为 True ，且你需要在每个条件为 True

时都采取相应措施时，适合使用这种方法。

下面再来看前面的比萨店示例。如果顾客点了两种配料，就需要确保在其比萨中包含这些配料：

toppings.py

❶ requested_toppings = ['mushrooms', 'extra cheese']

❷ if 'mushrooms' in requested_toppings:

print("Adding mushrooms.")

❸ if 'pepperoni' in requested_toppings:

print("Adding pepperoni.")

❹ if 'extra cheese' in requested_toppings:

print("Adding extra cheese.")

print("\nFinished making your pizza!")

我们首先创建了一个列表，其中包含顾客点的配料（见 ❶ ）。 ❷ 处的 if 语句检查顾客是否点了配料蘑菇（ 'mushrooms' ），如果点了，就打印一条确认消息。 ❸ 处检查配料辣

香肠（ 'pepperoni' ）的代码也是一个简单的 if 语句，而不是 elif 或 else 语句；因此不管前一个测试是否通过，都将进行这个测试。 ❹ 处的代码检查顾客是否要求多加芝

士（ 'extra cheese' ）；不管前两个测试的结果如何，都会执行这些代码。每当这个程序运行时，都会进行这三个独立的测试。

在这个示例中，会检查每个条件，因此将在比萨中添加蘑菇并多加芝士：

Adding mushrooms.

Adding extra cheese.

Finished making your pizza!

如果像下面这样转而使用 if-elif-else 结构，代码将不能正确地运行，因为有一个测试通过后，就会跳过余下的测试：

requested_toppings = ['mushrooms', 'extra cheese']

if 'mushrooms' in requested_toppings:

print("Adding mushrooms.")

elif 'pepperoni' in requested_toppings:

print("Adding pepperoni.")

elif 'extra cheese' in requested_toppings:

print("Adding extra cheese.")

print("\nFinished making your pizza!")

第一个测试检查列表中是否包含 'mushrooms' ，它通过了，因此将在比萨中添加蘑菇。然而， Python 将跳过 if-elif-else 结构中余下的测试，不再检查列表中是否包

含 'extra cheese' 和 'pepperoni' 。其结果是，将添加顾客点的第一种配料，但不会添加其他的配料：

Adding mushrooms.

Finished making your pizza!

总之，如果你只想执行一个代码块，就使用 if-elif-else 结构；如果要运行多个代码块，就使用一系列独立的 if 语句。

动手试一试  

5-3 外

星人

颜

色 #1 ：假设在游戏中刚射杀了一个外星人，请创建一个名为 alien_color 的变量，并将其设置为 'green' 、 'yellow' 或 'red' 。

编写一条 if 语句，检查外星人是否是绿色的；如果是，就打印一条消息，指出玩家获得了 5 个点。

编写这个程序的两个版本，在一个版本中上述测试通过了，而在另一个版本中未通过（未通过测试时没有输出）。

5-4 外

星人

颜

色 #2 ：像练习 5-3 那样设置外星人的颜色，并编写一个 if-else 结构。

如果外星人是绿色的，就打印一条消息，指出玩家因射杀该外星人获得了 5 个点。

如果外星人不是绿色的，就打印一条消息，指出玩家获得了 10 个点。

编写这个程序的两个版本，在一个版本中执行 if 代码块，而在另一个版本中执行 else 代码块。

5-5 外

星人

颜

色 #3 ：将练习 5-4 中的 if-else 结构改为 if-elif-else 结构。

如果外星人是绿色的，就打印一条消息，指出玩家获得了 5 个点。

如果外星人是黄色的，就打印一条消息，指出玩家获得了 10 个点。

如果外星人是红色的，就打印一条消息，指出玩家获得了 15 个点。

编写这个程序的三个版本，它们分别在外星人为绿色、黄色和红色时打印一条消息。

5-6 人

生的

不同

阶段

 ：设置变量 age 的值，再编写一个 if-elif-else 结构，根据 age 的值判断处于人生的哪个阶段。

如果一个人的年龄小于 2 岁，就打印一条消息，指出他是婴儿。

如果一个人的年龄为 2 （含）～ 4 岁，就打印一条消息，指出他正蹒跚学步。

如果一个人的年龄为 4 （含）～ 13 岁，就打印一条消息，指出他是儿童。

如果一个人的年龄为 13 （含）～ 20 岁，就打印一条消息，指出他是青少年。

如果一个人的年龄为 20 （含）～ 65 岁，就打印一条消息，指出他是成年人。

如果一个人的年龄超过 65 （含）岁，就打印一条消息，指出他是老年人。

5-7 喜

欢的

水

果 ：创建一个列表，其中包含你喜欢的水果，再编写一系列独立的 if 语句，检查列表中是否包含特定的水果。

将该列表命名为 favorite_fruits ，并在其中包含三种水果。

编写 5 条 if 语句，每条都检查某种水果是否包含在列表中，如果包含在列表中，就打印一条消息，如 “You really like bananas!” 。

5.4 使用if语句处理列表

通过结合使用 if 语句和列表，可完成一些有趣的任务：对列表中特定的值做特殊处理；高效地管理不断变化的情形，如餐馆是否还有特定的食材；证明代码在各种情形下都将按

预期那样运行。

5.4.1 检查特殊元素

本章开头通过一个简单示例演示了如何处理特殊值 'bmw' —— 它需要采用不同的格式进行打印。既然你对条件测试和 if 语句有了大致的认识，下面来进一步研究如何检查列表

中的特殊值，并对其做合适的处理。

继续使用前面的比萨店示例。这家比萨店在制作比萨时，每添加一种配料都打印一条消息。通过创建一个列表，在其中包含顾客点的配料，并使用一个循环来指出添加到比萨中

的配料，可以以极高的效率编写这样的代码：

toppings.py

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:

print("Adding " + requested_topping + ".")

print("\nFinished making your pizza!") 输出很简单，因为上述代码不过是一个简单的 for 循环：

Adding mushrooms.

Adding green peppers.

Adding extra cheese.

Finished making your pizza!

然而，如果比萨店的青椒用完了，该如何处理呢？为妥善地处理这种情况，可在 for 循环中包含一条 if 语句：

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:

❶ if requested_topping == 'green peppers':

print("Sorry, we are out of green peppers right now.")

❷ else:

print("Adding " + requested_topping + ".")

print("\nFinished making your pizza!")

这里在比萨中添加每种配料前都进行检查。 ❶ 处的代码检查顾客点的是否是青椒，如果是，就显示一条消息，指出不能点青椒的原因。 ❷ 处的 else 代码块确保其他配料都将添

加到比萨中。

输出表明，妥善地处理了顾客点的每种配料：

Adding mushrooms.

Sorry, we are out of green peppers right now.

Adding extra cheese.

Finished making your pizza!

5.4.2 确定列表不是空的

到目前为止，对于处理的每个列表都做了一个简单的假设，即假设它们都至少包含一个元素。我们马上就要让用户来提供存储在列表中的信息，因此不能再假设循环运行时列表

不是空的。有鉴于此，在运行 for 循环前确定列表是否为空很重要。

下面在制作比萨前检查顾客点的配料列表是否为空。如果列表是空的，就向顾客确认他是否要点普通比萨；如果列表不为空，就像前面的示例那样制作比萨：

❶ requested_toppings = []

❷ if requested_toppings:

for requested_topping in requested_toppings:

print("Adding " + requested_topping + ".")

print("\nFinished making your pizza!")

❸ else:

print("Are you sure you want a plain pizza?")

在这里，我们首先创建了一个空列表，其中不包含任何配料（见 ❶ ）。在 ❷ 处我们进行了简单检查，而不是直接执行 for 循环。 在if 语句中将列表名用在条件表达式中

时，Python将在列表至少包含一个元素时返回True ，并在列表为空时返回False 。 如果 requested_toppings 不为空，就运行与前一个示例相同的 for 循环；否则，就打印

一条消息，询问顾客是否确实要点不加任何配料的普通比萨（见 ❸ ）。

在这里，这个列表为空，因此输出如下 —— 询问顾客是否确实要点普通比萨：

Are you sure you want a plain pizza?

如果这个列表不为空，将显示在比萨中添加的各种配料的输出。

5.4.3 使用多个列表

顾客的要求往往五花八门，在比萨配料方面尤其如此。如果顾客要在比萨中添加炸薯条，该怎么办呢？可使用列表和 if 语句来确定能否满足顾客的要求。

来看看在制作比萨前如何拒绝怪异的配料要求。下面的示例定义了两个列表，其中第一个列表包含比萨店供应的配料，而第二个列表包含顾客点的配料。这次对

于 requested_toppings 中的每个元素，都检查它是否是比萨店供应的配料，再决定是否在比萨中添加它：

❶ available_toppings = ['mushrooms', 'olives', 'green peppers',

'pepperoni', 'pineapple', 'extra cheese']

❷ requested_toppings = ['mushrooms', 'french fries', 'extra cheese']

❸ for requested_topping in requested_toppings:

❹ if requested_topping in available_toppings:

print("Adding " + requested_topping + ".")

❺ else:

print("Sorry, we don't have " + requested_topping + ".")

print("\nFinished making your pizza!")

在 ❶ 处，我们定义了一个列表，其中包含比萨店供应的配料。请注意，如果比萨店供应的配料是固定的，也可使用一个元组来存储它们。在 ❷ 处，我们又创建了一个列表，其中

包含顾客点的配料，请注意那个不同寻常的配料 —— 'french fries' 。在 ❸ 处，我们遍历顾客点的配料列表。在这个循环中，对于顾客点的每种配料，我们都检查它是否包

含在供应的配料列表中（见 ❹ ）；如果答案是肯定的，就将其加入到比萨中，否则将运行 else 代码块（见 ❺ ）：打印一条消息，告诉顾客不供应这种配料。

这些代码的输出整洁而详实：

Adding mushrooms.

Sorry, we don't have french fries.

Adding extra cheese.

Finished making your pizza!

通过为数不多的几行代码，我们高效地处理了一种真实的情形！

动手试一试

 

5-8 以特殊方式跟管理员打招呼

 ：创建一个至少包含 5 个用户名的列表，且其中一个用户名为 'admin' 。想象你要编写代码，在每位用户登录网站后都打印一条问

候消息。遍历用户名列表，并向每位用户打印一条问候消息。

如果用户名为 'admin' ，就打印一条特殊的问候消息，如 “Hello admin, would you like to see a status report?” 。

否则，打印一条普通的问候消息，如 “Hello Eric, thank you for logging in again” 。

5-9 处理没有用户的情形

：在为完成练习 5-8 编写的程序中，添加一条if 语句，检查用户名列表是否为空。  #  if requested_toppings: 列表为空时返回False

如果为空，就打印消息 “We need to find some users!” 。

删除列表中的所有用户名，确定将打印正确的消息。

5-10 检查用户名

 ：按下面的说明编写一个程序，模拟网站确保每位用户的用户名都独一无二的方式。

创建一个至少包含 5 个用户名的列表，并将其命名为 current_users 。

再创建一个包含 5 个用户名的列表，将其命名为 new_users ，并确保其中有一两个用户名也包含在列表 current_users 中。

遍历列表 new_users ，对于其中的每个用户名，都检查它是否已被使用。如果是这样，就打印一条消息，指出需要输入别的用户名；否则，打印一条消息，指

出这个用户名未被使用。

确保比较时不区分大消息；换句话说，如果用户名 'John' 已被使用，应拒绝用户名 'JOHN' 。

5-11 序数

：序数表示位置，如 1st 和 2nd 。大多数序数都以 th 结尾，只有 1 、 2 和 3 例外。

在一个列表中存储数字 1~9 。

遍历这个列表。

在循环中使用一个 if-elif-else 结构，以打印每个数字对应的序数。输出内容应为 1st 、 2nd 、 3rd 、 4th 、 5th 、 6th 、 7th 、 8th 和 9th ，但每个序

数都独占一行。

5.5 设置if语句的格式

本章的每个示例都展示了良好的格式设置习惯。在条件测试的格式设置方面， PEP 8 提供的唯一建议是，在诸如 == 、>= 和<= 等比较运算符两边各添加一个空格，例如， if

age < 4: 要比 if age<4: 好。

这样的空格不会影响 Python 对代码的解读，而只是让代码阅读起来更容易。

动手试一试

 

5-12 设置if语句的格式

：审核你在本章编写的程序，确保正确地设置了条件测试的格式。

5-13 自己的想法

：与刚拿起本书时相比，现在你是一名能力更强的程序员了。鉴于你对如何在程序中模拟现实情形有了更深入的认识，你可以考虑使用程序来解决一

些问题。随着编程技能不断提高，你可能想解决一些问题，请将这方面的想法记录下来。想想你可能想编写的游戏、想研究的数据集以及想创建的 Web 应用程序。

5.6 小结

在本章中，你学习了如何编写结果要么为Ture 要么为False 的条件测试。你学习了如何编写简单的if 语句、if-else 语句和if-elif-else 结构。在程序中，你使用了这

些结构来测试特定的条件，以确定这些条件是否满足。你学习了如何在利用高效的for 循环的同时，以不同于其他元素的方式对特定的列表元素进行处理。你还再次学习了

Python就代码格式方面提出的建议，这可确保即便你编写的程序越来越复杂，其代码依然易于阅读和理解。

在第6章，你将学习Python字典。字典类似于列表，但让你能够将不同的信息关联起来。你将学习如何创建和遍历字典，以及如何将字典同列表和if 语句结合起来使用。学习字典

让你能够模拟更多现实世界的情形。