第 4 章　操作列表

第 4 章　操作列表 - 图1

在第3章，你学习了如何创建简单的列表，还学习了如何操作列表元素。在本章中，你将学习如何遍历整个列表，这只需要几行代码，无论列表有多长。循环让你能够对列表的每个元素都采取一个或一系列相同的措施，从而高效地处理任何长度的列表，包括包含数千乃至数百万个元素的列表。

4.1　遍历整个列表

你经常需要遍历列表的所有元素，对每个元素执行相同的操作。例如，在游戏中，可能需要将每个界面元素平移相同的距离；对于包含数字的列表，可能需要对每个元素执行相同的统计运算；在网站中，可能需要显示文章列表中的每个标题。需要对列表中的每个元素都执行相同的操作时，可使用Python中的for循环。

假设我们有一个魔术师名单，需要将其中每个魔术师的名字都打印出来。为此，我们可以分别获取名单中的每个名字，但这种做法会导致多个问题。例如，如果名单很长，将包含大量重复的代码。另外，每当名单的长度发生变化时，都必须修改代码。通过使用for循环，可让Python去处理这些问题。

下面使用for循环来打印魔术师名单中的所有名字：

magicians.py

  1. magicians = ['alice', 'david', 'carolina'] ❶
  2. for magician in magicians: ❷
  3.     print(magician) ❸

首先，我们像第3章那样定义了一个列表（见❶）。接下来，我们定义了一个for循环（见❷）；这行代码让Python从列表magicians中取出一个名字，并将其存储在变量magician中。最后，我们让Python打印前面存储到变量magician中的名字（见❸）。这样，对于列表中的每个名字，Python都将重复执行❷处和❸处的代码行。你可以这样解读这些代码：对于列表magicians中的每位魔术师，都将其名字打印出来。输出很简单，就是列表中所有的姓名：

  1. alice
  2. david
  3. carolina

4.1.1　深入地研究循环

循环这种概念很重要，因为它是让计算机自动完成重复工作的常见方式之一。例如，在前面的magicians.py中使用的简单循环中，Python将首先读取其中的第一行代码：

  1. for magician in magicians:

这行代码让Python获取列表magicians中的第一个值（'alice'），并将其存储到变量magician中。接下来，Python读取下一行代码：

  1.     print(magician)

它让Python打印magician的值——依然是'alice'。鉴于该列表还包含其他值，Python返回到循环的第一行：

  1. for magician in magicians:

Python获取列表中的下一个名字——'david'，并将其存储到变量magician中，再执行下面这行代码：

  1.     print(magician)

Python再次打印变量magician的值——当前为'david'。接下来，Python再次执行整个循环，对列表中的最后一个值——'carolina'进行处理。至此，列表中没有其他的值了，因此Python接着执行程序的下一行代码。在这个示例中，for循环后面没有其他的代码，因此程序就此结束。

刚开始使用循环时请牢记，对列表中的每个元素，都将执行循环指定的步骤，而不管列表包含多少个元素。如果列表包含一百万个元素，Python就重复执行指定的步骤一百万次，且通常速度非常快。

另外，编写for循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助。例如，对于小猫列表、小狗列表和一般性列表，像下面这样编写for循环的第一行代码是不错的选择：

  1. for cat in cats:
  2. for dog in dogs:
  3. for item in list_of_items:

这些命名约定有助于你明白for循环中将对每个元素执行的操作。使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表。

4.1.2　在for循环中执行更多的操作

在for循环中，可对每个元素执行任何操作。下面来扩展前面的示例，对于每位魔术师，都打印一条消息，指出他的表演太精彩了。

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3.     print(magician.title() + ", that was a great trick!") ❶

相比于前一个示例，唯一的不同是对于每位魔术师，都打印了一条以其名字为抬头的消息（见❶）。这个循环第一次迭代时，变量magician的值为'alice'，因此Python打印的第一条消息的抬头为'Alice'。第二次迭代时，消息的抬头为'David'，而第三次迭代时，抬头为'Carolina'。

下面的输出表明，对于列表中的每位魔术师，都打印了一条个性化消息：

  1. Alice, that was a great trick!
  2. David, that was a great trick!
  3. Carolina, that was a great trick!

