Python基础拾遗

1. python 虽然是比较简单的语言，如果工作中用的不多很快一些细节就会忘记，为了使用的时候快速捡起python基础，参考市面上的入门书籍罗列一下基础知识，帮忙大家节省时间；
2. python和其他语言共有基础知识就不罗列了，这个只是总结出来python特有的基础知识；

参考书籍如下：
Python编程：从入门到实践
Python基础教程
Python编程快速上手

第1章 变量和简单数据类型

语句和函数

布尔值
“布尔”数据类型只有两种值：True 和 False。Boolean（布尔）的首字母大写，在作为 Python 代码输入时，布尔值 True 和 False不像字符串，两边没有引号，它们总是以大写字母 T 或 F 开头，后面的字母小写。

布尔操作符
3 个布尔操作符（and、or 和 not）用于比较布尔值。像比较操作符一样，它们将这些表达式求值为一个布尔值。让我们仔细看看这些操作符，从 and 操作符开始。

第2章 序列

1. 在Python中，最基本的数据结构为序列
2. Python内置了多种序列，本章重点讨论其中最常用的两种：列表和元组。另一种重要的序列是字符串
3. 列表和元组的主要不同在于，列表是可以修改的，而元组不可以。

2.1 序列-列表

2.1.1 简介

“列表”是一个值，它包含多个字构成的序列。术语“列表值”指的是列表本身，而不是指列表值之内的那些值。

列表 由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意。

在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。下面是一个简单的列表示例，这个列表包含几种自行车：
bicycles.py

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)
'''
输出
['trek', 'cannondale', 'redline', 'specialized']
'''

2.1.1.1 访问列表元素

列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。
例如，下面的代码从列表bicycles 中提取第一款自行车：

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles[0]) #❶ 

❶处演示了访问列表元素的语法。当你请求获取列表元素时，Python只返回该元素，而不包括方括号和引号：
trek

2.1.1.2 使用列表中的各个值

可像使用其他变量一样使用列表中的各个值。例如，你可以使用拼接根据列表中的值来创建消息。
下面来尝试从列表中提取第一款自行车，并使用这个值来创建一条消息：
bicycles = [‘trek’, ‘cannondale’, ‘redline’, ‘specialized’]
❶ message = "My first bicycle was a " + bicycles[0].title() + “.”
print(message)
我们使用bicycles[0] 的值生成了一个句子，并将其存储在变量message 中（见❶）。输出是一个简单的句子，其中包含列表中的第一款自行车：
My first bicycle was a Trek.

2.1.2 修改、添加和删除元素 修

你创建的大多数列表都将是动态的，这意味着列表创建后，将随着程序的运行增删元素。例如，你创建一个游戏，要求玩家射杀从天而降的外星人；为此，可在开始时将一些外星人存储在列表中，然后每当有外星人被射杀时，都将其从列表中删除，而每次有新的外星人出现在屏幕上时，都将其添加到列表中。在整个游戏运行期间，外星人列表的长度将不断变化。

3.2.1 修改列表元素
修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。
例如，假设有一个摩托车列表，其中的第一个元素为’honda’ ，如何修改它的值呢？
motorcycles.py
❶ motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
print(motorcycles)
❷ motorcycles[0] = ‘ducati’
print(motorcycles)
我们首先定义一个摩托车列表，其中的第一个元素为’honda’ （见❶）。接下来，我们将第一个元素的值改为’ducati’ （见❷）。输出表明，第一个元素的值确实变了，但
其他列表元素的值没变：
[‘honda’, ‘yamaha’, ‘suzuki’]
[‘ducati’, ‘yamaha’, ‘suzuki’]
你可以修改任何列表元素的值，而不仅仅是第一个元素的值。
3.2.2 在列表中添加元素
你可能出于众多原因要在列表中添加新元素，例如，你可能希望游戏中出现新的外星人、添加可视化数据或给网站添加新注册的用户。Python提供了多种在既有列表中添加新数据
的方式。