在for循环中，想包含多少行代码都可以。在代码行for magician in magicians后面，每个缩进的代码行都是循环的一部分，且将针对列表中的每个值都执行一次。因此，可对列表中的每个值执行任意次数的操作。

下面再添加一行代码，告诉每位魔术师，我们期待他的下一次表演：

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3.     print(magician.title() + ", that was a great trick!")
  4.     print("I can't wait to see your next trick, " + magician.title() + ".\n") ❶

由于两条print语句都缩进了，因此它们都将针对列表中的每位魔术师执行一次。第二条print语句中的换行符"\n"（见❶）在每次迭代结束后都插入一个空行，从而整洁地将针对各位魔术师的消息编组：

  1. Alice, that was a great trick!
  2. I can't wait to see your next trick, Alice.
  4. David, that was a great trick!
  5. I can't wait to see your next trick, David.
  7. Carolina, that was a great trick!
  8. I can't wait to see your next trick, Carolina.

在for循环中，想包含多少行代码都可以。实际上，你会发现使用for循环对每个元素执行众多不同的操作很有用。

4.1.3　在for循环结束后执行一些操作

for循环结束后再怎么做呢？通常，你需要提供总结性输出或接着执行程序必须完成的其他任务。

在for循环后面，没有缩进的代码都只执行一次，而不会重复执行。下面来打印一条向全体魔术师致谢的消息，感谢他们的精彩表演。想要在打印给各位魔术师的消息后面打印一条给全体魔术师的致谢消息，需要将相应的代码放在for循环后面，且不缩进：

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3.     print(magician.title() + ", that was a great trick!")
  4.     print("I can't wait to see your next trick, " + magician.title() + ".\n")
  6. print("Thank you, everyone. That was a great magic show!") ❶

你在前面看到了，开头两条print语句针对列表中每位魔术师重复执行。然而，由于第三条print语句没有缩进，因此只执行一次：

  1. Alice, that was a great trick!
  2. I can't wait to see your next trick, Alice.
  4. David, that was a great trick!
  5. I can't wait to see your next trick, David.
  7. Carolina, that was a great trick!
  8. I can't wait to see your next trick, Carolina.
  10. Thank you, everyone. That was a great magic show!

使用for循环处理数据是一种对数据集执行整体操作的不错的方式。例如，你可能使用for循环来初始化游戏——遍历角色列表，将每个角色都显示到屏幕上；再在循环后面添加一个不缩进的代码块，在屏幕上绘制所有角色后显示一个Play Now按钮。

4.2　避免缩进错误

Python根据缩进来判断代码行与前一个代码行的关系。在前面的示例中，向各位魔术师显示消息的代码行是for循环的一部分，因为它们缩进了。Python通过使用缩进让代码更易读；简单地说，它要求你使用缩进让代码整洁而结构清晰。在较长的Python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识。

当你开始编写必须正确缩进的代码时，需要注意一些常见的缩进错误。例如，有时候，程序员会将不需要缩进的代码块缩进，而对于必须缩进的代码块却忘了缩进。通过查看这样的错误示例，有助于你以后避开它们，以及在它们出现在程序中时进行修复。

下面来看一些较为常见的缩进错误。

4.2.1　忘记缩进

对于位于for语句后面且属于循环组成部分的代码行，一定要缩进。如果你忘记缩进，Python会提醒你：

magicians.py

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3. print(magician) ❶

print语句（见❶）应缩进却没有缩进。Python没有找到期望缩进的代码块时，会让你知道哪行代码有问题。

  1.   File "magicians.py", line 3
  2.     print(magician)
  3.         ^
  4. IndentationError: expected an indented block

通常，将紧跟在for语句后面的代码行缩进，可消除这种缩进错误。

4.2.2　忘记缩进额外的代码行

有时候，循环能够运行而不会报告错误，但结果可能会出乎意料。试图在循环中执行多项任务，却忘记缩进其中的一些代码行时，就会出现这种情况。

例如，如果忘记缩进循环中的第2行代码（它告诉每位魔术师，我们期待他的下一次表演），就会出现这种情况：

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3.     print(magician.title() + ", that was a great trick!")
  4. 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”：

  1. Alice, that was a great trick!
  2. David, that was a great trick!
  3. Carolina, that was a great trick!
  4. I can't wait to see your next trick, Carolina.

这是一个逻辑错误。从语法上看，这些Python代码是合法的，但由于存在逻辑错误，结果并不符合预期。如果你预期某项操作将针对每个列表元素都执行一次，但它却只执行了一次，请确定是否需要将一行或多行代码缩进。

4.2.3　不必要的缩进

如果你不小心缩进了无需缩进的代码行，Python将指出这一点：

hello_world.py

  1. message = "Hello Python world!"
  2.     print(message) ❶

print语句（见❶）无需缩进，因为它并不属于前一行代码，因此Python将指出这种错误：

  1.   File "hello_world.py", line 2
  2.     print(message)
  3.     ^
  4. IndentationError: unexpected indent

为避免意外缩进错误，请只缩进需要缩进的代码。在前面编写的程序中，只有要在for循环中对每个元素执行的代码需要缩进。

4.2.4　循环后不必要的缩进

如果你不小心缩进了应在循环结束后执行的代码，这些代码将针对每个列表元素重复执行。在有些情况下，这可能导致Python报告语法错误，但在大多数情况下，这只会导致逻辑错误。

例如，如果不小心缩进了感谢全体魔术师精彩表演的代码行，结果将如何呢？

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians:
  3.     print(magician.title() + ", that was a great trick!")
  4.     print("I can't wait to see your next trick, " + magician.title() + ".\n")
  6.     print("Thank you everyone, that was a great magic show!") ❶

由于❶处的代码行被缩进，它将针对列表中的每位魔术师执行一次，如❷所示：

  1. Alice, that was a great trick!
  2. I can't wait to see your next trick, Alice.
  4. Thank you everyone, that was a great magic show! ❷
  5. David, that was a great trick!
  6. I can't wait to see your next trick, David.
  8. Thank you everyone, that was a great magic show! ❷
  9. Carolina, that was a great trick!
  10. I can't wait to see your next trick, Carolina.
  12. Thank you everyone, that was a great magic show! ❷

这也是一个逻辑错误，与4.2.2节的错误类似。Python不知道你的本意，只要代码符合语法，它就会运行。如果原本只应执行一次的操作执行了多次，请确定你是否不应该缩进执行该操作的代码。

4.2.5　遗漏了冒号

for语句末尾的冒号告诉Python，下一行是循环的第一行。

  1. magicians = ['alice', 'david', 'carolina']
  2. for magician in magicians ❶
  3.     print(magician)

如果你不小心遗漏了冒号，如❶所示，将导致语法错误，因为Python不知道你意欲何为。这种错误虽然易于消除，但并不那么容易发现。程序员为找出这样的单字符错误，花费的时间多得令人惊讶。这样的错误之所以难以发现，是因为通常在我们的意料之外。

动手试一试

4-1 比萨：想出至少三种你喜欢的比萨，将其名称存储在一个列表中，再使用for循环将每种比萨的名称都打印出来。

  • 修改这个for循环，使其打印包含比萨名称的句子，而不仅仅是比萨的名称。对于每种比萨，都显示一行输出，如“I like pepperoni pizza”。

  • 在程序末尾添加一行代码，它不在for循环中，指出你有多喜欢比萨。输出应包含针对每种比萨的消息，还有一个总结性句子，如“I really love pizza!”。

4-2 动物：想出至少三种有共同特征的动物，将这些动物的名称存储在一个列表中，再使用for循环将每种动物的名称都打印出来。

  • 修改这个程序，使其针对每种动物都打印一个句子，如“A dog would make a great pet”。

  • 在程序末尾添加一行代码，指出这些动物的共同之处，如打印诸如“Any of these animals would make a great pet!”这样的句子。

4.3　创建数值列表

需要存储一组数字的原因有很多，例如，在游戏中，需要跟踪每个角色的位置，还可能需要跟踪玩家的几个最高得分。在数据可视化中，处理的几乎都是由数字（如温度、距离、人口数量、经度和纬度等）组成的集合。

列表非常适合用于存储数字集合，而Python提供了很多工具，可帮助你高效地处理数字列表。明白如何有效地使用这些工具后，即便列表包含数百万个元素，你编写的代码也能运行得很好。

4.3.1　使用函数range()

Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range()来打印一系列的数字：