1. 在列表末尾添加元素 在
   在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。给列表附加元素时，它将添加到列表末尾。继续使用前一个示例中的列表，在其末尾添加新元素’ducati’ ：
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   print(motorcycles)
   ❶ motorcycles.append(‘ducati’)
   print(motorcycles)
   方法append() 将元素’ducati’ 添加到了列表末尾（见❶ ），而不影响列表中的其他所有元素：
   [‘honda’, ‘yamaha’, ‘suzuki’]
   [‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
   方法append() 让动态地创建列表易如反掌，例如，你可以先创建一个空列表，再使用一系列的append() 语句添加元素。下面来创建一个空列表，再在其中添加元
   素’honda’ 、‘yamaha’ 和’suzuki’ ：
   motorcycles = []
   motorcycles.append(‘honda’)
   motorcycles.append(‘yamaha’)
   motorcycles.append(‘suzuki’)
   print(motorcycles)
   最终的列表与前述示例中的列表完全相同：
   [‘honda’, ‘yamaha’, ‘suzuki’]
   这种创建列表的方式极其常见，因为经常要等程序运行后，你才知道用户要在程序中存储哪些数据。为控制用户，可首先创建一个空列表，用于存储用户将要输入的值，然后将
   用户提供的每个新值附加到列表中。
2. 在列表中插入元素 在
   使用方法insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   ❶ motorcycles.insert(0, ‘ducati’)
   print(motorcycles)
   在这个示例中，值’ducati’ 被插入到了列表开头（见❶）；方法insert() 在索引0 处添加空间，并将值’ducati’ 存储到这个地方。这种操作将列表中既有的每个元素都右
   移一个位置：
   [‘ducati’, ‘honda’, ‘yamaha’, ‘suzuki’]
   3.2.3 从列表中删除元素
   你经常需要从列表中删除一个或多个元素。例如，玩家将空中的一个外星人射杀后，你很可能要将其从存活的外星人列表中删除；当用户在你创建的Web应用中注销其账户时，
   你需要将该用户从活跃用户列表中删除。你可以根据位置或值来删除列表中的元素。
3. 使用使 del 语句删除元素 语
   如果知道要删除的元素在列表中的位置，可使用del 语句。
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   print(motorcycles)
   ❶ del motorcycles[0]
   print(motorcycles)
   ❶ 处的代码使用del 删除了列表motorcycles 中的第一个元素——‘honda’ ：
   [‘honda’, ‘yamaha’, ‘suzuki’]
   [‘yamaha’, ‘suzuki’]
   使用del 可删除任何位置处的列表元素，条件是知道其索引。下例演示了如何删除前述列表中的第二个元素——‘yamaha’ ：
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   print(motorcycles)
   del motorcycles[1]
   print(motorcycles)
   下面的输出表明，已经将第二款摩托车从列表中删除了：
   [‘honda’, ‘yamaha’, ‘suzuki’]
   [‘honda’, ‘suzuki’]
   在这两个示例中，使用del 语句将值从列表中删除后，你就无法再访问它了。
4. 使用方法 使 pop() 删除元素 删
   有时候，你要将元素从列表中删除，并接着使用它的值。例如，你可能需要获取刚被射杀的外星人的 x 和 y 坐标，以便在相应的位置显示爆炸效果；在Web应用程序中，你可能
   要将用户从活跃成员列表中删除，并将其加入到非活跃成员列表中。
   方法pop() 可删除列表末尾的元素，并让你能够接着使用它。术语弹出弹 （pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
   下面从列表motorcycles 中弹出一款摩托车：
   ❶ motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   print(motorcycles)
   ❷ popped_motorcycle = motorcycles.pop() ❸ print(motorcycles) ❹ print(popped_motorcycle)
   我们首先定义并打印了列表motorcycles （见❶）。接下来，我们从这个列表中弹出一个值，并将其存储到变量popped_motorcycle 中（见❷）。然后我们打印这个列
   表，以核实从其中删除了一个值（见❸）。最后，我们打印弹出的值，以证明我们依然能够访问被删除的值（见❹）。
   输出表明，列表末尾的值’suzuki’ 已删除，它现在存储在变量popped_motorcycle 中：
   [‘honda’, ‘yamaha’, ‘suzuki’]
   [‘honda’, ‘yamaha’]
   suzuki
   方法pop() 是怎么起作用的呢？假设列表中的摩托车是按购买时间存储的，就可使用方法pop() 打印一条消息，指出最后购买的是哪款摩托车：
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   last_owned = motorcycles.pop()
   print("The last motorcycle I owned was a " + last_owned.title() + “.”)
   输出是一个简单的句子，指出了最新购买的是哪款摩托车：
   The last motorcycle I owned was a Suzuki.
5. 弹出列表中任何位置处的元素 弹
   实际上，你可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
   ❶ first_owned = motorcycles.pop(0) ❷ print('The first motorcycle I owned was a ’ + first_owned.title() + ‘.’)
   首先，我们弹出了列表中的第一款摩托车（见❶），然后打印了一条有关这辆摩托车的消息（见❷）。输出是一个简单的句子，描述了我购买的第一辆摩托车：
   The first motorcycle I owned was a Honda.
   别忘了，每当你使用pop() 时，被弹出的元素就不再在列表中了。
   如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元
   素后还能继续使用它，就使用方法pop() 。
6. 根据值删除元素 根
   有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove() 。
   例如，假设我们要从列表motorcycles 中删除值’ducati’ 。
   motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
   print(motorcycles)
   ❶ motorcycles.remove(‘ducati’)
   print(motorcycles)
   ❶ 处的代码让Python确定’ducati’ 出现在列表的什么地方，并将该元素删除：
   [‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
   [‘honda’, ‘yamaha’, ‘suzuki’]
   使用remove() 从列表中删除元素时，也可接着使用它的值。下面删除值’ducati’ ，并打印一条消息，指出要将其从列表中删除的原因：
   ❶ motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
   print(motorcycles)
   ❷ too_expensive = ‘ducati’ ❸ motorcycles.remove(too_expensive)
   print(motorcycles) ❹ print(“\nA " + too_expensive.title() + " is too expensive for me.”)
   在❶处定义列表后，我们将值’ducati’ 存储在变量too_expensive 中（见❷）。接下来，我们使用这个变量来告诉Python将哪个值从列表中删除（见❸）。最后，
   值’ducati’ 已经从列表中删除，但它还存储在变量too_expensive 中（见❹），让我们能够打印一条消息，指出将’ducati’ 从列表motorcycles 中删除的原因：
   [‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
   [‘honda’, ‘yamaha’, ‘suzuki’]
   A Ducati is too expensive for me.

注意注 方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。你将在第7章学习如何这
样做。

3.3 组织列表
在你创建的列表中，元素的排列顺序常常是无法预测的，因为你并非总能控制用户提供数据的顺序。这虽然在大多数情况下都是不可避免的，但你经常需要以特定的顺序呈现信
息。有时候，你希望保留列表元素最初的排列顺序，而有时候又需要调整排列顺序。Python提供了很多组织列表的方式，可根据具体情况选用。
3.3.1 使用方法 使 sort() 对列表进行永久性排序 对
Python方法sort() 让你能够较为轻松地对列表进行排序。假设你有一个汽车列表，并要让其中的汽车按字母顺序排列。为简化这项任务，我们假设该列表中的所有值都是小写
的。
cars.py
cars = [‘bmw’, ‘audi’, ‘toyota’, ‘subaru’] ❶ cars.sort()
print(cars)
方法sort() （见❶）永久性地修改了列表元素的排列顺序。现在，汽车是按字母顺序排列的，再也无法恢复到原来的排列顺序：
[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True 。下面的示例将汽车列表按与字母顺序相反的顺序排列：
cars = [‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
cars.sort(reverse=True)
print(cars)
同样，对列表元素排列顺序的修改是永久性的：
[‘toyota’, ‘subaru’, ‘bmw’, ‘audi’]
3.3.2 使用函数 使 sorted() 对列表进行临时排序 对
要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted() 。函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排
列顺序。
下面尝试对汽车列表调用这个函数。
cars = [‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
❶ print(“Here is the original list:”)
print(cars)
❷ print(“\nHere is the sorted list:”)
print(sorted(cars))
❸ print(“\nHere is the original list again:”)
print(cars)
我们首先按原始顺序打印列表（见❶），再按字母顺序显示该列表（见❷）。以特定顺序显示列表后，我们进行核实，确认列表元素的排列顺序与以前相同（见❸）。
Here is the original list:
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
Here is the sorted list:
[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
❹ Here is the original list again:
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
注意，调用函数sorted() 后，列表元素的排列顺序并没有变（见❹）。如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted() 传递参数reverse=True 。
注意注 在并非所有的值都是小写时，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的
要复杂。然而，大多数排序方式都基于本节介绍的知识。
3.3.3 倒着打印列表 倒
要反转列表元素的排列顺序，可使用方法reverse() 。假设汽车列表是按购买时间排列的，可轻松地按相反的顺序排列其中的汽车：
cars = [‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
print(cars)
cars.reverse()
print(cars)
注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
[‘subaru’, ‘toyota’, ‘audi’, ‘bmw’]
方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可。
3.3.4 确定列表的长度 确
使用函数len() 可快速获悉列表的长度。在下面的示例中，列表包含4个元素，因此其长度为4：

>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4

在你需要完成如下任务时，len() 很有用：确定还有多少个外星人未被射杀，需要管理多少项可视化数据，网站有多少注册用户等。
注意注 Python计算列表元素数时从1开始，因此确定列表长度时，你应该不会遇到差一错误。

3.4 使用列表时避免索引错误 使
刚开始使用列表时，经常会遇到一种错误。假设你有一个包含三个元素的列表，却要求获取第四个元素：
motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
print(motorcycles[3])
这将导致索引错误 索 ：
Traceback (most recent call last):
File “motorcycles.py”, line 3, in
print(motorcycles[3])
IndexError: list index out of range
Python试图向你提供位于索引3处的元素，但它搜索列表motorcycles 时，却发现索引3处没有元素。鉴于列表索引差一的特征，这种错误很常见。有些人从1开始数，因此以为
第三个元素的索引为3；但在Python中，第三个元素的索引为2，因为索引是从0开始的。
索引错误意味着Python无法理解你指定的索引。程序发生索引错误时，请尝试将你指定的索引减1，然后再次运行程序，看看结果是否正确。
别忘了，每当需要访问最后一个列表元素时，都可使用索引-1 。这在任何情况下都行之有效，即便你最后一次访问列表后，其长度发生了变化：
motorcycles = [‘honda’, ‘yamaha’, ‘suzuki’]
print(motorcycles[-1])
索引-1 总是返回最后一个列表元素，这里为值’suzuki’ ：
‘suzuki’
仅当列表为空时，这种访问最后一个元素的方式才会导致错误：
motorcycles = []
print(motorcycles[-1])
列表motorcycles 不包含任何元素，因此Python返回一条索引错误消息：
Traceback (most recent call last):
File “motorcyles.py”, line 3, in
print(motorcycles[-1])
IndexError: list index out of range
注意注 发生索引错误却找不到解决办法时，请尝试将列表或其长度打印出来。列表可能与你以为的截然不同，在程序对其进行了动态处理时尤其如此。通过查看列表
或其包含的元素数，可帮助你找出这种逻辑错误。

2.1.2 列表数据类型

1. 用下标取得列表中的单个值
2. 利用切片取得子列表
3. 用 len()取得列表的长度
4. 用下标改变列表中的值
5. 列表连接和列表复制
6. 用 del 语句从列表中删除值

2.1.3 使用列表

1. 列表用于循环
2. in 和 not in 操作符
3. 多重赋值技巧
4. 增强的赋值操作

2.1.4 列表方法

1.用 index()方法在列表中查找值
2.用 append()和 insert()方法在列表中添加值
3.用 remove()方法从列表中删除值
4.用 sort()方法将列表中的值排序
5.

操作列表

4.1 遍历整个列表 遍
你经常需要遍历列表的所有元素，对每个元素执行相同的操作。例如，在游戏中，可能需要将每个界面元素平移相同的距离；对于包含数字的列表，可能需要对每个元素执行相
同的统计运算；在网站中，可能需要显示文章列表中的每个标题。需要对列表中的每个元素都执行相同的操作时，可使用Python中的for 循环。
假设我们有一个魔术师名单，需要将其中每个魔术师的名字都打印出来。为此，我们可以分别获取名单中的每个名字，但这种做法会导致多个问题。例如，如果名单很长，将包
含大量重复的代码。另外，每当名单的长度发生变化时，都必须修改代码。通过使用for 循环，可让Python去处理这些问题。
下面使用for 循环来打印魔术师名单中的所有名字：
magicians.py
❶ magicians = [‘alice’, ‘david’, ‘carolina’] ❷ for magician in magicians: ❸ print(magician)
首先，我们像第3章那样定义了一个列表（见❶）。接下来，我们定义了一个for 循环（见❷）；这行代码让Python从列表magicians 中取出一个名字，并将其存储在变
量magician 中。最后，我们让Python打印前面存储到变量magician 中的名字（见❸）。这样，对于列表中的每个名字，Python都将重复执行❷处和❸处的代码行。你可以这
样解读这些代码：对于列表magicians 中的每位魔术师，都将其名字打印出来。输出很简单，就是列表中所有的姓名：
alice
david
carolina
4.1.1 深入地研究循环 深
循环这种概念很重要，因为它是让计算机自动完成重复工作的常见方式之一。例如，在前面的magicians.py中使用的简单循环中，Python将首先读取其中的第一行代码：
for magician in magicians:
这行代码让Python获取列表magicians 中的第一个值（‘alice’ ），并将其存储到变量magician 中。接下来，Python读取下一行代码：
print(magician)
它让Python打印magician 的值——依然是’alice’ 。鉴于该列表还包含其他值，Python返回到循环的第一行：
for magician in magicians:
Python获取列表中的下一个名字——‘david’ ，并将其存储到变量magician 中，再执行下面这行代码：
print(magician)
Python再次打印变量magician 的值——当前为’david’ 。接下来，Python再次执行整个循环，对列表中的最后一个值——‘carolina’ 进行处理。至此，列表中没有其他的值
了，因此Python接着执行程序的下一行代码。在这个示例中，for 循环后面没有其他的代码，因此程序就此结束。
刚开始使用循环时请牢记，对列表中的每个元素，都将执行循环指定的步骤，而不管列表包含多少个元素。如果列表包含一百万个元素，Python就重复执行指定的步骤一百万次，
且通常速度非常快。
另外，编写for 循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助。例如，对于小猫列表、小狗列表和
一般性列表，像下面这样编写for 循环的第一行代码是不错的选择：
for cat in cats:
for dog in dogs:
for item in list_of_items:
这些命名约定有助于你明白for 循环中将对每个元素执行的操作。使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表。
4.1.2 在在for 循环中执行更多的操作 循
在for 循环中，可对每个元素执行任何操作。下面来扩展前面的示例，对于每位魔术师，都打印一条消息，指出他的表演太精彩了。
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians: ❶ print(magician.title() + “, that was a great trick!”)
相比于前一个示例，唯一的不同是对于每位魔术师，都打印了一条以其名字为抬头的消息（见❶）。这个循环第一次迭代时，变量magician 的值为’alice’ ，因此Python打印
的第一条消息的抬头为’Alice’ 。第二次迭代时，消息的抬头为’David’ ，而第三次迭代时，抬头为’Carolina’ 。
下面的输出表明，对于列表中的每位魔术师，都打印了一条个性化消息：
Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
在for 循环中，想包含多少行代码都可以。在代码行for magician in magicians 后面，每个缩进的代码行都是循环的一部分，且将针对列表中的每个值都执行一次。因
此，可对列表中的每个值执行任意次数的操作。
下面再添加一行代码，告诉每位魔术师，我们期待他的下一次表演：
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians:
print(magician.title() + “, that was a great trick!”) ❶ print(“I can’t wait to see your next trick, " + magician.title() + “.\n”)
由于两条print 语句都缩进了，因此它们都将针对列表中的每位魔术师执行一次。第二条print 语句中的换行符”\n" （见❶）在每次迭代结束后都插入一个空行，从而整洁地
将针对各位魔术师的消息编组：
Alice, that was a great trick!
I can’t wait to see your next trick, Alice.
David, that was a great trick!
I can’t wait to see your next trick, David.
Carolina, that was a great trick!
I can’t wait to see your next trick, Carolina.
在for 循环中，想包含多少行代码都可以。实际上，你会发现使用for 循环对每个元素执行众多不同的操作很有用。
4.1.3 在在for 循环结束后执行一些操作 循
for 循环结束后再怎么做呢？通常，你需要提供总结性输出或接着执行程序必须完成的其他任务。
在for 循环后面，没有缩进的代码都只执行一次，而不会重复执行。下面来打印一条向全体魔术师致谢的消息，感谢他们的精彩表演。想要在打印给各位魔术师的消息后面打印
一条给全体魔术师的致谢消息，需要将相应的代码放在for 循环后面，且不缩进：
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians:
print(magician.title() + “, that was a great trick!”)
print("I can’t wait to see your next trick, " + magician.title() + “.\n”)
❶ print(“Thank you, everyone. That was a great magic show!”)
你在前面看到了，开头两条print 语句针对列表中每位魔术师重复执行。然而，由于第三条print 语句没有缩进，因此只执行一次：
Alice, that was a great trick!
I can’t wait to see your next trick, Alice.
David, that was a great trick!
I can’t wait to see your next trick, David.
Carolina, that was a great trick!
I can’t wait to see your next trick, Carolina.
Thank you, everyone. That was a great magic show!
使用for 循环处理数据是一种对数据集执行整体操作的不错的方式。例如，你可能使用for 循环来初始化游戏——遍历角色列表，将每个角色都显示到屏幕上；再在循环后面添
加一个不缩进的代码块，在屏幕上绘制所有角色后显示一个PlayNow按钮。
4.2 避免缩进错误 避
Python根据缩进来判断代码行与前一个代码行的关系。在前面的示例中，向各位魔术师显示消息的代码行是for 循环的一部分，因为它们缩进了。Python通过使用缩进让代码更易
读；简单地说，它要求你使用缩进让代码整洁而结构清晰。在较长的Python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识。
当你开始编写必须正确缩进的代码时，需要注意一些常见的缩进错误 缩 。例如，有时候，程序员会将不需要缩进的代码块缩进，而对于必须缩进的代码块却忘了缩进。通过查看这
样的错误示例，有助于你以后避开它们，以及在它们出现在程序中时进行修复。
下面来看一些较为常见的缩进错误。
4.2.1 忘记缩进 忘
对于位于for 语句后面且属于循环组成部分的代码行，一定要缩进。如果你忘记缩进，Python会提醒你：
magicians.py
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians: ❶ print(magician)
print 语句（见❶）应缩进却没有缩进。Python没有找到期望缩进的代码块时，会让你知道哪行代码有问题。
File “magicians.py”, line 3
print(magician)
^
IndentationError: expected an indented block
通常，将紧跟在for 语句后面的代码行缩进，可消除这种缩进错误。
4.2.2 忘记缩进额外的代码行 忘
有时候，循环能够运行而不会报告错误，但结果可能会出乎意料。试图在循环中执行多项任务，却忘记缩进其中的一些代码行时，就会出现这种情况。
例如，如果忘记缩进循环中的第2行代码（它告诉每位魔术师，我们期待他的下一次表演），就会出现这种情况：
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians:
print(magician.title() + “, that was a great trick!”) ❶ print("I can’t wait to see your next trick, " + magician.title() + “.\n”)
第二条print 语句（见❶）原本需要缩进，但Python发现for 语句后面有一行代码是缩进的，因此它没有报告错误。最终的结果是，对于列表中的每位魔术师，都执行了第一
条print 语句，因为它缩进了；而第二条print 语句没有缩进，因此它只在循环结束后执行一次。由于变量magician 的终值为’carolina’ ，因此只有她收到了消息“looking
forward to the next trick”：
Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
I can’t wait to see your next trick, Carolina.
这是一个逻辑错误 逻 。从语法上看，这些Python代码是合法的，但由于存在逻辑错误，结果并不符合预期。如果你预期某项操作将针对每个列表元素都执行一次，但它却只执行了
一次，请确定是否需要将一行或多行代码缩进。
4.2.3 不必要的缩进 不
如果你不小心缩进了无需缩进的代码行，Python将指出这一点：
hello_world.py
message = “Hello Python world!”
❶ print(message)
print 语句（见❶）无需缩进，因为它并不属于前一行代码，因此Python将指出这种错误：
File “hello_world.py”, line 2
print(message)
^
IndentationError: unexpected indent
为避免意外缩进错误，请只缩进需要缩进的代码。在前面编写的程序中，只有要在for 循环中对每个元素执行的代码需要缩进。
4.2.4 循环后不必要的缩进 循
如果你不小心缩进了应在循环结束后执行的代码，这些代码将针对每个列表元素重复执行。在有些情况下，这可能导致Python报告语法错误，但在大多数情况下，这只会导致逻辑
错误。
例如，如果不小心缩进了感谢全体魔术师精彩表演的代码行，结果将如何呢？
magicians = [‘alice’, ‘david’, ‘carolina’]
for magician in magicians:
print(magician.title() + “, that was a great trick!”)
print("I can’t wait to see your next trick, " + magician.title() + “.\n”)
❶ print(“Thank you everyone, that was a great magic show!”)
由于❶处的代码行被缩进，它将针对列表中的每位魔术师执行一次，如❷所示：
Alice, that was a great trick!
I can’t wait to see your next trick, Alice.
❷ Thank you everyone, that was a great magic show!
David, that was a great trick!
I can’t wait to see your next trick, David.
❷ Thank you everyone, that was a great magic show!
Carolina, that was a great trick!
I can’t wait to see your next trick, Carolina.
❷ Thank you everyone, that was a great magic show!
这也是一个逻辑错误，与4.2.2节的错误类似。Python不知道你的本意，只要代码符合语法，它就会运行。如果原本只应执行一次的操作执行了多次，请确定你是否不应该缩进执行
该操作的代码。
4.2.5 遗漏了冒号 遗
for 语句末尾的冒号告诉Python，下一行是循环的第一行。
magicians = [‘alice’, ‘david’, ‘carolina’] ❶ for magician in magicians
print(magician)
如果你不小心遗漏了冒号，如❶所示，将导致语法错误，因为Python不知道你意欲何为。这种错误虽然易于消除，但并不那么容易发现。程序员为找出这样的单字符错误，花费的
时间多得令人惊讶。这样的错误之所以难以发现，是因为通常在我们的意料之外。
动手试一试 动
4-1 比萨比 ：想出至少三种你喜欢的比萨，将其名称存储在一个列表中，再使用for 循环将每种比萨的名称都打印出来。
修改这个for 循环，使其打印包含比萨名称的句子，而不仅仅是比萨的名称。对于每种比萨，都显示一行输出，如“I like pepperoni pizza”。
在程序末尾添加一行代码，它不在for 循环中，指出你有多喜欢比萨。输出应包含针对每种比萨的消息，还有一个总结性句子，如“I really love pizza!”。
4-2 动物动 ：想出至少三种有共同特征的动物，将这些动物的名称存储在一个列表中，再使用for 循环将每种动物的名称都打印出来。
修改这个程序，使其针对每种动物都打印一个句子，如“Adogwould makea great pet”。
在程序末尾添加一行代码，指出这些动物的共同之处，如打印诸如“Any oftheseanimals would makea great pet!”这样的句子。
4.3 创建数值列表 创
需要存储一组数字的原因有很多，例如，在游戏中，需要跟踪每个角色的位置，还可能需要跟踪玩家的几个最高得分。在数据可视化中，处理的几乎都是由数字（如温度、距
离、人口数量、经度和纬度等）组成的集合。
列表非常适合用于存储数字集合，而Python提供了很多工具，可帮助你高效地处理数字列表。明白如何有效地使用这些工具后，即便列表包含数百万个元素，你编写的代码也能运
行得很好。
4.3.1 使用函数 使 range()
Python函数range() 让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range() 来打印一系列的数字：
numbers.py
for value in range(1,5):
print(value)
上述代码好像应该打印数字1~5，但实际上它不会打印数字5：
1
2
3
4
在这个示例中，range() 只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值
后停止，因此输出不包含第二个值（这里为5）。
要打印数字1~5，需要使用range(1,6) ：
for value in range(1,6):
print(value)
这样，输出将从1开始，到5结束：
1
2
3
4
5
使用range() 时，如果输出不符合预期，请尝试将指定的值加1或减1。
4.3.2 使用使 range() 创建数字列表 创
要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。如果将range() 作为list() 的参数，输出将为一个数字列表。
在前一节的示例中，我们打印了一系列数字。要将这些数字转换为一个列表，可使用list() ：
numbers = list(range(1,6))
print(numbers)
结果如下：
[1, 2, 3, 4, 5]
使用函数range() 时，还可指定步长。例如，下面的代码打印1~10内的偶数：
even_numbers.py
even_numbers = list(range(2,11,2))
print(even_numbers)
在这个示例中，函数range() 从2开始数，然后不断地加2，直到达到或超过终值（11），因此输出如下：
[2, 4, 6, 8, 10]
使用函数range() 几乎能够创建任何需要的数字集，例如，如何创建一个列表，其中包含前10个整数（即1~10）的平方呢？在Python中，两个星号（** ）表示乘方运算。下面
的代码演示了如何将前10个整数的平方加入到一个列表中：
squares.py
❶ squares = [] ❷ for value in range(1,11): ❸ square = value2 ❹ squares.append(square)
❺ print(squares)
首先，我们创建了一个空列表（见❶）；接下来，使用函数range() 让Python遍历1~10的值（见❷）。在循环中，计算当前值的平方，并将结果存储到变量square 中（见
❸）。然后，将新计算得到的平方值附加到列表squares 末尾（见❹）。最后，循环结束后，打印列表squares （见❺）：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
为让这些代码更简洁，可不使用临时变量square ，而直接将每个计算得到的值附加到列表末尾：
squares = []
for value in range(1,11): ❶ squares.append(value2)
print(squares)
❶处的代码与squares.py中❸处和❹处的代码等效。在循环中，计算每个值的平方，并立即将结果附加到列表squares 的末尾。
创建更复杂的列表时，可使用上述两种方法中的任何一种。有时候，使用临时变量会让代码更易读；而在其他情况下，这样做只会让代码无谓地变长。你首先应该考虑的是，编
写清晰易懂且能完成所需功能的代码；等到审核代码时，再考虑采用更高效的方法。
4.3.3 对数字列表执行简单的统计计算 对
有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digits)
0
max(digits)
9
sum(digits)
45
注意注 出于版面考虑，本节使用的数字列表都很短，但这里介绍的知识也适用于包含数百万个数字的列表。
4.3.4 列表解析 列
前面介绍的生成列表squares 的方式包含三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表。列表解析 列 将for 循环和创建新元素的代码合并成一行，并自动
附加新元素。面向初学者的书籍并非都会介绍列表解析，这里之所以介绍列表解析，是因为等你开始阅读他人编写的代码时，很可能会遇到它们。
下面的示例使用列表解析创建你在前面看到的平方数列表：
squares.py
squares = [value2 for value in range(1,11)]
print(squares)
要使用这种语法，首先指定一个描述性的列表名，如squares ；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式
为value2 ，它计算平方值。接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。在这个示例中，for 循环为for value in range(1,11) ，它将值
1~10提供给表达式value2 。请注意，这里的for 语句末尾没有冒号。
结果与你在前面看到的平方数列表相同：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
要创建自己的列表解析，需要经过一定的练习，但能够熟练地创建常规列表后，你会发现这样做是完全值得的。当你觉得编写三四行代码来生成列表有点繁复时，就应考虑创建
列表解析了。
动手试一试 动
4-3 数到数 20 ：使用一个for 循环打印数字1~20（含）。
4-4 一百万 一 ：创建一个列表，其中包含数字1~1 000 000，再使用一个for 循环将这些数字打印出来（如果输出的时间太长，按Ctrl+ C停止输出，或关闭输出窗口）。
4-5 计算计 1~1 000 000的总和 的 ：创建一个列表，其中包含数字1~1 000 000，再使用min() 和max() 核实该列表确实是从1开始，到1 000 000结束的。另外，对这个列表
调用函数sum() ，看看Python将一百万个数字相加需要多长时间。
4-6 奇数奇 ：通过给函数range() 指定第三个参数来创建一个列表，其中包含1~20的奇数；再使用一个for 循环将这些数字都打印出来。
4-7 3的倍数 的 ：创建一个列表，其中包含3~30内能被3整除的数字；再使用一个for 循环将这个列表中的数字都打印出来。
4-8 立方立 ：将同一个数字乘三次称为立方。例如，在Python中，2的立方用23 表示。请创建一个列表，其中包含前10个整数（即1~10）的立方，再使用一个for 循
环将这些立方数都打印出来。
4-9 立方解析 立 ：使用列表解析生成一个列表，其中包含前10个整数的立方。
4.4 使用列表的一部分 使
在第3章中，你学习了如何访问单个列表元素。在本章中，你一直在学习如何处理列表的所有元素。你还可以处理列表的部分元素——Python称之为切片切 。
4.4.1 切片切
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需
要指定索引0~3，这将输出分别为0 、1 和2 的元素。
下面的示例处理的是一个运动队成员列表：
players.py
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’] ❶ print(players[0:3])
❶处的代码打印该列表的一个切片，其中只包含三名队员。输出也是一个列表，其中包含前三名队员：
[‘charles’, ‘martina’, ‘michael’]
你可以生成列表的任何子集，例如，如果你要提取列表的第2~4个元素，可将起始索引指定为1 ，并将终止索引指定为4 ：
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’]
print(players[1:4])
这一次，切片始于’marita’ ，终于’florence’ ：
[‘martina’, ‘michael’, ‘florence’]
如果你没有指定第一个索引，Python将自动从列表开头开始：
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’]
print(players[:4])
由于没有指定起始索引，Python从列表开头开始提取：
[‘charles’, ‘martina’, ‘michael’, ‘florence’]
要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2 ，并省略终止索引：
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’]
print(players[2:])
Python将返回从第3个元素到列表末尾的所有元素：
[‘michael’, ‘florence’, ‘eli’]
无论列表多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素。本书前面说过，负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。
例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:] ：
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’]
print(players[-3:])
上述代码打印最后三名队员的名字，即便队员名单的长度发生变化，也依然如此。
4.4.2 遍历切片 遍
如果要遍历列表的部分元素，可在for 循环中使用切片。在下面的示例中，我们遍历前三名队员，并打印他们的名字：
players = [‘charles’, ‘martina’, ‘michael’, ‘florence’, ‘eli’]
print(“Here are the first three players on my team:”) ❶ for player in players[:3]:
print(player.title())
❶处的代码没有遍历整个队员列表，而只遍历前三名队员：
Here are the first three players on my team:
Charles
Martina
Michael
在很多情况下，切片都很有用。例如，编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中。然后，为获取该玩家的三个最高得分，你可以将该列表按降序排
列，再创建一个只包含前三个得分的切片。处理数据时，可使用切片来进行批量处理；编写Web应用程序时，可使用切片来分页显示信息，并在每页显示数量合适的信息。
4.4.3 复制列表 复
你经常需要根据既有列表创建全新的列表。下面来介绍复制列表的工作原理，以及复制列表可提供极大帮助的一种情形。
要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] ）。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个
列表。
例如，假设有一个列表，其中包含你最喜欢的四种食品，而你还想创建另一个列表，在其中包含一位朋友喜欢的所有食品。不过，你喜欢的食品，这位朋友都喜欢，因此你可以
通过复制来创建这个列表：
foods.py
❶ my_foods = [‘pizza’, ‘falafel’, ‘carrot cake’] ❷ friend_foods = my_foods[:]
print(“My favorite foods are:”)
print(my_foods)
print(“\nMy friend’s favorite foods are:”)
print(friend_foods)
我们首先创建了一个名为my_foods 的食品列表（见❶），然后创建了一个名为friend_foods 的新列表（见❷）。我们在不指定任何索引的情况下从列表my_foods 中提取
一个切片，从而创建了这个列表的副本，再将该副本存储到变量friend_foods 中。打印每个列表后，我们发现它们包含的食品相同：
My favorite foods are:
[‘pizza’, ‘falafel’, ‘carrot cake’]
My friend’s favorite foods are:
[‘pizza’, ‘falafel’, ‘carrot cake’]
为核实我们确实有两个列表，下面在每个列表中都添加一种食品，并核实每个列表都记录了相应人员喜欢的食品：
my_foods = [‘pizza’, ‘falafel’, ‘carrot cake’] ❶ friend_foods = my_foods[:]
❷ my_foods.append(‘cannoli’) ❸ friend_foods.append(‘ice cream’)
print(“My favorite foods are:”)
print(my_foods)
print(“\nMy friend’s favorite foods are:”)
print(friend_foods)
与前一个示例一样，我们首先将my_foods 的元素复制到新列表friend_foods 中（见❶）。接下来，在每个列表中都添加一种食品：在列表my_foods 中添加’cannoli’ （见❷），而在friend_foods 中添加’ice cream’ （见❸）。最后，打印这两个列表，核实这两种食品包含在正确的列表中。
My favorite foods are: ❹ [‘pizza’, ‘falafel’, ‘carrot cake’, ‘cannoli’]
My friend’s favorite foods are: ❺ [‘pizza’, ‘falafel’, ‘carrot cake’, ‘ice cream’]
❹处的输出表明，‘cannoli’ 包含在你喜欢的食品列表中，而’ice cream’ 没有。❺处的输出表明，‘ice cream’ 包含在你朋友喜欢的食品列表中，而’cannoli’ 没
有。倘若我们只是简单地将my_foods 赋给friend_foods ，就不能得到两个列表。例如，下例演示了在不使用切片的情况下复制列表的情况：
my_foods = [‘pizza’, ‘falafel’, ‘carrot cake’]
#这行不通
❶ friend_foods = my_foods
my_foods.append(‘cannoli’)
friend_foods.append(‘ice cream’)
print(“My favorite foods are:”)
print(my_foods)
print(“\nMy friend’s favorite foods are:”)
print(friend_foods)
这里将my_foods 赋给friend_foods ，而不是将my_foods 的副本存储到friend_foods （见❶）。这种语法实际上是让Python将新变量friend_foods 关联到包含
在my_foods 中的列表，因此这两个变量都指向同一个列表。鉴于此，当我们将’cannoli’ 添加到my_foods 中时，它也将出现在friend_foods 中；同样，虽然’ice
cream’ 好像只被加入到了friend_foods 中，但它也将出现在这两个列表中。
输出表明，两个列表是相同的，这并非我们想要的结果：
My favorite foods are:
[‘pizza’, ‘falafel’, ‘carrot cake’, ‘cannoli’, ‘ice cream’]
My friend’s favorite foods are:
[‘pizza’, ‘falafel’, ‘carrot cake’, ‘cannoli’, ‘ice cream’]
注意注 现在暂时不要考虑这个示例中的细节。基本上，当你试图使用列表的副本时，如果结果出乎意料，请确认你像第一个示例那样使用切片复制了列表。
动手试一试 动
4-10 切片切 ：选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。
打印消息“Thefirst threeitems in thelistare:”，再使用切片来打印列表的前三个元素。
打印消息“Threeitems fromthe middle ofthelistare:”，再使用切片来打印列表中间的三个元素。
打印消息“Thelast threeitems in thelistare:”，再使用切片来打印列表末尾的三个元素。
4-11 你的比萨和我的比萨 你 ：在你为完成练习4-1而编写的程序中，创建比萨列表的副本，并将其存储到变量friend_pizzas 中，再完成如下任务。
在原来的比萨列表中添加一种比萨。
在列表friend_pizzas 中添加另一种比萨。
核实你有两个不同的列表。为此，打印消息“My favorite pizzasare:”，再使用一个for 循环来打印第一个列表；打印消息“My friend’s favorite pizzasare:”，再使用一
个for 循环来打印第二个列表。核实新增的比萨被添加到了正确的列表中。
4-12 使用多个循环 使 ：在本节中，为节省篇幅，程序foods.py的每个版本都没有使用for 循环来打印列表。请选择一个版本的foods.py，在其中编写两个for 循环，将各
个食品列表都打印出来。
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
dimensions[0] = 250
TypeError: ‘tuple’ object does not support item assignment
代码试图修改矩形的尺寸时，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 语句对特定元素采取特定的措施。

2.2 序列-元组

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
dimensions[0] = 250
TypeError: ‘tuple’ object does not support item assignment
代码试图修改矩形的尺寸时，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
相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

2.3 序列-字符串

1. 原始字符串
   可以在字符串开始的引号之前加上 r，使它成为原始字符串。“原始字符串”完全忽略所有的转义字符，打印出字符串中所有的倒斜杠。
   例如，在交互式环境中输入以下代码：

>>> print(r'That is Carol\'s cat.')
That is Carol\'s cat.

因为这是原始字符串，Python 认为倒斜杠是字符串的一部分，而不是转义字符的开始。如果输入的字符串包含许多倒斜杠，比如下一章中要介绍的正则表达式字符串，那么原始字符串就很有用。

2. 字符串下标和切片
   字符串像列表一样，使用下标和切片。可以将字符串’Hello world!'看成是一个列表，字符串中的每个字符都是一个表项，有对应的下标。

' H e l l o w o r l d ! '
0 1 2 3 4 5 6 7 8 9 10 11

字符计数包含了空格和感叹号，所以’Hello world!'有 12 个字符，H 的下标是 0，!的下标是 11。在交互式环境中输入以下代码：

>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'

如果指定一个下标，你将得到字符串在该处的字符。如果用一个下标和另一个下标指定一个范围，开始下标将被包含，结束下标则不包含。因此，如果 spam 是’Hello world!‘，spam[0:5]就是’Hello’。通过 spam[0:5]得到的子字符串，将包含 spam[0]到spam[4]的全部内容，而不包括下标 5 处的空格。
请注意，字符串切片并没有修改原来的字符串。可以从一个变量中获取切片，记录在另一个变量中。在交互式环境中输入以下代码：

>>> spam = 'Hello world!'
>>> fizz = spam[0:5]
>>> fizz
'Hello'

通过切片并将结果子字符串保存在另一个变量中，就可以同时拥有完整的字符串和子字符串，便于快速简单的访问。

3. 字符串的 in 和 not in 操作符
   像列表一样，in 和 not in 操作符也可以用于字符串。用 in 或 not in 连接两个字符串得到的表达式，将求值为布尔值 True 或 False。在交互式环境中输入以下代码：

>>> 'Hello' in 'Hello World'
True
>>> 'Hello' in 'Hello'
True
>>> 'HELLO' in 'Hello World'
False
>>> '' in 'spam'

4. 字符串方法
   4.1 字符串方法 upper()、lower()、isupper()和 islower()
   4.2 isX 字符串方法
   4.3 字符串方法 startswith()和 endswith()
   4.4 字符串方法 join()和 split()
   4.5 用 rjust()、ljust()和 center()方法对齐文本
   4.6 用 strip()、rstrip()和 lstrip()删除空白字符
   4.7 用 pyperclip 模块拷贝粘贴字符串

第3章 字典

6.1 一个简单的字典
来看一个游戏，其中包含一些外星人，这些外星人的颜色和点数各不相同。下面是一个简单的字典，存储了有关特定外星人的信息：
alien.py

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

字典alien_0 存储了外星人的颜色和点数。使用两条print 语句来访问并打印这些信息，如下所示：
green
5

6.2 使用字典 使
在Python中，字典字 是一系列键—值对值 。每个键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将
任何Python对象用作字典中的值。
在Python中，字典用放在花括号{} 中的一系列键—值对表示，如前面的示例所示：
alien_0 = {‘color’: ‘green’, ‘points’: 5}
键—值 对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以。
最简单的字典只有一个键—值对，如下述修改后的字典alien_0 所示：
alien_0 = {‘color’: ‘green’}
这个字典只存储了一项有关alien_0 的信息，具体地说是这个外星人的颜色。在这个字典中，字符串’color’ 是一个键，与之相关联的值为’green’ 。

6.2.1 访问字典中的值 访
要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示：
alien_0 = {‘color’: ‘green’}
print(alien_0[‘color’])
这将返回字典alien_0 中与键’color’ 相关联的值：
green
字典中可包含任意数量的键—值对。例如，下面是最初的字典alien_0 ，其中包含两个键—值对：
alien_0 = {‘color’: ‘green’, ‘points’: 5}
现在，你可以访问外星人alien_0 的颜色和点数。如果玩家射杀了这个外星人，你就可以使用下面的代码来确定玩家应获得多少个点：
alien_0 = {‘color’: ‘green’, ‘points’: 5}
❶ new_points = alien_0[‘points’] ❷ print(“You just earned " + str(new_points) + " points!”)
上述代码首先定义了一个字典，然后从这个字典中获取与键’points’ 相关联的值（见❶），并将这个值存储在变量new_points 中。接下来，将这个整数转换为字符串，并
打印一条消息，指出玩家获得了多少个点（见❷）：
You just earned 5 points!
如果你在有外星人被射杀时都运行这段代码，就会获取该外星人的点数。
6.2.2 添加键 添 —值对值
字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。
下面在字典alien_0 中添加两项信息：外星人的 x 坐标和 y 坐标，让我们能够在屏幕的特定位置显示该外星人。我们将这个外星人放在屏幕左边缘，且离屏幕上边缘25像素的地
方。由于屏幕坐标系的原点通常为左上角，因此要将该外星人放在屏幕左边缘，可将 x 坐标设置为0；要将该外星人放在离屏幕顶部25像素的地方，可将 y 坐标设置为25，如下所
示：
alien_0 = {‘color’: ‘green’, ‘points’: 5}
print(alien_0)
❶ alien_0[‘x_position’] = 0 ❷ alien_0[‘y_position’] = 25
print(alien_0)
我们首先定义了前面一直在使用的字典，然后打印这个字典，以显示其信息快照。在❶处，我们在这个字典中新增了一个键—值对，其中的键为’x_position’ ，而值为0 。在
❷处，我们重复这样的操作，但使用的键为’y_position’ 。打印修改后的字典时，将看到这两个新增的键—值对：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’, ‘points’: 5, ‘y_position’: 25, ‘x_position’: 0}
这个字典的最终版本包含四个键—值对，其中原来的两个指定外星人的颜色和点数，而新增的两个指定位置。注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对
的添加顺序，而只关心键和值之间的关联关系。
6.2.3 先创建一个空字典 先
有时候，在空字典中添加键—值对是为了方便，而有时候必须这样做。为此，可先使用一对空的花括号定义一个字典，再分行添加各个键—值对。例如，下例演示了如何以这种
方式创建字典alien_0 ：
alien_0 = {}
alien_0[‘color’] = ‘green’
alien_0[‘points’] = 5
print(alien_0)
这里首先定义了空字典alien_0 ，再在其中添加颜色和点数，得到前述示例一直在使用的字典：
{‘color’: ‘green’, ‘points’: 5}
使用字典来存储用户提供的数据或在编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典。
6.2.4 修改字典中的值 修
要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。例如，假设随着游戏的进行，需要将一个外星人从绿色改为黄色：
alien_0 = {‘color’: ‘green’}
print("The alien is " + alien_0[‘color’] + “.”)
alien_0[‘color’] = ‘yellow’
print("The alien is now " + alien_0[‘color’] + “.”)
我们首先定义了一个表示外星人alien_0 的字典，其中只包含这个外星人的颜色。接下来，我们将与键’color’ 相关联的值改为’yellow’ 。输出表明，这个外星人确实从绿
色变成了黄色：
The alien is green.
The alien is now yellow.
来看一个更有趣的例子：对一个能够以不同速度移动的外星人的位置进行跟踪。为此，我们将存储该外星人的当前速度，并据此确定该外星人将向右移动多远：
alien_0 = {‘x_position’: 0, ‘y_position’: 25, ‘speed’: ‘medium’}
print("Original x-position: " + str(alien_0[‘x_position’]))

向右移动外星人

据外星人当前速度决定将其移动多远

❶ if alien_0[‘speed’] == ‘slow’:
x_increment = 1
elif alien_0[‘speed’] == ‘medium’:
x_increment = 2
else:

这个外星人的速度一定很快

x_increment = 3

新位置等于老位置加上增量

❷ alien_0[‘x_position’] = alien_0[‘x_position’] + x_increment
print(“New x-position: " + str(alien_0[‘x_position’]))
我们首先定义了一个外星人，其中包含初始的x 坐标和y 坐标，还有速度’medium’ 。出于简化考虑，我们省略了颜色和点数，但即便包含这些键-值对，这个示例的工作原理也
不会有任何变化。我们还打印了x_position 的初始值，旨在让用户知道这个外星人向右移动了多远。
在❶处，使用了一个if-elif-else 结构来确定外星人应向右移动多远，并将这个值存储在变量x_increment 中。如果外星人的速度为’slow’ ，它将向右移动一个单位；
如果速度为’medium’ ，将向右移动两个单位；如果为’fast’ ，将向右移动三个单位。确定移动量后，将其与x_position 的当前值相加（见❷），再将结果关联到字典中
的键x_position 。
由于这是一个速度中等的外星人，因此其位置将向右移动两个单位：
Original x-position: 0
New x-position: 2
这种技术很棒：通过修改外星人字典中的值，可改变外星人的行为。例如，要将这个速度中等的外星人变成速度很快的外星人，可添加如下代码行：
alien_0[‘speed’] = fast
这样，再次运行这些代码时，其中的if-elif-else 结构将把一个更大的值赋给变量x_increment 。
6.2.5 删除键 删 —值对值
对于字典中不再需要的信息，可使用del 语句将相应的键—值对彻底删除。使用del 语句时，必须指定字典名和要删除的键。
例如，下面的代码从字典alien_0 中删除键’points’ 及其值：
alien_0 = {‘color’: ‘green’, ‘points’: 5}
print(alien_0)
❶ del alien_0[‘points’]
print(alien_0)
❶处的代码行让Python将键’points’ 从字典alien_0 中删除，同时删除与这个键相关联的值。输出表明，键’points’ 及其值5 已从字典中删除，但其他键—值对未受影响：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’}
注意注 删除的键—值对永远消失了。
6.2.6 由类似对象组成的字典 由
在前面的示例中，字典存储的是一个对象（游戏中的一个外星人）的多种信息，但你也可以使用字典来存储众多对象的同一种信息。例如，假设你要调查很多人，询问他们最喜
欢的编程语言，可使用一个字典来存储这种简单调查的结果，如下所示：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
正如你看到的，我们将一个较大的字典放在了多行中。其中每个键都是一个被调查者的名字，而每个值都是被调查者喜欢的语言。确定需要使用多行来定义字典时，在输入左花
括号后按回车键，再在下一行缩进四个空格，指定第一个键—值对，并在它后面加上一个逗号。此后你再次按回车键时，文本编辑器将自动缩进后续键—值对，且缩进量与第一
个键—值对相同。
定义好字典后，在最后一个键—值对的下一行添加一个右花括号，并缩进四个空格，使其与字典中的键对齐。另外一种不错的做法是在最后一个键—值对后面也加上逗号，为以
后在下一行添加键—值对做好准备。
注意注 对于较长的列表和字典，大多数编辑器都有以类似方式设置其格式的功能。对于较长的字典，还有其他一些可行的格式设置方式，因此在你的编辑器或其他源
代码中，你可能会看到稍微不同的格式设置方式。
给定被调查者的名字，可使用这个字典轻松地获悉他喜欢的语言：
favorite_languages.py
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
❶ print(“Sarah’s favorite language is " + ❷ favorite_languages[‘sarah’].title() + ❸ “.”)
为获悉Sarah 喜欢的语言，我们使用如下代码：
favorite_languages[‘sarah’]
在print 语句中，我们使用了这种语法（见❷）；输出指出了Sarah喜欢的语言：
Sarah’s favorite language is C.
这个示例还演示了如何将较长的print 语句分成多行。单词print 比大多数字典名都短，因此让输出的第一部分紧跟在左括号后面是合理的（见❶）。请选择在合适的地方拆
分要打印的内容，并在第一行末尾（见❷）加上一个拼接运算符（+ ）。按回车键进入print 语句的后续各行，并使用Tab键将它们对齐并缩进一级。指定要打印的所有内容
后，在print 语句的最后一行末尾加上右括号（见❸）。
动手试一试 动
6-1 人 ：使用一个字典来存储一个熟人的信息，包括名、姓、年龄和居住的城市。该字典应包含键first_name 、last_name 、age 和city 。将存储在该字典中
的每项信息都打印出来。
6-2 喜欢的数字 喜 ：使用一个字典来存储一些人喜欢的数字。请想出5个人的名字，并将这些名字用作字典中的键；想出每个人喜欢的一个数字，并将这些数字作为值存
储在字典中。打印每个人的名字和喜欢的数字。为让这个程序更有趣，通过询问朋友确保数据是真实的。
6-3 词汇表 词 ：Python字典可用于模拟现实生活中的字典，但为避免混淆，我们将后者称为词汇表。
想出你在前面学过的5个编程词汇，将它们用作词汇表中的键，并将它们的含义作为值存储在词汇表中。
以整洁的方式打印每个词汇及其含义。为此，你可以先打印词汇，在它后面加上一个冒号，再打印词汇的含义；也可在一行打印词汇，再使用换行符（\n ）插
入一个空行，然后在下一行以缩进的方式打印词汇的含义。
6.3 遍历字典 遍
一个Python字典可能只包含几个键—值对，也可能包含数百万个键—值对。鉴于字典可能包含大量的数据，Python支持对字典遍历。字典可用于以各种方式存储信息，因此有多种
遍历字典的方式：可遍历字典的所有键—值对、键或值。
6.3.1 遍历所有的键 遍 —值对值
探索各种遍历方法前，先来看一个新字典，它用于存储有关网站用户的信息。下面的字典存储一名用户的用户名、名和姓：
user_0 = {
‘username’: ‘efermi’,
‘first’: ‘enrico’,
‘last’: ‘fermi’,
}
利用本章前面介绍过的知识，可访问user_0 的任何一项信息，但如果要获悉该用户字典中的所有信息，该怎么办呢？可以使用一个for 循环来遍历这个字典：
user.py
user_0 = {
‘username’: ‘efermi’,
‘first’: ‘enrico’,
‘last’: ‘fermi’,
}
❶ for key, value in user_0.items(): ❷ print(”\nKey: " + key) ❸ print(“Value: " + value)
如❶所示，要编写用于遍历字典的for 循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使用任何名称。下面的代码使用了简单的变量名，这完全可
行：
for k, v in user_0.items()
for 语句的第二部分包含字典名和方法items() （见❶），它返回一个键—值对列表。接下来，for 循环依次将每个键—值对存储到指定的两个变量中。在前面的示例中，我
们使用这两个变量来打印每个键（见❷）及其相关联的值（见❸）。第一条print 语句中的”\n” 确保在输出每个键—值对前都插入一个空行：
Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi
注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。
在6.2.6节的示例favorite_languages.py中，字典存储的是不同人的同一种信息；对于类似这样的字典，遍历所有的键—值对很合适。如果遍历字典favorite_languages ，将得到
其中每个人的姓名和喜欢的编程语言。由于其中的键都是人名，而值都是语言，因此我们在循环中使用变量name 和language ，而不是key 和value ，这让人更容易明白循环
的作用：
favorite_languages.py
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
❶ for name, language in favorite_languages.items(): ❷ print(name.title() + “'s favorite language is " +
language.title() + “.”)
❶处的代码让Python遍历字典中的每个键—值对，并将键存储在变量name 中，而将值存储在变量language 中。这些描述性名称能够让人非常轻松地明白print 语句（见❷）
是做什么的。
仅使用几行代码，我们就将全部调查结果显示出来了：
Jen’s favorite language is Python.
Sarah’s favorite language is C.
Phil’s favorite language is Python.
Edward’s favorite language is Ruby.
即便字典存储的是上千乃至上百万人的调查结果，这种循环也管用。
6.3.2 遍历字典中的所有键 遍
在不需要使用字典中的值时，方法keys() 很有用。下面来遍历字典favorite_languages ，并将每个被调查者的名字都打印出来：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
❶ for name in favorite_languages.keys():
print(name.title())
❶处的代码行让Python提取字典favorite_languages 中的所有键，并依次将它们存储到变量name 中。输出列出了每个被调查者的名字：
Jen
Sarah
Phil
Edward
遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ，输出
将不变。
如果显式地使用方法keys() 可让代码更容易理解，你可以选择这样做，但如果你愿意，也可省略它。
在这种循环中，可使用当前键来访问与之相关联的值。下面来打印两条消息，指出两位朋友喜欢的语言。我们像前面一样遍历字典中的名字，但在名字为指定朋友的名字时，打
印一条消息，指出其喜欢的语言：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
❶ friends = [‘phil’, ‘sarah’]
for name in favorite_languages.keys():
print(name.title())
❷ if name in friends:
print(” Hi " + name.title() +
", I see your favorite language is " + ❸ favorite_languages[name].title() + “!”)
在❶处，我们创建了一个列表，其中包含我们要通过打印消息，指出其喜欢的语言的朋友。在循环中，我们打印每个人的名字，并检查当前的名字是否在列表friends 中（见
❷）。如果在列表中，就打印一句特殊的问候语，其中包含这位朋友喜欢的语言。为访问喜欢的语言，我们使用了字典名，并将变量name 的当前值作为键（见❸）。每个人的
名字都会被打印，但只对朋友打印特殊消息：
Edward
Phil
Hi Phil, I see your favorite language is Python!
Sarah
Hi Sarah, I see your favorite language is C!
Jen
你还可以使用keys() 确定某个人是否接受了调查。下面的代码确定Erin是否接受了调查：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
❶ if ‘erin’ not in favorite_languages.keys():
print(“Erin, please take our poll!”)
方法keys() 并非只能用于遍历；实际上，它返回一个列表，其中包含字典中的所有键，因此❶处的代码行只是核实’erin’ 是否包含在这个列表中。由于她并不包含在这个列
表中，因此打印一条消息，邀请她参加调查：
Erin, please take our poll!
6.3.3 按顺序遍历字典中的所有键 按
字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。这不是问题，因为通常你想要的只是获取与键相关联的正确的值。
要以特定的顺序返回元素，一种办法是在for 循环中对返回的键进行排序。为此，可使用函数sorted() 来获得按特定顺序排列的键列表的副本：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
for name in sorted(favorite_languages.keys()):
print(name.title() + “, thank you for taking the poll.”)
这条for 语句类似于其他for 语句，但对方法dictionary.keys() 的结果调用了函数sorted() 。这让Python列出字典中的所有键，并在遍历前对这个列表进行排序。输出
表明，按顺序显示了所有被调查者的名字：
Edward, thank you for taking the poll.
Jen, thank you for taking the poll.
Phil, thank you for taking the poll.
Sarah, thank you for taking the poll.
6.3.4 遍历字典中的所有值 遍
如果你感兴趣的主要是字典包含的值，可使用方法values() ，它返回一个值列表，而不包含任何键。例如，如果我们想获得一个这样的列表，即其中只包含被调查者选择的各
种语言，而不包含被调查者的名字，可以这样做：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
print(“The following languages have been mentioned:”)
for language in favorite_languages.values():
print(language.title())
这条for 语句提取字典中的每个值，并将它们依次存储到变量language 中。通过打印这些值，就获得了一个列表，其中包含被调查者选择的各种语言：
The following languages have been mentioned:
Python
C
Python
Ruby
这种做法提取字典中所有的值，而没有考虑是否重复。涉及的值很少时，这也许不是问题，但如果被调查者很多，最终的列表可能包含大量的重复项。为剔除重复项，可使用集
合（set）。集合集 类似于列表，但每个元素都必须是独一无二的：
favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
print(“The following languages have been mentioned:”) ❶ for language in set(favorite_languages.values()):
print(language.title())
通过对包含重复元素的列表调用set() ，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。在❶处，我们使用了set() 来提
取favorite_languages.values() 中不同的语言。
结果是一个不重复的列表，其中列出了被调查者提及的所有语言：
The following languages have been mentioned:
Python
C
Ruby
随着你更深入地学习Python，经常会发现它内置的功能可帮助你以希望的方式处理数据。
动手试一试 动
6-4 词汇表 词 2 ：既然你知道了如何遍历字典，现在请整理你为完成练习6-3而编写的代码，将其中的一系列print 语句替换为一个遍历字典中的键和值的循环。确定该
循环正确无误后，再在词汇表中添加5个Python术语。当你再次运行这个程序时，这些新术语及其含义将自动包含在输出中。
6-5 河流河 ：创建一个字典，在其中存储三条大河流及其流经的国家。其中一个键—值对可能是’nile’: ‘egypt’ 。
使用循环为每条河流打印一条消息，如“The Nileruns throughEgypt.”。
使用循环将该字典中每条河流的名字都打印出来。
使用循环将该字典包含的每个国家的名字都打印出来。
6-6 调查调 ：在6.3.1节编写的程序favorite_languages.py中执行以下操作。
创建一个应该会接受调查的人员名单，其中有些人已包含在字典中，而其他人未包含在字典中。
遍历这个人员名单，对于已参与调查的人，打印一条消息表示感谢。对于还未参与调查的人，打印一条消息邀请他参与调查。
6.4 嵌套嵌
有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套嵌 。你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。正如下面的示例
将演示的，嵌套是一项强大的功能。
6.4.1 字典列表 字
字典alien_0 包含一个外星人的各种信息，但无法存储第二个外星人的信息，更别说屏幕上全部外星人的信息了。如何管理成群结队的外星人呢？一种办法是创建一个外星人列
表，其中每个外星人都是一个字典，包含有关该外星人的各种信息。例如，下面的代码创建一个包含三个外星人的列表：
aliens.py
alien_0 = {‘color’: ‘green’, ‘points’: 5}
alien_1 = {‘color’: ‘yellow’, ‘points’: 10}
alien_2 = {‘color’: ‘red’, ‘points’: 15}
❶ aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)
我们首先创建了三个字典，其中每个字典都表示一个外星人。在❶处，我们将这些字典都放到一个名为aliens 的列表中。最后，我们遍历这个列表，并将每个外星人都打印出
来：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘yellow’, ‘points’: 10}
{‘color’: ‘red’, ‘points’: 15}
更符合现实的情形是，外星人不止三个，且每个外星人都是使用代码自动生成的。在下面的示例中，我们使用range() 生成了30个外星人：