numbers.py

  1. for value in range(1,5):
  2.     print(value)

上述代码好像应该打印数字1~5，但实际上它不会打印数字5：

  1. 1
  2. 2
  3. 3
  4. 4

在这个示例中，range()只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range()让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。

要打印数字1~5，需要使用range(1,6)：

  1. for value in range(1,6):
  2.     print(value)

这样，输出将从1开始，到5结束：

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

使用range()时，如果输出不符合预期，请尝试将指定的值加1或减1。

4.3.2　使用range()创建数字列表

要创建数字列表，可使用函数list()将range()的结果直接转换为列表。如果将range()作为list()的参数，输出将为一个数字列表。

在前一节的示例中，我们打印了一系列数字。要将这些数字转换为一个列表，可使用list()：

  1. numbers = list(range(1,6))
  2. print(numbers)

结果如下：

  1. [1, 2, 3, 4, 5]

使用函数range()时，还可指定步长。例如，下面的代码打印1~10内的偶数：

even_numbers.py

  1. even_numbers = list(range(2,11,2))
  2. print(even_numbers)

在这个示例中，函数range()从2开始数，然后不断地加2，直到达到或超过终值（11），因此输出如下：

  1. [2, 4, 6, 8, 10]

使用函数range()几乎能够创建任何需要的数字集，例如，如何创建一个列表，其中包含前10个整数（即1~10）的平方呢？在Python中，两个星号（**）表示乘方运算。下面的代码演示了如何将前10个整数的平方加入到一个列表中：

squares.py

  1. squares = [] ❶
  2. for value in range(1,11): ❷
  3.     square = value**2 ❸
  4.     squares.append(square) ❹
  6. print(squares) ❺

首先，我们创建了一个空列表（见❶）；接下来，使用函数range()让Python遍历1~10的值（见❷）。在循环中，计算当前值的平方，并将结果存储到变量square中（见❸）。然后，将新计算得到的平方值附加到列表squares末尾（见❹）。最后，循环结束后，打印列表squares（见❺）：

  1. [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

为让这些代码更简洁，可不使用临时变量square，而直接将每个计算得到的值附加到列表末尾：

  1. squares = []
  2. for value in range(1,11):
  3.     squares.append(value**2) ❶
  5. print(squares)

❶处的代码与squares.py中❸处和❹处的代码等效。在循环中，计算每个值的平方，并立即将结果附加到列表squares的末尾。

创建更复杂的列表时，可使用上述两种方法中的任何一种。有时候，使用临时变量会让代码更易读；而在其他情况下，这样做只会让代码无谓地变长。你首先应该考虑的是，编写清晰易懂且能完成所需功能的代码；等到审核代码时，再考虑采用更高效的方法。

4.3.3　对数字列表执行简单的统计计算

有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

  1. >>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
  2. >>> min(digits)
  3. 0
  4. >>> max(digits)
  5. 9
  6. >>> sum(digits)
  7. 45

注意　出于版面考虑，本节使用的数字列表都很短，但这里介绍的知识也适用于包含数百万个数字的列表。

4.3.4　列表解析

前面介绍的生成列表squares的方式包含三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。面向初学者的书籍并非都会介绍列表解析，这里之所以介绍列表解析，是因为等你开始阅读他人编写的代码时，很可能会遇到它们。

下面的示例使用列表解析创建你在前面看到的平方数列表：

squares.py

  1. squares = [value**2 for value in range(1,11)]
  2. print(squares)

要使用这种语法，首先指定一个描述性的列表名，如squares；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式为value**2，它计算平方值。接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。在这个示例中，for循环为for value in range(1,11)，它将值1~10提供给表达式value**2。请注意，这里的for语句末尾没有冒号。

结果与你在前面看到的平方数列表相同：

  1. [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的立方用2**3表示。请创建一个列表，其中包含前10个整数（即1~10）的立方，再使用一个for循环将这些立方数都打印出来。

4-9 立方解析：使用列表解析生成一个列表，其中包含前10个整数的立方。

4.4　使用列表的一部分

在第3章中，你学习了如何访问单个列表元素。在本章中，你一直在学习如何处理列表的所有元素。你还可以处理列表的部分元素——Python称之为切片。

4.4.1　切片

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。

下面的示例处理的是一个运动队成员列表：

players.py

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  2. print(players[0:3]) ❶

❶处的代码打印该列表的一个切片，其中只包含三名队员。输出也是一个列表，其中包含前三名队员：

  1. ['charles', 'martina', 'michael']

你可以生成列表的任何子集，例如，如果你要提取列表的第2~4个元素，可将起始索引指定为1，并将终止索引指定为4：

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  2. print(players[1:4])

这一次，切片始于'martina'，终于'florence'：

  1. ['martina', 'michael', 'florence']

如果你没有指定第一个索引，Python将自动从列表开头开始：

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  2. print(players[:4])

由于没有指定起始索引，Python从列表开头开始提取：

  1. ['charles', 'martina', 'michael', 'florence']

要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引：

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  2. print(players[2:])

Python将返回从第3个元素到列表末尾的所有元素：

  1. ['michael', 'florence', 'eli']

无论列表多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素。本书前面说过，负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:]：

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  2. print(players[-3:])

上述代码打印最后三名队员的名字，即便队员名单的长度发生变化，也依然如此。

4.4.2　遍历切片

如果要遍历列表的部分元素，可在for循环中使用切片。在下面的示例中，我们遍历前三名队员，并打印他们的名字：

  1. players = ['charles', 'martina', 'michael', 'florence', 'eli']
  3. print("Here are the first three players on my team:")
  4. for player in players[:3]: ❶
  5.     print(player.title())

❶处的代码没有遍历整个队员列表，而只遍历前三名队员：

  1. Here are the first three players on my team:
  2. Charles
  3. Martina
  4. Michael

在很多情况下，切片都很有用。例如，编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中。然后，为获取该玩家的三个最高得分，你可以将该列表按降序排列，再创建一个只包含前三个得分的切片。处理数据时，可使用切片来进行批量处理；编写Web应用程序时，可使用切片来分页显示信息，并在每页显示数量合适的信息。

4.4.3　复制列表

你经常需要根据既有列表创建全新的列表。下面来介绍复制列表的工作原理，以及复制列表可提供极大帮助的一种情形。

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:]）。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

例如，假设有一个列表，其中包含你最喜欢的三种食品，而你还想创建另一个列表，在其中包含一位朋友喜欢的所有食品。不过，你喜欢的食品，这位朋友都喜欢，因此你可以通过复制来创建这个列表：

foods.py

  1. my_foods = ['pizza', 'falafel', 'carrot cake'] ❶
  2. friend_foods = my_foods[:] ❷
  4. print("My favorite foods are:")
  5. print(my_foods)
  7. print("\nMy friend's favorite foods are:")
  8. print(friend_foods)

我们首先创建了一个名为my_foods的食品列表（见❶），然后创建了一个名为friend_foods的新列表（见❷）。我们在不指定任何索引的情况下从列表my_foods中提取一个切片，从而创建了这个列表的副本，再将该副本存储到变量friend_foods中。打印每个列表后，我们发现它们包含的食品相同：

  1. My favorite foods are:
  2. ['pizza', 'falafel', 'carrot cake']
  4. My friend's favorite foods are:
  5. ['pizza', 'falafel', 'carrot cake']

为核实我们确实有两个列表，下面在每个列表中都添加一种食品，并核实每个列表都记录了相应人员喜欢的食品：

  1. my_foods = ['pizza', 'falafel', 'carrot cake']
  2. friend_foods = my_foods[:] ❶
  4. my_foods.append('cannoli') ❷
  5. friend_foods.append('ice cream') ❸
  7. print("My favorite foods are:")
  8. print(my_foods)
  10. print("\nMy friend's favorite foods are:")
  11. print(friend_foods)

与前一个示例一样，我们首先将my_foods的元素复制到新列表friend_foods中（见❶）。接下来，在每个列表中都添加一种食品：在列表my_foods中添加'cannoli'（见❷），而在friend_foods中添加'ice cream'（见❸）。最后，打印这两个列表，核实这两种食品包含在正确的列表中。

  1. My favorite foods are:
  2. ['pizza', 'falafel', 'carrot cake', 'cannoli'] ❹
  4. My friend's favorite foods are:
  5. ['pizza', 'falafel', 'carrot cake', 'ice cream'] ❺