创建一个用于存储外星人的空列表

aliens = []

创建30个绿色的外星人

❶ for alien_number in range(30): ❷ new_alien = {‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’} ❸ aliens.append(new_alien)

显示前五个外星人

❹ for alien in aliens[:5]:
print(alien)
print(“…”)

显示创建了多少个外星人

❺ print("Total number of aliens: " + str(len(aliens)))
在这个示例中，首先创建了一个空列表，用于存储接下来将创建的所有外星人。在❶处，range() 返回一系列数字，其唯一的用途是告诉Python我们要重复这个循环多少次。每
次执行这个循环时，都创建一个外星人（见❷），并将其附加到列表aliens 末尾（见❸）。在❹处，使用一个切片来打印前五个外星人；在❺处，打印列表的长度，以证明确
实创建了30个外星人：
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
…
Total number of aliens: 30
这些外星人都具有相同的特征，但在Python看来，每个外星人都是独立的，这让我们能够独立地修改每个外星人。
在什么情况下需要处理成群结队的外星人呢？想象一下，可能随着游戏的进行，有些外星人会变色且移动速度会加快。必要时，我们可以使用for 循环和if 语句来修改某些外星
人的颜色。例如，要将前三个外星人修改为黄色的、速度为中等且值10个点，可以这样做：

创建一个用于存储外星人的空列表

aliens = []

创建30个绿色的外星人

for alien_number in range (0,30):
new_alien = {‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
aliens.append(new_alien)
for alien in aliens[0:3]:
if alien[‘color’] == ‘green’:
alien[‘color’] = ‘yellow’
alien[‘speed’] = ‘medium’
alien[‘points’] = 10

显示前五个外星人

for alien in aliens[0:5]:
print(alien)
print(“…”)
鉴于我们要修改前三个外星人，需要遍历一个只包含这些外星人的切片。当前，所有外星人都是绿色的，但情况并非总是如此，因此我们编写了一条if 语句来确保只修改绿色外
星人。如果外星人是绿色的，我们就将其颜色改为’yellow’ ，将其速度改为’medium’ ，并将其点数改为10 ，如下面的输出所示：
{‘speed’: ‘medium’, ‘color’: ‘yellow’, ‘points’: 10}
{‘speed’: ‘medium’, ‘color’: ‘yellow’, ‘points’: 10}
{‘speed’: ‘medium’, ‘color’: ‘yellow’, ‘points’: 10}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
{‘speed’: ‘slow’, ‘color’: ‘green’, ‘points’: 5}
…
你可以进一步扩展这个循环，在其中添加一个elif 代码块，将黄色外星人改为移动速度快且值15个点的红色外星人，如下所示（这里只列出了循环，而没有列出整个程序）：
for alien in aliens[0:3]:
if alien[‘color’] == ‘green’:
alien[‘color’] = ‘yellow’
alien[‘speed’] = ‘medium’
alien[‘points’] = 10
elif alien[‘color’] == ‘yellow’:
alien[‘color’] = ‘red’
alien[‘speed’] = ‘fast’
alien[‘points’] = 15
经常需要在列表中包含大量的字典，而其中每个字典都包含特定对象的众多信息。例如，你可能需要为网站的每个用户创建一个字典（就像6.3.1节的user.py中那样），并将这些
字典存储在一个名为users 的列表中。在这个列表中，所有字典的结构都相同，因此你可以遍历这个列表，并以相同的方式处理其中的每个字典。
6.4.2 在字典中存储列表 在
有时候，需要将列表存储在字典中，而不是将字典存储在列表中。例如，你如何描述顾客点的比萨呢？如果使用列表，只能存储要添加的比萨配料；但如果使用字典，就不仅可
在其中包含配料列表，还可包含其他有关比萨的描述。
在下面的示例中，存储了比萨的两方面信息：外皮类型和配料列表。其中的配料列表是一个与键’toppings’ 相关联的值。要访问该列表，我们使用字典名和键’toppings’ ，就像访问字典中的其他值一样。这将返回一个配料列表，而不是单个值：
pizza.py

存储所点比萨的信息

❶ pizza = {
‘crust’: ‘thick’,
‘toppings’: [‘mushrooms’, ‘extra cheese’],
}

概述所点的比萨

❷ print(“You ordered a " + pizza[‘crust’] + “-crust pizza " +
“with the following toppings:”)
❸ for topping in pizza[‘toppings’]:
print(”\t” + topping)
我们首先创建了一个字典，其中存储了有关顾客所点比萨的信息（见❶）。在这个字典中，一个键是’crust’ ，与之相关联的值是字符串’thick’ ；下一个键是’toppings’ ，与之相关联的值是一个列表，其中存储了顾客要求添加的所有配料。制作前我们概述了顾客所点的比萨（见❷）。为打印配料，我们编写了一个for 循环（见❸）。为访问配
料列表，我们使用了键’toppings’ ，这样Python将从字典中提取配料列表。
下面的输出概述了要制作的比萨：
You ordered a thick-crust pizza with the following toppings:
mushrooms
extra cheese
每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。在本章前面有关喜欢的编程语言的示例中，如果将每个人的回答都存储在一个列表中，被调查者就
可选择多种喜欢的语言。在这种情况下，当我们遍历字典时，与每个被调查者相关联的都是一个语言列表，而不是一种语言；因此，在遍历该字典的for 循环中，我们需要再使
用一个for 循环来遍历与被调查者相关联的语言列表：
favorite_languages.py
❶ favorite_languages = {
‘jen’: [‘python’, ‘ruby’],
‘sarah’: [‘c’],
‘edward’: [‘ruby’, ‘go’],
‘phil’: [‘python’, ‘haskell’],
}
❷ for name, languages in favorite_languages.items():
print(“\n” + name.title() + “'s favorite languages are:”) ❸ for language in languages:
print(“\t” + language.title())
正如你看到的，现在与每个名字相关联的值都是一个列表（见❶）。请注意，有些人喜欢的语言只有一种，而有些人有多种。遍历字典时（见❷），我们使用了变量languages 来依次存储字典中的每个值，因为我们知道这些值都是列表。在遍历字典的主循环中，我们又使用了一个for 循环来遍历每个人喜欢的语言列表（见❸）。现在，每个人想列出
多少种喜欢的语言都可以：
Jen’s favorite languages are:
Python
Ruby
Sarah’s favorite languages are:
C
Phil’s favorite languages are:
Python
Haskell
Edward’s favorite languages are:
Ruby
Go
为进一步改进这个程序，可在遍历字典的for 循环开头添加一条if 语句，通过查看len(languages) 的值来确定当前的被调查者喜欢的语言是否有多种。如果他喜欢的语言有
多种，就像以前一样显示输出；如果只有一种，就相应修改输出的措辞，如显示Sarah’s favorite language is C 。
注意注 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。
6.4.3 在字典中存储字典 在
可在字典中嵌套字典，但这样做时，代码可能很快复杂起来。例如，如果有多个网站用户，每个都有独特的用户名，可在字典中将用户名作为键，然后将每位用户的信息存储在
一个字典中，并将该字典作为与用户名相关联的值。在下面的程序中，对于每位用户，我们都存储了其三项信息：名、姓和居住地；为访问这些信息，我们遍历所有的用户名，
并访问与每个用户名相关联的信息字典：
many_users.py
users = {
‘aeinstein’: {
‘first’: ‘albert’,
‘last’: ‘einstein’,
‘location’: ‘princeton’,
},
‘mcurie’: {
‘first’: ‘marie’,
‘last’: ‘curie’,
‘location’: ‘paris’,
},
}
❶ for username, user_info in users.items(): ❷ print(“\nUsername: " + username) ❸ full_name = user_info[‘first’] + " " + user_info[‘last’]
location = user_info[‘location’]
❹ print(”\tFull name: " + full_name.title())
print("\tLocation: " + location.title())
我们首先定义了一个名为users 的字典，其中包含两个键：用户名’aeinstein’ 和’mcurie’ ；与每个键相关联的值都是一个字典，其中包含用户的名、姓和居住地。在❶
处，我们遍历字典users ，让Python依次将每个键存储在变量username 中，并依次将与当前键相关联的字典存储在变量user_info 中。在主循环内部的❷处，我们将用户名
打印出来。
在❸处，我们开始访问内部的字典。变量user_info 包含用户信息字典，而该字典包含三个键：‘first’ 、‘last’ 和’location’ ；对于每位用户，我们都使用这些键来
生成整洁的姓名和居住地，然后打印有关用户的简要信息（见❹）：
Username: aeinstein
Full name: Albert Einstein
Location: Princeton
Username: mcurie
Full name: Marie Curie
Location: Paris
请注意，表示每位用户的字典的结构都相同，虽然Python并没有这样的要求，但这使得嵌套的字典处理起来更容易。倘若表示每位用户的字典都包含不同的键，for 循环内部的
代码将更复杂。

字典数据类型

字典与列表

keys()、values()和 items()方法

检查字典中是否存在键或值

get()方法

setdefault()方法

语句

if语句

while语句

第4章 函数

4.1 函数定义

下面是一个打印问候语的简单函数，名为greet_user() ：
greeter.py

def greet_user(): //①
    """显示简单的问候语""" // ②
    print("Hello!") // ③
greet_user()

①使用关键字def 来定义一个函数。这是函数定义 ，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息。在这里，函数名为greet_user() ，它不需要任何信息就能完成其工作，因此括号是空的。最后，定义以冒号结尾。

紧跟在def greet_user(): 后面的所有缩进行构成了函数体。②处的文本是被称为文档字符串 文 （docstring）的注释，描述了函数是做什么的。文档字符串用三引号括起，Python使用它们来生成有关程序中函数的文档。
代码行print(“Hello!”) （见③）是函数体内的唯一一行代码，greet_user() 只做一项工作：打印Hello! 。

要使用这个函数，可调用它。函数调用 函 让Python执行函数的代码。要调用调 函数，可依次指定函数名以及用括号括起的必要信息，如④处所示。由于这个函数不需要任何信息，因此调用它时只需输入greet_user() 即可。和预期的一样，它打印Hello! ：
Hello!

4.1.1 向函数传递信息

只需稍作修改，就可以让函数greet_user() 不仅向用户显示Hello! ，还将用户的名字用作抬头。为此，可在函数定义def greet_user() 的括号内添加username 。通过在这里添加username ，就可让函数接受你给username 指定的任何值。现在，这个函数要求你调用它时给username 指定一个值。调用greet_user() 时，可将一个名字传递给它，如下所示：

def greet_user(username):
    """显示简单的问候语"""
    print("Hello, " + username.title() + "!")
greet_user('jesse')

代码greet_user(‘jesse’) 调用函数greet_user() ，并向它提供执行print 语句所需的信息。这个函数接受你传递给它的名字，并向这个人发出问候：
Hello, Jesse!

4.1.2 实参和形参

前面定义函数greet_user() 时，要求给变量username 指定一个值。调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。
在函数greet_user() 的定义中，变量username 是一个形参形 ——函数完成其工作所需的一项信息。在代码greet_user(‘jesse’) 中，值’jesse’ 是一个实参实 。实参是调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。在greet_user(‘jesse’) 中，将实参’jesse’ 传递给了函数greet_user() ，这个值被存储在形参username 中。

4.2 传递实参

鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可使用位置实参 位 ，这要求实参的顺序与形参的顺序相同；也可使用关键关字实参 字 ，其中每个实参都由变量名和值组成；还可使用列表和字典。下面来依次介绍这些方式。

4.2.1 位置实参 位

你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 位 。
为明白其中的工作原理，来看一个显示宠物信息的函数。这个函数指出一个宠物属于哪种动物以及它叫什么名字，如下所示：
pets.py

def describe_pet(animal_type, pet_name): // ❶ 
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry') // ❷ 

这个函数的定义表明，它需要一种动物类型和一个名字（见❶）。调用describe_pet() 时，需要按顺序提供一种动物类型和一个名字。例如，在前面的函数调用中，实参’hamster’ 存储在形参animal_type 中，而实参’harry’ 存储在形参pet_name 中（见❷）。在函数体内，使用了这两个形参来显示宠物的信息。
输出描述了一只名为Harry的仓鼠：
I have a hamster.
My hamster’s name is Harry

**1. 调用函数多次 **
你可以根据需要调用函数任意次。要再描述一个宠物，只需再次调用describe_pet() 即可：

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')
describe_pet('dog', 'willie')

第二次调用describe_pet() 函数时，我们向它传递了实参’dog’ 和’willie’ 。与第一次调用时一样，Python将实参’dog’ 关联到形参animal_type ，并将实参’willie’ 关联到形参pet_name 。与前面一样，这个函数完成其任务，但打印的是一条名为Willie的小狗的信息。至此，我们有一只名为Harry的仓鼠，还有一条名为Willie的小狗：
I have a hamster.
My hamster’s name is Harry.
I have a dog.
My dog’s name is Willie.

调用函数多次是一种效率极高的工作方式。我们只需在函数中编写描述宠物的代码一次，然后每当需要描述新宠物时，都可调用这个函数，并向它提供新宠物的信息。即便描述宠物的代码增加到了10行，你依然只需使用一行调用函数的代码，就可描述一个新宠物。

在函数中，可根据需要使用任意数量的位置实参，Python将按顺序将函数调用中的实参关联到函数定义中相应的形参。

2. 位置实参的顺序很重要
使用位置实参来调用函数时，如果实参的顺序不正确，结果可能出乎意料：

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('harry', 'hamster')

在这个函数调用中，我们先指定名字，再指定动物类型。由于实参’harry’ 在前，这个值将存储到形参animal_type 中；同理，‘hamster’ 将存储到形参pet_name 中。
结果是我们得到了一个名为Hamster 的harry ：
I have a harry.
My harry’s name is Hamster.

如果结果像上面一样搞笑，请确认函数调用中实参的顺序与函数定义中形参的顺序一致。

8.2.2 关键字实参 关

关键字实参 关 是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。
下面来重新编写pets.py，在其中使用关键字实参来调用describe_pet() ：

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster', pet_name='harry')

函数describe_pet() 还是原来那样，但调用这个函数时，我们向Python明确地指出了各个实参对应的形参。看到这个函数调用时，Python知道应该将实参’hamster’ 和’harry’ 分别存储在形参animal_type 和pet_name 中。输出正确无误，它指出我们有一只名为Harry的仓鼠。
关键字实参的顺序无关紧要，因为Python知道各个值该存储到哪个形参中。下面两个函数调用是等效的：
describe_pet(animal_type=‘hamster’, pet_name=‘harry’)
describe_pet(pet_name=‘harry’, animal_type=‘hamster’)

注意注 使用关键字实参时，务必准确地指定函数定义中的形参名。

8.2.3 默认值

编写函数时，可给每个形参指定默认值 默 。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。
例如，如果你发现调用describe_pet() 时，描述的大都是小狗，就可将形参animal_type 的默认值设置为’dog’ 。这样，调用describe_pet() 来描述小狗时，就可不提供这种信息：

def describe_pet(pet_name, animal_type='dog'):
"""显示宠物的信息"""
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie')

这里修改了函数describe_pet() 的定义，在其中给形参animal_type 指定了默认值’dog’ 。这样，调用这个函数时，如果没有给animal_type 指定值，Python将把这个形参设置为’dog’ ：
I have a dog.
My dog’s name is Willie.

请注意，在这个函数的定义中，修改了形参的排列顺序。由于给animal_type 指定了默认值，无需通过实参来指定动物类型，因此在函数调用中只包含一个实参——宠物的名
字。然而，Python依然将这个实参视为位置实参，因此如果函数调用中只包含宠物的名字，这个实参将关联到函数定义中的第一个形参。这就是需要将pet_name 放在形参列表开头的原因所在。
现在，使用这个函数的最简单的方式是，在函数调用中只提供小狗的名字：
describe_pet(‘willie’)

这个函数调用的输出与前一个示例相同。只提供了一个实参——‘willie’ ，这个实参将关联到函数定义中的第一个形参——pet_name 。由于没有给animal_type 提供实参，因此Python使用其默认值’dog’ 。
如果要描述的动物不是小狗，可使用类似于下面的函数调用：
describe_pet(pet_name=‘harry’, animal_type=‘hamster’)
由于显式地给animal_type 提供了实参，因此Python将忽略这个形参的默认值。
注意注 使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让Python依然能够正确地解读位置实参。

8.2.4 等效的函数调用 等

鉴于可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式。请看下面的函数describe_pets() 的定义，其中给一个形参提供了默认值：
def describe_pet(pet_name, animal_type=‘dog’):
基于这种定义，在任何情况下都必须给pet_name 提供实参；指定该实参时可以使用位置方式，也可以使用关键字方式。如果要描述的动物不是小狗，还必须在函数调用中给animal_type 提供实参；同样，指定该实参时可以使用位置方式，也可以使用关键字方式。
下面对这个函数的所有调用都可行：

# 一条名为Willie的小狗
describe_pet('willie')
describe_pet(pet_name='willie')
# 一只名为Harry的仓鼠
describe_pet('harry', 'hamster')
describe_pet(pet_name='harry', animal_type='hamster')
describe_pet(animal_type='hamster', pet_name='harry')

这些函数调用的输出与前面的示例相同。
注意注 使用哪种调用方式无关紧要，只要函数调用能生成你希望的输出就行。使用对你来说最容易理解的调用方式即可。

8.2.5 避免实参错误 避

等你开始使用函数后，如果遇到实参不匹配错误，不要大惊小怪。你提供的实参多于或少于函数完成其工作所需的信息时，将出现实参不匹配错误。例如，如果调用函
数describe_pet() 时没有指定任何实参，结果将如何呢？
def describe_pet(animal_type, pet_name):
“”“显示宠物的信息”“”
print("\nI have a " + animal_type + “.”)
print("My " + animal_type + "'s name is " + pet_name.title() + “.”)
describe_pet()
Python发现该函数调用缺少必要的信息，而traceback指出了这一点：
Traceback (most recent call last): ❶ File “pets.py”, line 6, in ❷ describe_pet() ❸ TypeError: describe_pet() missing 2 required positional arguments: ‘animal_
type’ and ‘pet_name’
在❶处，traceback指出了问题出在什么地方，让我们能够回过头去找出函数调用中的错误。在❷处，指出了导致问题的函数调用。在❸处，traceback指出该函数调用少两个实参，
并指出了相应形参的名称。如果这个函数存储在一个独立的文件中，我们也许无需打开这个文件并查看函数的代码，就能重新正确地编写函数调用。
Python读取函数的代码，并指出我们需要为哪些形参提供实参，这提供了极大的帮助。这也是应该给变量和函数指定描述性名称的另一个原因；如果你这样做了，那么无论对于
你，还是可能使用你编写的代码的其他任何人来说，Python提供的错误消息都将更有帮助。
如果提供的实参太多，将出现类似的traceback，帮助你确保函数调用和函数定义匹配。

8.3 返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值 返 。在函数中，可使用return 语句将值返回到调用函数的代码行。
返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。

8.3.1 返回简单值 返

下面来看一个函数，它接受名和姓并返回整洁的姓名：
formatted_name.py
❶ def get_formatted_name(first_name, last_name):
“”“返回整洁的姓名”“” ❷ full_name = first_name + ’ ’ + last_name ❸ return full_name.title()
❹ musician = get_formatted_name(‘jimi’, ‘hendrix’)
print(musician)
函数get_formatted_name() 的定义通过形参接受名和姓（见❶）。它将姓和名合而为一，在它们之间加上一个空格，并将结果存储在变量full_name 中（见❷）。然后，
将full_name 的值转换为首字母大写格式，并将结果返回到函数调用行（见❸）。
调用返回值的函数时，需要提供一个变量，用于存储返回的值。在这里，将返回值存储在了变量musician 中（见❹）。输出为整洁的姓名：
Jimi Hendrix
我们原本只需编写下面的代码就可输出整洁的姓名，相比于此，前面做的工作好像太多了：
print(“Jimi Hendrix”)
但在需要分别存储大量名和姓的大型程序中，像get_formatted_name() 这样的函数非常有用。你分别存储名和姓，每当需要显示姓名时都调用这个函数。

8.3.2 让实参变成可选的 让

有时候，需要让实参变成可选的，这样使用函数的人就只需在必要时才提供额外的信息。可使用默认值来让实参变成可选的。
例如，假设我们要扩展函数get_formatted_name() ，使其还处理中间名。为此，可将其修改成类似于下面这样：
def get_formatted_name(first_name, middle_name, last_name):
“”“返回整洁的姓名”“”
full_name = first_name + ’ ’ + middle_name + ’ ’ + last_name
return full_name.title()
musician = get_formatted_name(‘john’, ‘lee’, ‘hooker’)
print(musician)
只要同时提供名、中间名和姓，这个函数就能正确地运行。它根据这三部分创建一个字符串，在适当的地方加上空格，并将结果转换为首字母大写格式：
John Lee Hooker
然而，并非所有的人都有中间名，但如果你调用这个函数时只提供了名和姓，它将不能正确地运行。为让中间名变成可选的，可给实参middle_name 指定一个默认值——空字
符串，并在用户没有提供中间名时不使用这个实参。为让get_formatted_name() 在没有提供中间名时依然可行，可给实参middle_name 指定一个默认值——空字符串，
并将其移到形参列表的末尾：
❶ def get_formatted_name(first_name, last_name, middle_name=‘’):
“”“返回整洁的姓名”“” ❷ if middle_name:
full_name = first_name + ’ ’ + middle_name + ’ ’ + last_name ❸ else:
full_name = first_name + ’ ’ + last_name
return full_name.title()
musician = get_formatted_name(‘jimi’, ‘hendrix’)
print(musician)
❹ musician = get_formatted_name(‘john’, ‘hooker’, ‘lee’)
print(musician)
在这个示例中，姓名是根据三个可能提供的部分创建的。由于人都有名和姓，因此在函数定义中首先列出了这两个形参。中间名是可选的，因此在函数定义中最后列出该形参，
并将其默认值设置为空字符串（见❶）。
在函数体中，我们检查是否提供了中间名。Python将非空字符串解读为True ，因此如果函数调用中提供了中间名，if middle_name 将为True （见❷）。如果提供了中间
名，就将名、中间名和姓合并为姓名，然后将其修改为首字母大写格式，并返回到函数调用行。在函数调用行，将返回的值存储在变量musician 中；然后将这个变量的值打印
出来。如果没有提供中间名，middle_name 将为空字符串，导致if 测试未通过，进而执行else 代码块（见❸）：只使用名和姓来生成姓名，并将设置好格式的姓名返回给函
数调用行。在函数调用行，将返回的值存储在变量musician 中；然后将这个变量的值打印出来。
调用这个函数时，如果只想指定名和姓，调用起来将非常简单。如果还要指定中间名，就必须确保它是最后一个实参，这样Python才能正确地将位置实参关联到形参（见❹）。
这个修改后的版本适用于只有名和姓的人，也适用于还有中间名的人：
Jimi Hendrix
John Lee Hooker
可选值让函数能够处理各种不同情形的同时，确保函数调用尽可能简单。

8.3.3 返回字典 返

函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。例如，下面的函数接受姓名的组成部分，并返回一个表示人的字典：
person.py
def build_person(first_name, last_name):
“”“返回一个字典，其中包含有关一个人的信息”“” ❶ person = {‘first’: first_name, ‘last’: last_name} ❷ return person
musician = build_person(‘jimi’, ‘hendrix’) ❸ print(musician)
函数build_person() 接受名和姓，并将这些值封装到字典中（见❶）。存储first_name 的值时，使用的键为’first’ ，而存储last_name 的值时，使用的键
为’last’ 。最后，返回表示人的整个字典（见❷）。在❸处，打印这个返回的值，此时原来的两项文本信息存储在一个字典中：
{‘first’: ‘jimi’, ‘last’: ‘hendrix’}
这个函数接受简单的文本信息，将其放在一个更合适的数据结构中，让你不仅能打印这些信息，还能以其他方式处理它们。当前，字符串’jimi’ 和’hendrix’ 被标记为名和
姓。你可以轻松地扩展这个函数，使其接受可选值，如中间名、年龄、职业或你要存储的其他任何信息。例如，下面的修改让你还能存储年龄：
def build_person(first_name, last_name, age=‘’):
“”“返回一个字典，其中包含有关一个人的信息”“”
person = {‘first’: first_name, ‘last’: last_name}
if age:
person[‘age’] = age
return person
musician = build_person(‘jimi’, ‘hendrix’, age=27)
print(musician)
在函数定义中，我们新增了一个可选形参age ，并将其默认值设置为空字符串。如果函数调用中包含这个形参的值，这个值将存储到字典中。在任何情况下，这个函数都会存储
人的姓名，但可对其进行修改，使其也存储有关人的其他信息。

8.3.4 结合使用函数和 结 while 循环循

可将函数同本书前面介绍的任何Python结构结合起来使用。例如，下面将结合使用函数get_formatted_name() 和while 循环，以更正规的方式问候用户。下面尝试使用名
和姓跟用户打招呼：
greeter.py

def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + ' ' + last_name
return full_name.title()
# 这是一个无限循环!
while True: ❶ print("\nPlease tell me your name:")
f_name = input("First name: ")
l_name = input("Last name: ")
formatted_name = get_formatted_name(f_name, l_name)
print("\nHello, " + formatted_name + "!")

在这个示例中，我们使用的是get_formatted_name() 的简单版本，不涉及中间名。其中的while 循环让用户输入姓名：依次提示用户输入名和姓（见❶）。
但这个while 循环存在一个问题：没有定义退出条件。请用户提供一系列输入时，该在什么地方提供退出条件呢？我们要让用户能够尽可能容易地退出，因此每次提示用户输入
时，都应提供退出途径。每次提示用户输入时，都使用break 语句提供了退出循环的简单途径：

def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + ' ' + last_name
return full_name.title()
while True:
print("\nPlease tell me your name:")
print("(enter 'q' at any time to quit)")
f_name = input("First name: ")
if f_name == 'q':
break
l_name = input("Last name: ")
if l_name == 'q':
break
formatted_name = get_formatted_name(f_name, l_name)
print("\nHello, " + formatted_name + "!")

我们添加了一条消息来告诉用户如何退出，然后在每次提示用户输入时，都检查他输入的是否是退出值，如果是，就退出循环。现在，这个程序将不断地问候，直到用户输入的
姓或名为’q’ 为止：
Please tell me your name:
(enter ‘q’ at any time to quit)
First name: eric
Last name: matthes
Hello, Eric Matthes!
Please tell me your name:
(enter ‘q’ at any time to quit)
First name: q

8.4 传递列表

你经常会发现，向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。将列表传递给函数后，函数就能直接访问其内容。下面使用函数来提高
处理列表的效率。
假设有一个用户列表，我们要问候其中的每位用户。下面的示例将一个名字列表传递给一个名为greet_users() 的函数，这个函数问候列表中的每个人：
greet_users.py
def greet_users(names):
“”“向列表中的每位用户都发出简单的问候”“”
for name in names:
msg = "Hello, " + name.title() + “!”
print(msg)
❶ usernames = [‘hannah’, ‘ty’, ‘margot’]
greet_users(usernames)
我们将greet_users() 定义成接受一个名字列表，并将其存储在形参names 中。这个函数遍历收到的列表，并对其中的每位用户都打印一条问候语。在❶处，我们定义了一
个用户列表——usernames ，然后调用greet_users() ，并将这个列表传递给它：
Hello, Hannah!
Hello, Ty!
Hello, Margot!
输出完全符合预期，每位用户都看到了一条个性化的问候语。每当你要问候一组用户时，都可调用这个函数。

8.4.1 在函数中修改列表 在

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
来看一家为用户提交的设计制作3D打印模型的公司。需要打印的设计存储在一个列表中，打印后移到另一个列表中。下面是在不使用函数的情况下模拟这个过程的代码：
printing_models.py

首先创建一个列表，其中包含一些要打印的设计

unprinted_designs = [‘iphone case’, ‘robot pendant’, ‘dodecahedron’]
completed_models = []

模拟打印每个设计，直到没有未打印的设计为止

打印每个设计后，都将其移到列表completed_models中

while unprinted_designs:
current_design = unprinted_designs.pop()
#模拟根据设计制作3D打印模型的过程
print("Printing model: " + current_design)
completed_models.append(current_design)

显示打印好的所有模型

print(“\nThe following models have been printed:”)
for completed_model in completed_models:
print(completed_model)
这个程序首先创建一个需要打印的设计列表，还创建一个名为completed_models 的空列表，每个设计打印都将移到这个列表中。只要列表unprinted_designs 中还有设
计，while 循环就模拟打印设计的过程：从该列表末尾删除一个设计，将其存储到变量current_design 中，并显示一条消息，指出正在打印当前的设计，再将该设计加入到
列表completed_models 中。循环结束后，显示已打印的所有设计：
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case
The following models have been printed:
dodecahedron
robot pendant
iphone case
为重新组织这些代码，我们可编写两个函数，每个都做一件具体的工作。大部分代码都与原来相同，只是效率更高。第一个函数将负责处理打印设计的工作，而第二个将概述打
印了哪些设计：
❶ def print_models(unprinted_designs, completed_models):
“”" 模拟打印每个设计，直到没有未打印的设计为止
打印每个设计后，都将其移到列表completed_models中
“”"
while unprinted_designs:
current_design = unprinted_designs.pop()

模拟根据设计制作3D打印模型的过程

print(“Printing model: " + current_design)
completed_models.append(current_design)
❷ def show_completed_models(completed_models):
“”“显示打印好的所有模型””"
print(“\nThe following models have been printed:”)
for completed_model in completed_models:
print(completed_model)
unprinted_designs = [‘iphone case’, ‘robot pendant’, ‘dodecahedron’]
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
在❶处，我们定义了函数print_models() ，它包含两个形参：一个需要打印的设计列表和一个打印好的模型列表。给定这两个列表，这个函数模拟打印每个设计的过程：将
设计逐个地从未打印的设计列表中取出，并加入到打印好的模型列表中。在❷处，我们定义了函数show_completed_models() ，它包含一个形参：打印好的模型列表。给定
这个列表，函数show_completed_models() 显示打印出来的每个模型的名称。
这个程序的输出与未使用函数的版本相同，但组织更为有序。完成大部分工作的代码都移到了两个函数中，让主程序更容易理解。只要看看主程序，你就知道这个程序的功能容
易看清得多：
unprinted_designs = [‘iphone case’, ‘robot pendant’, ‘dodecahedron’]
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
我们创建了一个未打印的设计列表，还创建了一个空列表，用于存储打印好的模型。接下来，由于我们已经定义了两个函数，因此只需调用它们并传入正确的实参即可。我们调
用print_models() 并向它传递两个列表；像预期的一样，print_models() 模拟打印设计的过程。接下来，我们调用show_completed_models() ，并将打印好的模型
列表传递给它，让其能够指出打印了哪些模型。描述性的函数名让别人阅读这些代码时也能明白，虽然其中没有任何注释。
相比于没有使用函数的版本，这个程序更容易扩展和维护。如果以后需要打印其他设计，只需再次调用print_models() 即可。如果我们发现需要对打印代码进行修改，只需
修改这些代码一次，就能影响所有调用该函数的地方；与必须分别修改程序的多个地方相比，这种修改的效率更高。
这个程序还演示了这样一种理念，即每个函数都应只负责一项具体的工作。第一个函数打印每个设计，而第二个显示打印好的模型；这优于使用一个函数来完成两项工作。编写
函数时，如果你发现它执行的任务太多，请尝试将这些代码划分到两个函数中。别忘了，总是可以在一个函数中调用另一个函数，这有助于将复杂的任务划分成一系列的步骤。

8.4.2 禁止函数修改列表 禁

有时候，需要禁止函数修改列表。例如，假设像前一个示例那样，你有一个未打印的设计列表，并编写了一个将这些设计移到打印好的模型列表中的函数。你可能会做出这样的
决定：即便打印所有设计后，也要保留原来的未打印的设计列表，以供备案。但由于你将所有的设计都移出了unprinted_designs ，这个列表变成了空的，原来的列表没有
了。为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。
要将列表的副本传递给函数，可以像下面这样做：
function_name(list_name[:])
切片表示法[:] 创建列表的副本。在print_models.py中，如果不想清空未打印的设计列表，可像下面这样调用print_models() ：
print_models(unprinted_designs[:], completed_models)
这样函数print_models() 依然能够完成其工作，因为它获得了所有未打印的设计的名称，但它使用的是列表unprinted_designs 的副本，而不是列
表unprinted_designs 本身。像以前一样，列表completed_models 也将包含打印好的模型的名称，但函数所做的修改不会影响到列表unprinted_designs 。
虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创
建副本，从而提高效率，在处理大型列表时尤其如此。

8.5 传递任意数量的实参

有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。
例如，来看一个制作比萨的函数，它需要接受很多配料，但你无法预先确定顾客要多少种配料。下面的函数只有一个形参*toppings ，但不管调用语句提供了多少实参，这个
形参都将它们统统收入囊中：
pizza.py
def make_pizza(toppings):
“”“打印顾客点的所有配料”“”
print(toppings)
make_pizza(‘pepperoni’)
make_pizza(‘mushrooms’, ‘green peppers’, ‘extra cheese’)
形参名toppings 中的星号让Python创建一个名为toppings 的空元组，并将收到的所有值都封装到这个元组中。函数体内的print 语句通过生成输出来证明Python能够处理
使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此：
(‘pepperoni’,)
(‘mushrooms’, ‘green peppers’, ‘extra cheese’)
现在，我们可以将这条print 语句替换为一个循环，对配料列表进行遍历，并对顾客点的比萨进行描述：
def make_pizza(*toppings):
“”“概述要制作的比萨”“”
print(“\nMaking a pizza with the following toppings:”)
for topping in toppings:
print("- " + topping)
make_pizza(‘pepperoni’)
make_pizza(‘mushrooms’, ‘green peppers’, ‘extra cheese’)
不管收到的是一个值还是三个值，这个函数都能妥善地处理：
Making a pizza with the following toppings:

• pepperoni
  Making a pizza with the following toppings:
• mushrooms
• green peppers
• extra cheese
  不管函数收到的实参是多少个，这种语法都管用。

8.5.1 结合使用位置实参和任意数量实参 结

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
例如，如果前面的函数还需要一个表示比萨尺寸的实参，必须将该形参放在形参*toppings 的前面：
def make_pizza(size, *toppings):
“”“概述要制作的比萨”“”
print(“\nMaking a " + str(size) +
“-inch pizza with the following toppings:”)
for topping in toppings:
print(”- " + topping)
make_pizza(16, ‘pepperoni’)
make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
基于上述函数定义，Python将收到的第一个值存储在形参size 中，并将其他的所有值都存储在元组toppings 中。在函数调用中，首先指定表示比萨尺寸的实参，然后根据需要
指定任意数量的配料。
现在，每个比萨都有了尺寸和一系列配料，这些信息按正确的顺序打印出来了——首先是尺寸，然后是配料：
Making a 16-inch pizza with the following toppings:

• pepperoni
  Making a 12-inch pizza with the following toppings:
• mushrooms
• green peppers
• extra cheese

8.5.2 使用任意数量的关键字实参 使

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接
受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中，函数build_profile() 接受名和姓，同时还接受
任意数量的关键字实参：
user_profile.py
def build_profile(first, last, user_info):
“”“创建一个字典，其中包含我们知道的有关用户的一切”“”
profile = {}
❶ profile[‘first_name’] = first
profile[‘last_name’] = last ❷ for key, value in user_info.items():
profile[key] = value
return profile
user_profile = build_profile(‘albert’, ‘einstein’,
location=‘princeton’,
field=‘physics’)
print(user_profile)
函数build_profile() 的定义要求提供名和姓，同时允许用户根据需要提供任意数量的名称—值对。形参user_info 中的两个星号让Python创建一个名为user_info 的
空字典，并将收到的所有名称—值对都封装到这个字典中。在这个函数中，可以像访问其他字典那样访问user_info 中的名称—值对。
在build_profile() 的函数体内，我们创建了一个名为profile 的空字典，用于存储用户简介。在❶处，我们将名和姓加入到这个字典中，因为我们总是会从用户那里收到
这两项信息。在❷处，我们遍历字典user_info 中的键—值对，并将每个键—值对都加入到字典profile 中。最后，我们将字典profile 返回给函数调用行。
我们调用build_profile() ，向它传递名（‘albert’ ）、姓（‘einstein’ ）和两个键—值对（location=‘princeton’ 和field=‘physics’ ），并将返回
的profile 存储在变量user_profile 中，再打印这个变量：
{‘first_name’: ‘albert’, ‘last_name’: ‘einstein’,
‘location’: ‘princeton’, ‘field’: ‘physics’}
在这里，返回的字典包含用户的名和姓，还有求学的地方和所学专业。调用这个函数时，不管额外提供了多少个键—值对，它都能正确地处理。
编写函数时，你可以以各种方式混合使用位置实参、关键字实参和任意数量的实参。知道这些实参类型大有裨益，因为阅读别人编写的代码时经常会见到它们。要正确地使用这
些类型的实参并知道它们的使用时机，需要经过一定的练习。就目前而言，牢记使用最简单的方法来完成任务就好了。你继续往下阅读，就会知道在各种情况下哪种方法的效率
是最高的。

8.6 将函数存储在模块中 将

函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块模 的独立文件中，
再将模块导入导 到主程序中。import 语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程
序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。
导入模块的方法有多种，下面对每种都作简要的介绍。
8.6.1 导入整个模块 导
要让函数是可导入的，得先创建模块。模块模 是扩展名为.py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza() 的模块。为此，我们将文件pizza.py中
除函数make_pizza() 之外的其他代码都删除：
pizza.py
def make_pizza(size, *toppings):
“”“概述要制作的比萨”“”
print(“\nMaking a " + str(size) +
“-inch pizza with the following toppings:”)
for topping in toppings:
print(”- " + topping)
接下来，我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza() 两次：
making_pizzas.py
import pizza
❶ pizza.make_pizza(16, ‘pepperoni’)
pizza.make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
Python读取这个文件时，代码行import pizza 让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕
后复制这些代码。你只需知道，在making_pizzas.py中，可以使用pizza.py中定义的所有函数。
要调用被导入的模块中的函数，可指定导入的模块的名称pizza 和函数名make_pizza() ，并用句点分隔它们（见❶）。这些代码的输出与没有导入模块的原始程序相同：
Making a 16-inch pizza with the following toppings:

• pepperoni
  Making a 12-inch pizza with the following toppings:
• mushrooms
• green peppers
• extra cheese
  这就是一种导入方法：只需编写一条import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。如果你使用这种import 语句导入了名为module_name.py 的整个模块，就可使用下面的语法来使用其中任何一个函数：
  module_name.function_name()

8.6.2 导入特定的函数 导

你还可以导入模块中的特定函数，这种导入方法的语法如下：
from module_name import function_name
通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：
from module_name import function_0, function_1, function_2
对于前面的making_pizzas.py示例，如果只想导入要使用的函数，代码将类似于下面这样：
from pizza import make_pizza
make_pizza(16, ‘pepperoni’)
make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
若使用这种语法，调用函数时就无需使用句点。由于我们在import 语句中显式地导入了函数make_pizza() ，因此调用它时只需指定其名称。

8.6.3 使用使 as 给函数指定别名 给

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名别 ——函数的另一个名称，类似于外号。要给函数指定这种特殊外
号，需要在导入它时这样做。
下面给函数make_pizza() 指定了别名mp() 。这是在import 语句中使用make_pizza as mp 实现的，关键字as 将函数重命名为你提供的别名：
from pizza import make_pizza as mp
mp(16, ‘pepperoni’)
mp(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
上面的import 语句将函数make_pizza() 重命名为mp() ；在这个程序中，每当需要调用make_pizza() 时，都可简写成mp() ，而Python将运行make_pizza() 中的代
码，这可避免与这个程序可能包含的函数make_pizza() 混淆。
指定别名的通用语法如下：
from module_name import function_name as fn

8.6.4 使用使 as 给模块指定别名 给

你还可以给模块指定别名。通过给模块指定简短的别名（如给模块pizza 指定别名p ），让你能够更轻松地调用模块中的函数。相比于pizza.make_pizza() ，p.make_pizza() 更为简洁：
import pizza as p
p.make_pizza(16, ‘pepperoni’)
p.make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
上述import 语句给模块pizza 指定了别名p ，但该模块中所有函数的名称都没变。调用函数make_pizza() 时，可编写代码p.make_pizza() 而不
是pizza.make_pizza() ，这样不仅能使代码更简洁，还可以让你不再关注模块名，而专注于描述性的函数名。这些函数名明确地指出了函数的功能，对理解代码而言，它们
比模块名更重要。
给模块指定别名的通用语法如下：
import module_name as mn

8.6.5 导入模块中的所有函数 导

使用星号（* ）运算符可让Python导入模块中的所有函数：
from pizza import *
make_pizza(16, ‘pepperoni’)
make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
import 语句中的星号让Python将模块pizza 中的每个函数都复制到这个程序文件中。由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。然而，使用
并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果：Python可能遇到多个名称相同的函
数或变量，进而覆盖函数，而不是分别导入所有的函数。
最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使用句点表示法。这能让代码更清晰，更容易阅读和理解。这里之所以介绍这种导入方法，只是想让你在阅
读别人编写的代码时，如果遇到类似于下面的import 语句，能够理解它们：
from module_name import *

8.7 函数编写指南 函

编写函数时，需要牢记几个细节。应给函数指定描述性名称，且只在其中使用小写字母和下划线。描述性名称可帮助你和别人明白代码想要做什么。给模块命名时也应遵循上述
约定。
每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式。文档良好的函数让其他程序员只需阅读文档字符串中的描述就能够使用
它：他们完全可以相信代码如描述的那样运行；只要知道函数的名称、需要的实参以及返回值的类型，就能在自己的程序中使用它。
给形参指定默认值时，等号两边不要有空格：
def function_name(parameter_0, parameter_1=‘default value’)
对于函数调用中的关键字实参，也应遵循这种约定：
function_name(value_0, parameter_1=‘value’)
PEP 8（https://www.python.org/dev/peps/pep-0008/ ）建议代码行的长度不要超过79字符，这样只要编辑器窗口适中，就能看到整行代码。如果形参很多，导致函数定义的长度超过了
79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。
大多数编辑器都会自动对齐后续参数列表行，使其缩进程度与你给第一个参数列表行指定的缩进程度相同：
def function_name(
parameter_0, parameter_1, parameter_2,
parameter_3, parameter_4, parameter_5):
function body…
如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开，这样将更容易知道前一个函数在什么地方结束，下一个函数从什么地方开始。
所有的import 语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。

第5章 类

9.1 创建和使用类 创

使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类Dog ——它表示的不是特定的小狗，而是任何小狗。对于大多数宠物狗，我们都知道些什么呢？它们都有名字和年龄；我们还知道，大多数小狗还会蹲下和打滚。由于大多数小狗都具备上述两项信息（名字和年龄）和两种行为（蹲下和打滚），我们的Dog 类将包含它们。这个类让Python知道如何创建表示小狗的对象。编写这个类后，我们将使用它来创建表示特定小狗的实例。

创建创 Dog 类

根据Dog 类创建的每个实例都将存储名字和年龄。我们赋予了每条小狗蹲下（sit() ）和打滚（roll_over() ）的能力：

class Dog():
    """一次模拟小狗的简单尝试"""
    def __init__(self, name, age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")
        def roll_over(self):
            """模拟小狗被命令时打滚"""
            print(self.name.title() + " rolled over!")

1. 方法方 init()
   init() 是一个特殊的方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

我们将方法__init__() 定义成了包含三个形参：self 、name 和age 。在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self 呢？

因为Python调用这个__init__() 方法来创建Dog 实例时，将自动传入实参self 。每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。我们创建Dog 实例时，Python将调用Dog 类的方法__init__() 。我们将通过实参向Dog() 传递名字和年龄；self 会自动传递，因此我们不需要传递它。每当我们根据Dog 类创建实例时，都只需给最后两个形参（name 和age ）提供值。

处义的两个变量都有前缀self 。以self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。self.name = name 获取存储在形参name 中的值，并将其存储到变量name 中，然后该变量被关联到当前创建的实例。self.age = age 的作用与此类似。像这样可通过实例访问的变量称为属性属 。

Dog 类还定义了另外两个方法：sit() 和roll_over() 。由于这些方法不需要额外的信息，如名字或年龄，因此它们只有一个形参self 。我们后面将创建的实例能够访问这些方法，换句话说，它们都会蹲下和打滚。当前，sit() 和roll_over() 所做的有限，它们只是打印一条消息，指出小狗正蹲下或打滚。但可以扩展这些方法以模拟实际情况：如果这个类包含在一个计算机游戏中，这些方法将包含创建小狗蹲下和打滚动画效果的代码。如果这个类是用于控制机器狗的，这些方法将引导机器狗做出蹲下和打滚的动作。

根据类创建实例

可将类视为有关如何创建实例的说明。Dog 类是一系列说明，让Python知道如何创建表示特定小狗的实例。
下面来创建一个表示特定小狗的实例：

my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

我们让Python创建一条名字为’willie’ 、年龄为6 的小狗。遇到这行代码时，Python使用实参’willie’ 和6 调用Dog 类中的方法__init__() 。方法__init__() 创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name 和age 。方法__init__() 并未显式地包含return 语句，
但Python自动返回一个表示这条小狗的实例。我们将这个实例存储在变量my_dog 中。在这里，命名约定很有用：我们通常可以认为首字母大写的名称（如Dog ）指的是类，而小写的名称（如my_dog ）指的是根据类创建的实例。

1. 访问属性 访
   要访问实例的属性，可使用句点表示法。在❷处，我们编写了如下代码来访问my_dog 的属性name 的值：
   my_dog.name
   句点表示法在Python中很常用，这种语法演示了Python如何获悉属性的值。在这里，Python先找到实例my_dog ，再查找与这个实例相关联的属性name 。在Dog 类中引用这个属
   性时，使用的是self.name 。在❸处，我们使用同样的方法来获取属性age 的值。在前面的第1条print 语句中，my_dog.name.title() 将my_dog 的属性name 的
   值’willie’ 改为首字母大写的；在第2条print 语句中，str(my_dog.age) 将my_dog 的属性age 的值6 转换为字符串。
   输出是有关my_dog 的摘要：
   My dog’s name is Willie.
   My dog is 6 years old.

2. 调用方法
   根据Dog 类创建实例后，就可以使用句点表示法来调用Dog 类中定义的任何方法。下面来让小狗蹲下和打滚：
   class Dog():
   –snip–
   my_dog = Dog(‘willie’, 6)
   my_dog.sit()
   my_dog.roll_over()
   要调用方法，可指定实例的名称（这里是my_dog ）和要调用的方法，并用句点分隔它们。遇到代码my_dog.sit() 时，Python在类Dog 中查找方法sit() 并运行其代码。
   Python以同样的方式解读代码my_dog.roll_over() 。

3. 创建多个实例 创
   可按需求根据类创建任意数量的实例。下面再创建一个名为your_dog 的实例：
   class Dog():
   –snip–
   my_dog = Dog(‘willie’, 6)
   your_dog = Dog(‘lucy’, 3)
   print(“My dog’s name is " + my_dog.name.title() + “.”)
   print(“My dog is " + str(my_dog.age) + " years old.”)
   my_dog.sit()
   print(”\nYour dog’s name is " + your_dog.name.title() + “.”)
   print(“Your dog is " + str(your_dog.age) + " years old.”)
   your_dog.sit()
   在这个实例中，我们创建了两条小狗，它们分别名为Willie和Lucy。每条小狗都是一个独立的实例，有自己的一组属性，能够执行相同的操作：
   My dog’s name is Willie.
   My dog is 6 years old.
   Willie is now sitting.
   Your dog’s name is Lucy.
   Your dog is 3 years old.
   Lucy is now sitting.
   就算我们给第二条小狗指定同样的名字和年龄，Python依然会根据Dog 类创建另一个实例。你可按需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量
   中，或占用列表或字典的不同位置。

使用类和实例 使

你可以使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性。你可以直接修改
实例的属性，也可以编写方法以特定的方式进行修改。

Car 类

下面来编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法：
camera.py

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())

在❶处，我们定义了方法__init__() 。与前面的Dog 类中一样，这个方法的第一个形参为self ；我们还在这个方法中包含了另外三个形参：make 、model 和year 。方
法__init__() 接受这些形参的值，并将它们存储在根据这个类创建的实例的属性中。创建新的Car 实例时，我们需要指定其制造商、型号和生产年份。
在❷处，我们定义了一个名为get_descriptive_name() 的方法，它使用属性year 、make 和model 创建一个对汽车进行描述的字符串，让我们无需分别打印每个属性的
值。为在这个方法中访问属性的值，我们使用了self.make 、self.model 和self.year 。在❸处，我们根据Car 类创建了一个实例，并将其存储到变量my_new_car 中。接下来，我们调用方法get_descriptive_name() ，指出我们拥有的是一辆什么样的汽车：

给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法__init__() 内指定这种初始值是可行的；如果你对某个属性这样做
了，就无需包含为它提供初始值的形参。

下面来添加一个名为odometer_reading 的属性，其初始值总是为0。我们还添加了一个名为read_odometer() 的方法，用于读取汽车的里程表：

9.3 继承继
编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用继承继 。一个类继承继 另一个类时，它将自动获得另一个类的所有属性和方法；原有的
类称为父类父 ，而新类称为子类子 。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
9.3.1 子类的方法 子 init()
创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__() 需要父类施以援手。
例如，下面来模拟电动汽车。电动汽车是一种特殊的汽车，因此我们可以在前面创建的Car 类的基础上创建新类ElectricCar ，这样我们就只需为电动汽车特有的属性和行为
编写代码。
下面来创建一个简单的ElectricCar 类版本，它具备Car 类的所有功能：
electric_car.py

class Car(): # ❶ 
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
    def increment_odometer(self, miles):
        self.odometer_reading += miles
class ElectricCar(Car): # ❷ 
    """电动汽车的独特之处"""
    def __init__(self, make, model, year): # ❸ 
        """初始化父类的属性""" 
        super().__init__(make, model, year) # ❹ 
my_tesla = ElectricCar('tesla', 'model s', 2016) # ❺ 
print(my_tesla.get_descriptive_name())

首先是Car 类的代码（见❶）。创建子类时，父类必须包含在当前文件中，且位于子类前面。在❷处，我们定义了子类ElectricCar 。定义子类时，必须在括号内指定父类的
名称。方法__init__() 接受创建Car 实例所需的信息（见❸）。
❹处的super() 是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所
有属性。父类也称为超类超 （superclass），名称super因此而得名。
为测试继承是否能够正确地发挥作用，我们尝试创建一辆电动汽车，但提供的信息与创建普通汽车时相同。在❺处，我们创建ElectricCar 类的一个实例，并将其存储在变
量my_tesla 中。这行代码调用ElectricCar 类中定义的方法__init__() ，后者让Python调用父类Car 中定义的方法__init__() 。我们提供了实参’tesla’ 、‘model
s’ 和2016 。
除方法__init__() 外，电动汽车没有其他特有的属性和方法。当前，我们只想确认电动汽车具备普通汽车的行为：
2016 Tesla Model S
ElectricCar 实例的行为与Car 实例一样，现在可以开始定义电动汽车特有的属性和方法了。

9.3.3 给子类定义属性和方法 给
让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。
下面来添加一个电动汽车特有的属性（电瓶），以及一个描述该属性的方法。我们将存储电瓶容量，并编写一个打印电瓶描述的方法：
class Car():
–snip–
class ElectricCar(Car):
“”“Represent aspects of a car, specific to electric vehicles.”“”
def init(self, make, model, year):
“”" 电动汽车的独特之处
初始化父类的属性，再初始化电动汽车特有的属性
“”"
super().init(make, model, year) ❶ self.battery_size = 70
❷ def describe_battery(self):
“”“打印一条描述电瓶容量的消息”“”
print(“This car has a " + str(self.battery_size) + “-kWh battery.”)
my_tesla = ElectricCar(‘tesla’, ‘model s’, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
在❶处，我们添加了新属性self.battery_size ，并设置其初始值（如70 ）。根据ElectricCar 类创建的所有实例都将包含这个属性，但所有Car 实例都不包含它。在❷
处，我们还添加了一个名为describe_battery() 的方法，它打印有关电瓶的信息。我们调用这个方法时，将看到一条电动汽车特有的描述：
2016 Tesla Model S
This car has a 70-kWh battery.
对于ElectricCar 类的特殊化程度没有任何限制。模拟电动汽车时，你可以根据所需的准确程度添加任意数量的属性和方法。如果一个属性或方法是任何汽车都有的，而不是
电动汽车特有的，就应将其加入到Car 类而不是ElectricCar 类中。这样，使用Car 类的人将获得相应的功能，而ElectricCar 类只包含处理电动汽车特有属性和行为的代
码。
9.3.4 重写父类的方法 重
对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这
个父类方法，而只关注你在子类中定义的相应方法。
假设Car 类有一个名为fill_gas_tank() 的方法，它对全电动汽车来说毫无意义，因此你可能想重写它。下面演示了一种重写方式：
def ElectricCar(Car):
–snip–
def fill_gas_tank():
“”“电动汽车没有油箱””"
print(“This car doesn’t need a gas tank!”)
现在，如果有人对电动汽车调用方法fill_gas_tank() ，Python将忽略Car 类中的方法fill_gas_tank() ，转而运行上述代码。使用继承时，可让子类保留从父类那里继
承而来的精华，并剔除不需要的糟粕。
9.3.5 将实例用作属性 将
使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。
你可以将大型类拆分成多个协同工作的小类。
例如，不断给ElectricCar 类添加细节时，我们可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，我们可将这些属性和方法提取出来，放到另一个名
为Battery 的类中，并将一个Battery 实例用作ElectricCar 类的一个属性：
class Car():
–snip–
❶ class Battery():
“”“一次模拟电动汽车电瓶的简单尝试”“”
❷ def init(self, battery_size=70):
“”“初始化电瓶的属性”“”
self.battery_size = battery_size
❸ def describe_battery(self):
“”“打印一条描述电瓶容量的消息”“”
print(“This car has a " + str(self.battery_size) + “-kWh battery.”)
class ElectricCar(Car):
“”“电动汽车的独特之处””"
def init(self, make, model, year):
“”" 初始化父类的属性，再初始化电动汽车特有的属性
“”"
super().init(make, model, year) ❹ self.battery = Battery()
my_tesla = ElectricCar(‘tesla’, ‘model s’, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
在❶处，我们定义了一个名为Battery 的新类，它没有继承任何类。❷处的方法__init__() 除self 外，还有另一个形参battery_size 。这个形参是可选的：如果没有给
它提供值，电瓶容量将被设置为70。方法describe_battery() 也移到了这个类中（见❸）。
在ElectricCar 类中，我们添加了一个名为self.battery 的属性（见❹）。这行代码让Python创建一个新的Battery 实例（由于没有指定尺寸，因此为默认值70 ），并将
该实例存储在属性self.battery 中。每当方法__init__() 被调用时，都将执行该操作；因此现在每个ElectricCar 实例都包含一个自动创建的Battery 实例。
我们创建一辆电动汽车，并将其存储在变量my_tesla 中。要描述电瓶时，需要使用电动汽车的属性battery ：
my_tesla.battery.describe_battery()
这行代码让Python在实例my_tesla 中查找属性battery ，并对存储在该属性中的Battery 实例调用方法describe_battery() 。
输出与我们前面看到的相同：
2016 Tesla Model S
This car has a 70-kWh battery.
这看似做了很多额外的工作，但现在我们想多详细地描述电瓶都可以，且不会导致ElectricCar 类混乱不堪。下面再给Battery 类添加一个方法，它根据电瓶容量报告汽车
的续航里程：
class Car():
–snip–
class Battery():
–snip–
❶ def get_range(self):
“”“打印一条消息，指出电瓶的续航里程”“”
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = “This car can go approximately " + str(range)
message += " miles on a full charge.”
print(message)
class ElectricCar(Car):
–snip–
my_tesla = ElectricCar(‘tesla’, ‘model s’, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery() ❷ my_tesla.battery.get_range()
❶处新增的方法get_range() 做了一些简单的分析：如果电瓶的容量为70kWh，它就将续航里程设置为240英里；如果容量为85kWh，就将续航里程设置为270英里，然后报告
这个值。为使用这个方法，我们也通过汽车的属性battery 来调用它（见❷）。
输出指出了汽车的续航里程（这取决于电瓶的容量）：
2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full charge.
9.3.6 模拟实物 模
模拟较复杂的物件（如电动汽车）时，需要解决一些有趣的问题。续航里程是电瓶的属性还是汽车的属性呢？如果我们只需描述一辆汽车，那么将方法get_range() 放
在Battery 类中也许是合适的；但如果要描述一家汽车制造商的整个产品线，也许应该将方法get_range() 移到ElectricCar 类中。在这种情况下，get_range() 依然
根据电瓶容量来确定续航里程，但报告的是一款汽车的续航里程。我们也可以这样做：将方法get_range() 还留在Battery 类中，但向它传递一个参数，如car_model ；在
这种情况下，方法get_range() 将根据电瓶容量和汽车型号报告续航里程。
这让你进入了程序员的另一个境界：解决上述问题时，你从较高的逻辑层面（而不是语法层面）考虑；你考虑的不是Python，而是如何使用代码来表示实物。到达这种境界后，你
经常会发现，现实世界的建模方法并没有对错之分。有些方法的效率更高，但要找出效率最高的表示法，需要经过一定的实践。只要代码像你希望的那样运行，就说明你做得很
好！即便你发现自己不得不多次尝试使用不同的方法来重写类，也不必气馁；要编写出高效、准确的代码，都得经过这样的过程。

导入类

随着你不断地给类添加功能，文件可能变得很长，即便你妥善地使用了继承亦如此。为遵循Python的总体理念，应让文件尽可能整洁。为在这方面提供帮助，Python允许你将类存储在模块中，然后在主程序中导入所需的模块。

类编码风格

类名应采用驼峰命名法 驼 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。在包含多条import 语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。

第6章 异常

第7章 文件

文件与文件路径

在 Windows 上，路径书写使用倒斜杠作为文件夹之间的分隔符。但在 OS X 和Linux 上，使用正斜杠作为它们的路径分隔符。如果想要程序运行在所有操作系统上，在编写 Python 脚本时，就必须处理这两种情况。

好在，用 os.path.join()函数来做这件事很简单。如果将单个文件和路径上的文件夹名称的字符串传递给它，os.path.join()就会返回一个文件路径的字符串，包含正确的路径分隔符。在交互式环境中输入以下代码：

>>> import os
>>> os.path.join('usr', 'bin', 'spam')
'usr\\bin\\spam'

如果需要创建文件名称的字符串，os.path.join()函数就很有用。这些字符串将传递给几个文件相关的函数，本章将进行介绍。例如，下面的例子将一个文件名列表中的名称，添加到文件夹名称的末尾。

>>> myFiles = ['accounts.txt', 'details.csv', 'invite.docx']
>>> for filename in myFiles:
print(os.path.join('C:\\Users\\asweigart', filename))
C:\Users\asweigart\accounts.txt
C:\Users\asweigart\details.csv
C:\Users\asweigart\invite.docx

用 os.getcwd()函数可以取得当前工作路径的字符串；
用 os.makedirs()创建新文件夹；
os.path 模块包含了许多与文件名和文件路径相关的有用函数；
调用 os.path.abspath(path)将返回参数的绝对路径的字符串；
调用 os.path.relpath(path, start)将返回从 start 路径到 path 的相对路径的字符串；

文件读写过程

用 open()函数打开文件

文件的基本方法

读取和写入

使用管道重定向输出

组 织 文 件

shutil模块中包含一些函数，让你在 Python 程序中复制、移动、改名和删除文件。

shutil.copy()将复制一个文件，shutil.copytree()将复制整个文件夹，以及它包含的文件夹和文件。