❹处的输出表明，'cannoli'包含在你喜欢的食品列表中，而'ice cream'没有。❺处的输出表明，'ice cream'包含在你朋友喜欢的食品列表中，而'cannoli'没有。倘若我们只是简单地将my_foods赋给friend_foods，就不能得到两个列表。例如，下例演示了在不使用切片的情况下复制列表的情况：

  1. my_foods = ['pizza', 'falafel', 'carrot cake']
  3. #这行不通
  4. friend_foods = my_foods ❶
  6. my_foods.append('cannoli')
  7. friend_foods.append('ice cream')
  9. print("My favorite foods are:")
  10. print(my_foods)
  12. print("\nMy friend's favorite foods are:")
  13. 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中，但它也将出现在这两个列表中。

输出表明，两个列表是相同的，这并非我们想要的结果：

  1. My favorite foods are:
  2. ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
  4. My friend's favorite foods are:
  5. ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

注意　现在暂时不要考虑这个示例中的细节。基本上，当你试图使用列表的副本时，如果结果出乎意料，请确认你像第一个示例那样使用切片复制了列表。

动手试一试

4-10 切片：选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。

  • 打印消息“The first three items in the list are:”，再使用切片来打印列表的前三个元素。

  • 打印消息“Three items from the middle of the list are:”，再使用切片来打印列表中间的三个元素。

  • 打印消息“The last three items in the list are:”，再使用切片来打印列表末尾的三个元素。

4-11 你的比萨和我的比萨：在你为完成练习4-1而编写的程序中，创建比萨列表的副本，并将其存储到变量friend_pizzas中，再完成如下任务。

  • 在原来的比萨列表中添加一种比萨。

  • 在列表friend_pizzas中添加另一种比萨。

  • 核实你有两个不同的列表。为此，打印消息“My favorite pizzas are:”，再使用一个for循环来打印第一个列表；打印消息“My friend's favorite pizzas are:”，再使用一个for循环来打印第二个列表。核实新增的比萨被添加到了正确的列表中。

4-12 使用多个循环：在本节中，为节省篇幅，程序foods.py的每个版本都没有使用for循环来打印列表。请选择一个版本的foods.py，在其中编写两个for循环，将各个食品列表都打印出来。

4.5　元组

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

4.5.1　定义元组

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

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

dimensions.py

  1. dimensions = (200, 50) ❶
  2. print(dimensions[0]) ❷
  3. print(dimensions[1])

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

  1. 200
  2. 50

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

  1. dimensions = (200, 50)
  2. dimensions[0] = 250 ❶

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

  1. Traceback (most recent call last):
  2.   File "dimensions.py", line 3, in <module>
  3.     dimensions[0] = 250
  4. TypeError: 'tuple' object does not support item assignment

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

4.5.2　遍历元组中的所有值

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

  1. dimensions = (200, 50)
  2. for dimension in dimensions:
  3.     print(dimension)

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

  1. 200
  2. 50

4.5.3　修改元组变量

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

  1. dimensions = (200, 50) ❶
  2. print("Original dimensions:")
  3. for dimension in dimensions:
  4.     print(dimension)
  6. dimensions = (400, 100) ❷
  7. print("\nModified dimensions:") ❸
  8. for dimension in dimensions:
  9.     print(dimension)

我们首先定义了一个元组，并将其存储的尺寸打印了出来（见❶）；接下来，将一个新元组存储到变量dimensions中（见❷）；然后，打印新的尺寸（见❸）。这次，Python不会报告任何错误，因为给元组变量赋值是合法的：

  1. Original dimensions:
  2. 200
  3. 50
  5. Modified dimensions:
  6. 400
  7. 100

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

动手试一试

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

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

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

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

4.6　设置代码格式

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

为确保所有人编写的代码的结构都大致一致，Python程序员都遵循一些格式设置约定。学会编写整洁的Python后，就能明白他人编写的Python代码的整体结构——只要他们和你遵循相同的指南。要成为专业程序员，应从现在开始就遵循这些指南，以养成良好的习惯。

4.6.1　格式设置指南

若要提出Python语言修改建议，需要编写Python改进提案（Python Enhancement 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语句对特定元素采取特定的措施。