
🔥承渊政道: 个人主页
❄️个人专栏: 《C语言基础语法知识》 《数据结构与算法》 《C++知识内容》 《Linux系统与网络知识》 《算法刷题指南》 《测评文章活动推广》 《大模型语言路线学习》 《MySQL数据库学习》 《Python知识内容》 《cpolar知识学习》 《LangChainAI应用开发框架 》 《QT、Redis、CMake、Docker、测试、运维》 《实战项目开发》
✨逆境不吐心中苦,顺境不忘来时路!✨ 🎬 博主简介:

在你能够开始编写程序之前,还有一个主题需要理解,那就是列表数据类型及元组.列表和元组可以包含多个值,这样编写程序来处理大量数据就变得更容易.而且,由于列表本身又可以包含其他列表,所以可以用它们将数据安排成层次结构.本文将探讨列表的基础知识.我也会讲授关于方法的内容.方法也是函数,它们与特定数据类型的值绑定.然后我会简单介绍类似列表的元组和字符串数据类型,以及它们与列表值的比较.

目录
- 1.列表数据类型
-
- 1.1用下标取得列表中的单个值
- 1.2负数下标
- 1.3利用切片取得子列表
- [1.4用 len() 取得列表的长度](#1.4用 len() 取得列表的长度)
- 1.5用下标改变列表中的值
- 1.6列表连接和列表复制
- [1.7用 del 语句从列表中删除值](#1.7用 del 语句从列表中删除值)
- 2.使用列表
- 3.增强的赋值操作
- 4.方法
-
- [4.1用index() 方法在列表中查找值](#4.1用index() 方法在列表中查找值)
- [4.2用append() 和 insert() 方法在列表中添加值](#4.2用append() 和 insert() 方法在列表中添加值)
- [4.3用remove() 方法从列表中删除值](#4.3用remove() 方法从列表中删除值)
- [4.4用sort() 方法将列表中的值排序](#4.4用sort() 方法将列表中的值排序)
- [5.例子程序:神奇 8 球和列表](#5.例子程序:神奇 8 球和列表)
- 6.类似列表的类型:字符串和元组
-
- 6.1可变和不可变数据类型
- 6.2元组数据类型
- [6.3用 list()和 tuple()函数来转换类型](#6.3用 list()和 tuple()函数来转换类型)
- 7.引用
-
- 7.1传递引用
- [7.2copy 模块的 copy()和 deepcopy()函数](#7.2copy 模块的 copy()和 deepcopy()函数)
- 8.小结
- 9.实践项目
1.列表数据类型
"列表"是一个值,它包含多个字构成的序列。术语"列表值"指的是列表本身(它作为一个值,可以保存在变量中,或传递给函数,像所有其他值一样),而不是指列表值之内的那些值。列表值看起来像这样:'cat', 'bat', 'rat', 'elephant'。就像字符串值用引号来标记字符串的起止一样,列表用左方括号开始,右方括号结束,即 \[\]。列表中的值也称为"表项"。表项用逗号分隔(就是说,它们是"逗号分隔的")。例如,在交互式环境中输入以下代码:
text
>>> [1, 2, 3]
[1, 2, 3]
>>> ['cat', 'bat', 'rat', 'elephant']
['cat', 'bat', 'rat', 'elephant']
>>> ['hello', 3.1415, True, None, 42]
['hello', 3.1415, True, None, 42]
① >>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam
['cat', 'bat', 'rat', 'elephant']
spam 变量①仍然只被赋予一个值:列表值。但列表值本身包含多个值。\[\] 是一个空列表,不包含任何值,类似于空字符串 ''。
1.1用下标取得列表中的单个值

假定列表 'cat', 'bat', 'rat', 'elephant' 保存在名为 spam 的变量中。Python 代码 spam0 将求值为 'cat',spam1 将求值为 'bat',依此类推。列表后面方括号内的整数被称为"下标"。列表中第一个值的下标是 0,第二个值的下标是 1,第三个值的下标是 2,依此类推。图 4-1 展示了一个赋给 spam 的列表值,以及下标表达式的求值结果。

图 4-1 一个列表值保存在 spam 变量中,展示了每个下标指向哪个值
例如,在交互式环境中输入以下表达式。开始将列表赋给变量 spam。
text
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0]
'cat'
>>> spam[1]
'bat'
>>> spam[2]
'rat'
>>> spam[3]
'elephant'
>>> ['cat', 'bat', 'rat', 'elephant'][3]
'elephant'
① >>> 'Hello ' + spam[0]
② 'Hello cat'
>>> 'The ' + spam[1] + ' ate the ' + spam[0] + '.'
'The bat ate the cat.'
请注意,表达式 'Hello ' + spam0①求值为 'Hello ' + 'cat',因为 spam0 求值为字符串 'cat'。这个表达式也因此求值为字符串 'Hello cat'②。
如果使用的下标超出了列表中值的个数,Python 将给出 IndexError 出错信息。
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[10000]
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
spam[10000]
IndexError: list index out of range
下标只能是整数,不能是浮点值。下面的例子将导致 TypeError 错误:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1]
'bat'
>>> spam[1.0]
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
spam[1.0]
TypeError: list indices must be integers, not float
>>> spam[int(1.0)]
'bat'
列表也可以包含其他列表值。这些列表的列表中的值,可以通过多重下标来访问,像这样:
pycon
>>> spam = [['cat', 'bat'], [10, 20, 30, 40, 50]]
>>> spam[0]
['cat', 'bat']
>>> spam[0][1]
'bat'
>>> spam[1][4]
50
第一个下标表明使用哪个列表值,第二个下标表明该列表值中的值。例如,spam01 打印出 'bat',即第一个列表中的第二个值。如果只使用一个下标,程序将打印出该下标处的完整列表值。
1.2负数下标
虽然下标从 0 开始并向上增长,但也可以用负整数作为下标。整数值 −1 指的是列表中的最后一个下标,−2 指的是列表中倒数第二个下标,以此类推。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[-1]
'elephant'
>>> spam[-3]
'bat'
>>> 'The ' + spam[-1] + ' is afraid of the ' + spam[-3] + '.'
'The elephant is afraid of the bat.'
1.3利用切片取得子列表

就像下标可以从列表中取得单个值一样,"切片"可以从列表中取得多个值,结果是一个新列表。切片输入在一对方括号中,像下标一样,但它有两个冒号分隔的整数。请注意下标和切片的不同。
- spam2 是一个列表和下标(一个整数)。
- spam1:4 是一个列表和切片(两个整数)。
在一个切片中,第一个整数是切片开始处的下标。第二个整数是切片结束处的下标。切片向上增长,直至第二个下标的值,但不包括它。切片求值为一个新的列表值。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']
作为快捷方法,你可以省略切片中冒号两边的一个下标或两个下标。省略第一个下标相当于使用 0,或列表的开始。省略第二个下标相当于使用列表的长度,意味着分片直至列表的末尾。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[:2]
['cat', 'bat']
>>> spam[1:]
['bat', 'rat', 'elephant']
>>> spam[:]
['cat', 'bat', 'rat', 'elephant']
1.4用 len() 取得列表的长度
len() 函数将返回传递给它的列表中值的个数,就像它能计算字符串中字符的个数一样。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'dog', 'moose']
>>> len(spam)
3
1.5用下标改变列表中的值
一般情况下,赋值语句左边是一个变量名,就像 spam = 4。但是,也可以使用列表的下标来改变下标处的值。例如,spam1 = 'aardvark' 意味着"将列表 spam 下标 1 处的值赋值为字符串 'aardvark'。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1] = 'aardvark'
>>> spam
['cat', 'aardvark', 'rat', 'elephant']
>>> spam[2] = spam[1]
>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']
>>> spam[-1] = 12345
>>> spam
['cat', 'aardvark', 'aardvark', 12345]
1.6列表连接和列表复制
+ 操作符可以连接两个列表,得到一个新列表,就像它将两个字符串合并成一个新字符串一样。* 操作符可以用于一个列表和一个整数,实现列表的复制。在交互式环境中输入以下代码:
pycon
>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']
1.7用 del 语句从列表中删除值
del 语句将删除列表中下标处的值,表中被删除值后面的所有值,都将向前移动一个下标。例如,在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']
del 语句也可用于一个简单变量,删除它,作用就像是"取消赋值"语句。如果在删除之后试图使用该变量,就会遇到 NameError 错误,因为该变量已不再存在。
在实践中,你几乎永远不需要删除简单变量。del 语句几乎总是用于删除列表中的值。
2.使用列表
当你第一次开始编程时,很容易会创建许多独立的变量,来保存一组类似的值。例如,如果要保存我的猫的名字,可能会写出这样的代码:
python
catName1 = 'Zophie'
catName2 = 'Pooka'
catName3 = 'Simon'
catName4 = 'Lady Macbeth'
catName5 = 'Fat-tail'
catName6 = 'Miss Cleo'
事实表明这是一种不好的编程方式。举一个例子,如果猫的数目发生改变,程序就不得不增加变量,来保存更多的猫。这种类型的程序也有很多重复或几乎相等的代码。考虑下面的程序中有多少重复代码,在文本编辑器中输入它并保存为 allMyCats1.py:
python
print('Enter the name of cat 1:')
catName1 = input()
print('Enter the name of cat 2:')
catName2 = input()
print('Enter the name of cat 3:')
catName3 = input()
print('Enter the name of cat 4:')
catName4 = input()
print('Enter the name of cat 5:')
catName5 = input()
print('Enter the name of cat 6:')
catName6 = input()
print('The cat names are:')
print(catName1 + ' ' + catName2 + ' ' + catName3 + ' ' + catName4 + ' ' +
catName5 + ' ' + catName6)
不必使用多个重复的变量,你可以使用单个变量,包含一个列表值。例如,下面是新的改进版本的 allMyCats1.py 程序。这个新版本使用了一个列表,可以保存用户输入的任意多的猫。在新的文件编辑器窗口中,输入以下代码并保存为 allMyCats2.py。
python
catNames = []
while True:
print('Enter the name of cat ' + str(len(catNames) + 1) +
' (Or enter nothing to stop.):')
name = input()
if name == '':
break
catNames = catNames + [name] # list concatenation
print('The cat names are:')
for name in catNames:
print(' ' + name)
运行这个程序,输出看起来像这样:
text
Enter the name of cat 1 (Or enter nothing to stop.):
Zophie
Enter the name of cat 2 (Or enter nothing to stop.):
Pooka
Enter the name of cat 3 (Or enter nothing to stop.):
Simon
Enter the name of cat 4 (Or enter nothing to stop.):
Lady Macbeth
Enter the name of cat 5 (Or enter nothing to stop.):
Fat-tail
Enter the name of cat 6 (Or enter nothing to stop.):
Miss Cleo
Enter the name of cat 7 (Or enter nothing to stop.):
The cat names are:
Zophie
Pooka
Simon
Lady Macbeth
Fat-tail
Miss Cleo
使用列表的好处在于,现在数据放在一个结构中,所以程序能够更灵活的处理数据,比放在一些重复的变量中方便。
2.1列表用于循环
在前面的学习中,你学习了使用循环,对一段代码执行一定次数。从技术上说,循环是针对一个列表或类似列表中的每个值,重复地执行代码块。例如,如果执行以下代码:
python
for i in range(4):
print(i)
程序的输出将是:
text
0
1
2
3
这是因为 range(4) 的返回值是类似列表的值。Python 认为它类似于 0, 1, 2, 3。下面的程序和前面的程序输出相同:
python
for i in [0, 1, 2, 3]:
print(i)
前面的 for 循环实际上是在循环执行它的子句,在每次迭代中,让变量依次设置为列表中的值。
一个常见的 Python 技巧,是在 for 循环中使用 range(len(someList)),迭代列表的每一个下标。例如,在交互式环境中输入以下代码:
pycon
>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
>>> for i in range(len(supplies)):
print('Index ' + str(i) + ' in supplies is: ' + supplies[i])
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flame-throwers
Index 3 in supplies is: binders
在前面的循环中使用 range(len(supplies)) 很方便,这是因为,循环中的代码可以访问下标(通过变量 i),以及下标处的值(通过 suppliesi)。最妙的是,range(len(supplies)) 将迭代 supplies 的所有下标,无论它包含多少表项。
2.2in和not in操作符
利用 in 和 not in 操作符,可以确定一个值否在列表中。像其他操作符一样,in 和 not in 用在表达式中,连接两个值:一个要在列表中查找的值,以及待查找的列表。这些表达式将求值为布尔值。在交互式环境中输入以下代码:
pycon
>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True
例如,下面的程序让用户输入一个宠物名字,然后检查该名字是否在宠物列表中。打开一个新的文件编辑器窗口,输入以下代码,并保存为 myPets.py:
python
myPets = ['Zophie', 'Pooka', 'Fat-tail']
print('Enter a pet name:')
name = input()
if name not in myPets:
print('I do not have a pet named ' + name)
else:
print(name + ' is my pet.')
输出可能像这样:
text
Enter a pet name:
Footfoot
I do not have a pet named Footfoot
2.3多重赋值技巧
多重赋值技巧是一种快捷方式,让你在一行代码中,用列表中的值为多个变量赋值。所以不必像这样:
pycon
>>> cat = ['fat', 'black', 'loud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]
而是输入下面的代码:
pycon
>>> cat = ['fat', 'black', 'loud']
>>> size, color, disposition = cat
变量的数目和列表的长度必须严格相等,否则 Python 将给出 ValueError:
pycon
>>> cat = ['fat', 'black', 'loud']
>>> size, color, disposition, name = cat
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
size, color, disposition, name = cat
ValueError: need more than 3 values to unpack
3.增强的赋值操作
在对变量赋值时,常常会用到变量本身。例如,将 42 赋给变量 spam 之后,用下面的代码让 spam 的值增加 1:
pycon
>>> spam = 42
>>> spam = spam + 1
>>> spam
43
作为一种快捷方式,可以用增强的赋值操作符 += 来完成同样的事:
pycon
>>> spam = 42
>>> spam += 1
>>> spam
43
针对 +、-、*、/ 和 % 操作符,都有增强的赋值操作符,如表 4-1 所示。
表 4-1 增强的赋值操作符
| 增强的赋值语句 | 等价的赋值语句 |
|---|---|
spam += 1 |
spam = spam + 1 |
spam -= 1 |
spam = spam - 1 |
spam *= 1 |
spam = spam * 1 |
spam /= 1 |
spam = spam / 1 |
spam %= 1 |
spam = spam % 1 |
+= 操作符也可以完成字符串和列表的连接,*= 操作符可以完成字符串和列表的复制。在交互式环境中输入以下代码:
pycon
>>> spam = 'Hello'
>>> spam += ' world!'
>>> spam
'Hello world!'
>>> bacon = ['Zophie']
>>> bacon *= 3
>>> bacon
['Zophie', 'Zophie', 'Zophie']
4.方法
方法和函数是一回事,只是它是调用在一个值上。例如,如果一个列表值存储在 spam 中,你可以在这个列表上调用 index() 列表方法(稍后我会解释),就像 spam.index('hello') 一样。方法部分跟在这个值后面,以一个句点分隔。
每种数据类型都有它自己的一组方法。例如,列表数据类型有一些有用的方法,用来查找、添加、删除或操作列表中的值。
4.1用index() 方法在列表中查找值
列表值有一个 index() 方法,可以传入一个值,如果该值存在于列表中,就返回它的下标。如果该值不在列表中,Python 就报 ValueError。在交互式环境中输入以下代码:
pycon
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> spam.index('hello')
0
>>> spam.index('heyas')
3
>>> spam.index('howdy howdy howdy')
Traceback (most recent call last):
File "<pyshell#31>", line 1, in <module>
spam.index('howdy howdy howdy')
ValueError: 'howdy howdy howdy' is not in list
如果列表中存在重复的值,就返回它第一次出现的下标。在交互式环境中输入以下代码,注意 index() 返回 1,而不是 3:
pycon
>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> spam.index('Pooka')
1
4.2用append() 和 insert() 方法在列表中添加值

要在列表中添加新值,就使用 append() 和 insert() 方法。在交互式环境中输入以下代码,对变量 spam 中的列表调用 append() 方法:
pycon
>>> spam = ['cat', 'dog', 'bat']
>>> spam.append('moose')
>>> spam
['cat', 'dog', 'bat', 'moose']
前面的 append() 方法调用,将参数添加到列表末尾。insert() 方法可以在列表任意下标处插入一个值。insert() 方法的第一个参数是新值的下标,第二个参数是要插入的新值。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'dog', 'bat']
>>> spam.insert(1, 'chicken')
>>> spam
['cat', 'chicken', 'dog', 'bat']
请注意,代码是 spam.append('moose') 和 spam.insert(1, 'chicken'),而不是 spam = spam.append('moose') 和 spam = spam.insert(1, 'chicken')。append() 和 insert() 都不会将 spam 的新值作为其返回值(实际上,append() 和 insert() 的返回值是 None,所以你肯定不希望将它保存为变量的新值)。但是,列表被"当场"修改了。
方法属于单个数据类型。append() 和 insert() 方法是列表方法,只能在列表上调用,不能在其他值上调用,例如字符串和整型。在交互式环境中输入以下代码,注意产生的 AttributeError 错误信息:
pycon
>>> eggs = 'hello'
>>> eggs.append('world')
Traceback (most recent call last):
File "<pyshell#19>", line 1, in <module>
eggs.append('world')
AttributeError: 'str' object has no attribute 'append'
>>> bacon = 42
>>> bacon.insert(1, 'world')
Traceback (most recent call last):
File "<pyshell#22>", line 1, in <module>
bacon.insert(1, 'world')
AttributeError: 'int' object has no attribute 'insert'
4.3用remove() 方法从列表中删除值
给 remove() 方法传入一个值,它将从被调用的列表中删除。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('bat')
>>> spam
['cat', 'rat', 'elephant']
试图删除列表中不存在的值,将导致 ValueError 错误。例如,在交互式环境中输入以下代码,注意显示的错误:
pycon
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('chicken')
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
spam.remove('chicken')
ValueError: list.remove(x): x not in list
如果该值在列表中出现多次,只有第一次出现的值会被删除。在交互式环境中输入以下代码:
pycon
>>> spam = ['cat', 'bat', 'rat', 'cat', 'hat', 'cat']
>>> spam.remove('cat')
>>> spam
['bat', 'rat', 'cat', 'hat', 'cat']
如果知道想要删除的值在列表中的下标,del 语句就很好用。如果知道想要从列表中删除的值,remove() 方法就很好用。
4.4用sort() 方法将列表中的值排序
数值的列表或字符串的列表,能用 sort() 方法排序。例如,在交互式环境中输入以下代码:
pycon
>>> spam = [2, 5, 3.14, 1, -7]
>>> spam.sort()
>>> spam
[-7, 1, 2, 3.14, 5]
>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']
>>> spam.sort()
>>> spam
['ants', 'badgers', 'cats', 'dogs', 'elephants']
也可以指定 reverse 关键字参数为 True,让 sort() 按逆序排序。在交互式环境中输入以下代码:
pycon
>>> spam.sort(reverse=True)
>>> spam
['elephants', 'dogs', 'cats', 'badgers', 'ants']
关于 sort() 方法,你应该注意 3 件事。首先,sort() 方法当场对列表排序。不要写出 spam = spam.sort() 这样的代码,试图记录返回值。
其次,不能对既有数字又有字符串值的列表排序,因为 Python 不知道如何比较它们。在交互式环境中输入以下代码,注意 TypeError 错误:
pycon
>>> spam = [1, 3, 2, 4, 'Alice', 'Bob']
>>> spam.sort()
Traceback (most recent call last):
File "<pyshell#70>", line 1, in <module>
spam.sort()
TypeError: unorderable types: str() < int()
第三,sort() 方法对字符串排序时,使用"ASCII 字符顺序",而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时,小写的 a 在大写的 Z 之后。例如,在交互式环境中输入以下代码:
pycon
>>> spam = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
>>> spam.sort()
>>> spam
['Alice', 'Bob', 'Carol', 'ants', 'badgers', 'cats']
如果需要按照普通的字典顺序来排序,就在 sort() 方法调用时,将关键字参数 key 设置为 str.lower。
pycon
>>> spam = ['a', 'z', 'A', 'Z']
>>> spam.sort(key=str.lower)
>>> spam
['a', 'A', 'z', 'Z']
这将导致 sort() 方法将列表中所有的表项当成小写,但实际上并不会改变它们在列表中的值。
5.例子程序:神奇 8 球和列表
前面我们写过神奇 8 球程序。利用列表,可以写出更优雅的版本。不是用一些几乎一样的 elif 语句,而是创建一个列表,针对它编码。打开一个新的文件编辑器窗口,输入以下代码,并保存为 magic8Ball2.py:
python
import random
messages = ['It is certain',
'It is decidedly so',
'Yes definitely',
'Reply hazy try again',
'Ask again later',
'Concentrate and ask again',
'My reply is no',
'Outlook not so good',
'Very doubtful']
print(messages[random.randint(0, len(messages) - 1)])
Python 中缩进规则的例外
在大多数情况下,代码行的缩进告诉 Python 它属于哪一个代码块。但是,这个规则有几个例外。例如在源代码文件中,列表实际上可以跨越几行。这些行的缩进并不重要。Python 知道,没有看到结束方括号,列表就没有结束。例如,代码可以看起来像这样:
pythonspam = ['apples', 'oranges', 'bananas', 'cats'] print(spam)当然,从实践的角度来说,大部分人会利用 Python 的行为,让他们的列表看起来漂亮且可读,就像神奇 8 球程序中的消息列表一样。
也可以在行末使用续行字符
\,将一条指令写成多行。可以把\看成是"这条指令在下一行继续"。\续行字符之后的一行中,缩进并不重要。例如,下面是有效的 Python 代码:
pythonprint('Four score and seven ' + \ 'years ago...')如果希望将一长行的 Python 代码安排得更为可读,这些技巧是有用的。
运行这个程序,你会看到它与前面的 magic8Ball.py 程序效果一样。
请注意用作 messages 下标的表达式:random.randint(0, len(messages) - 1)。这产生了一个随机数作为下标,不论 messages 的大小是多少。也就是说,你会得到 0 与 len(messages) - 1 之间的一个随机数。这种方法的好处在于,很容易向列表添加或删除字符串,而不必改变其他行的代码。如果稍后更新代码,就可以少改几行代码,引入缺陷的可能性也更小。
6.类似列表的类型:字符串和元组
列表并不是唯一表示序列值的数据类型。例如,字符串和列表实际上很相似,只要你认为字符串是单个文本字符的列表。对列表的许多操作,也可以作用于字符串:按下标取值、切片、用于 for 循环、用于 len(),以及用于 in 和 not in 操作符。为了看到这种效果,在交互式环境中输入以下代码:
pycon
>>> name = 'Zophie'
>>> name[0]
'Z'
>>> name[-2]
'i'
>>> name[0:4]
'Zoph'
>>> 'Zo' in name
True
>>> 'z' in name
False
>>> 'p' not in name
False
>>> for i in name:
print('* * * ' + i + ' * * *')
* * * Z * * *
* * * o * * *
* * * p * * *
* * * h * * *
* * * i * * *
* * * e * * *
6.1可变和不可变数据类型
但列表和字符串在一个重要的方面是不同的。列表是"可变的"数据类型,它的值可以添加、删除或改变。但是,字符串是"不可变的",它不能被更改。尝试对字符串中的一个字符重新赋值,将导致 TypeError 错误。在交互式环境中输入以下代码,你就会看到:
pycon
>>> name = 'Zophie a cat'
>>> name[7] = 'the'
Traceback (most recent call last):
File "<pyshell#50>", line 1, in <module>
name[7] = 'the'
TypeError: 'str' object does not support item assignment
"改变"一个字符串的正确方式,是使用切片和连接。构造一个"新的"字符串,从老的字符串那里复制一些部分。在交互式环境中输入以下代码:
pycon
>>> name = 'Zophie a cat'
>>> newName = name[0:7] + 'the' + name[8:12]
>>> name
'Zophie a cat'
>>> newName
'Zophie the cat'
我们用 [0:7] 和 [8:12] 来指那些不想替换的字符。请注意,原来的 'Zophie a cat' 字符串没有被修改,因为字符串是不可变的。尽管列表值是可变的,但下面代码中的第二行并没有修改列表 eggs:
pycon
>>> eggs = [1, 2, 3]
>>> eggs = [4, 5, 6]
>>> eggs
[4, 5, 6]
这里 eggs 中的列表值并没有改变,而是整个新的不同的列表值 ([4, 5, 6]),覆写了老的列表值。如图 4-2 所示。

图 4-2 当 eggs = 4, 5, 6被执行时,eggs 的内容被新的列表值取代
如果你确实希望修改 eggs 中原来的列表,让它包含 [4, 5, 6],就要这样做:
pycon
>>> eggs = [1, 2, 3]
>>> del eggs[2]
>>> del eggs[1]
>>> del eggs[0]
>>> eggs.append(4)
>>> eggs.append(5)
>>> eggs.append(6)
>>> eggs
[4, 5, 6]
在第一个例子中,eggs 最后的列表值与它开始的列表值是一样的。只是这个列表被改变了,而不是被覆写。图 4-3 展示了前面交互式脚本的例子中,前 7 行代码所做的 7 次改动。

图 4-3 del 语句和 append()方法当场修改了同一个列表值
改变一个可变数据类型的值(就像前面例子中 del 语句和 append() 方法所做的事),当场改变了该值,因为该变量的值没有被一个新的列表值取代。
区分可变与不可变类型,似乎没有什么意义,但 4.7.1 节"传递引用"将解释,使用可变参数和不可变参数调用函数时产生的不同行为。首先,让我们来看看元组数据类型,它是列表数据类型的不可变形式。
6.2元组数据类型

除了两个方面,"元组"数据类型几乎与列表数据类型一样。首先,元组输入时用圆括号 (),而不是用方括号 []。例如,在交互式环境中输入以下代码:
pycon
>>> eggs = ('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
3
但元组与列表的主要区别还在于,元组像字符串一样,是不可变的。元组不能让它们的值被修改、添加或删除。在交互式环境中输入以下代码,注意 TypeError 出错信息:
pycon
>>> eggs = ('hello', 42, 0.5)
>>> eggs[1] = 99
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
eggs[1] = 99
TypeError: 'tuple' object does not support item assignment
如果元组中只有一个值,你可以在括号内该值的后面跟上一个逗号,表明这种情况。否则,Python 将认为,你只是在一个普通括号内输入了一个值。逗号告诉 Python,这是一个元组(不像其他编程语言,Python 接受列表或元组中最后表项后面跟的逗号)。在交互式环境中,输入以下的 type() 函数调用,看看它们的区别:
pycon
>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>
你可以用元组告诉所有读代码的人,你不打算改变这个序列的值。如果需要一个永远不会改变的值的序列,就使用元组。使用元组而不是列表的第二个好处在于,因为它们是不可变的,它们的内容不会变化,Python 可以实现一些优化,让使用元组的代码比使用列表的代码更快。
6.3用 list()和 tuple()函数来转换类型
正如 str(42) 将返回 '42',即整数 42 的字符串表示形式,函数 list() 和 tuple() 将返回传递给它们的值的列表和元组版本。在交互式环境中输入以下代码,注意返回值与传入值是不同的数据类型:
pycon
>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
如果需要元组值的一个可变版本,将元组转换成列表就很方便。
7.引用

正如你看到的,变量保存字符串和整数值。在交互式环境中输入以下代码:
pycon
>>> spam = 42
>>> cheese = spam
>>> spam = 100
>>> spam
100
>>> cheese
42
你将 42 赋给 spam 变量,然后拷贝 spam 中的值,将它赋给变量 cheese。当稍后将 spam 中的值改变为 100 时,这不会影响 cheese 中的值。这是因为 spam 和 cheese 是不同的变量,保存了不同的值。
但列表不是这样的。当你将列表赋给一个变量时,实际上是将列表的"引用"赋给了该变量。引用是一个值,指向某些数据。列表引用是指向一个列表的值。这里有一些代码,让这个概念更容易理解。在交互式环境中输入以下代码:
text
① >>> spam = [0, 1, 2, 3, 4, 5]
② >>> cheese = spam
③ >>> cheese[1] = 'Hello!'
>>> spam
[0, 'Hello!', 2, 3, 4, 5]
>>> cheese
[0, 'Hello!', 2, 3, 4, 5]
这可能让你感到奇怪。代码只改变了 cheese 列表,但似乎 cheese 和 spam 列表同时发生了改变。
当创建列表时①,你将对它的引用赋给了变量。但下一行②只是将 spam 中的列表引用拷贝到 cheese,而不是列表值本身。这意味着存储在 spam 和 cheese 中的值,现在指向了同一个列表。底下只有一个列表,因为列表本身实际从未复制。所以当你修改 cheese 变量的第一个元素时③,也修改了 spam 指向的同一个列表。
记住,变量就像包含着值的盒子。本章前面的图显示列表在盒子中,这并不准确,因为列表变量实际上没有包含列表,而是包含了对列表的"引用"(这些引用包含一些 ID 数字,Python 在内部使用这些 ID,但是你可以忽略)。利用盒子作为变量的隐喻,图 4-4 展示了列表被赋给 spam 变量时发生的情形。

图 4-4 spam = 0, 1, 2, 3, 4, 5保存了对列表的引用,而非实际列表
然后,在图 4-5 中,spam 中的引用被复制给 cheese。只有新的引用被创建并保存在 cheese 中,而非新的列表。请注意,两个引用都指向同一个列表。

图 4-5 spam = cheese 复制了引用,而非列表
当你改变 cheese 指向的列表时,spam 指向的列表也发生了改变,因为 cheese 和 spam 都指向同一个列表,如图 4-6 所示。

图 4-6 cheese1 = 'Hello!'修改了两个变量指向的列表
变量包含对列表值的引用,而不是列表值本身。但对于字符串和整数值,变量就包含了字符串或整数值。在变量必须保存可变数据类型的值时,例如列表或字典,Python 就使用引用。对于不可变的数据类型的值,例如字符串、整型或元组,Python 变量就保存值本身。
虽然 Python 变量在技术上包含了对列表或字典值的引用,但人们通常随意地说,该变量包含了列表或字典。
7.1传递引用
要理解参数如何传递给函数,引用就特别重要。当函数被调用时,参数的值被复制给变元。对于列表(以及字典,我将在下一章中讨论),这意味着变元得到的是引用的拷贝。要看看这导致的后果,请打开一个新的文件编辑器窗口,输入以下代码,并保存为 passingReference.py:
python
def eggs(someParameter):
someParameter.append('Hello')
spam = [1, 2, 3]
eggs(spam)
print(spam)
请注意,当 eggs() 被调用时,没有使用返回值来为 spam 赋新值。相反,它直接当场修改了该列表。在运行时,该程序产生输出如下:
text
[1, 2, 3, 'Hello']
尽管 spam 和 someParameter 包含了不同的引用,但它们都指向相同的列表。这就是为什么函数内的 append('Hello') 方法调用在函数调用返回后,仍然会对该列表产生影响。
请记住这种行为:如果忘了 Python 处理列表和字典变量时采用这种方式,可能会导致令人困惑的缺陷。
7.2copy 模块的 copy()和 deepcopy()函数

在处理列表和字典时,尽管传递引用常常是最方便的方法,但如果函数修改了传入的列表或字典,你可能不希望这些变动影响原来的列表或字典。要做到这一点,Python 提供了名为 copy 的模块,其中包含 copy() 和 deepcopy() 函数。第一个函数 copy.copy(),可以用来复制列表或字典这样的可变值,而不只是复制引用。在交互式环境中输入以下代码:
pycon
>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']
现在 spam 和 cheese 变量指向独立的列表,这就是为什么当你将 42 赋给下标 7 时,只有 cheese 中的列表被改变。在图 4-7 中可以看到,两个变量的引用 ID 数字不再一样,因为它们指向了独立的列表。

图 4-7 cheese = copy.copy(spam)创建了第二个列表,能独立于第一个列表修改
如果要复制的列表中包含了列表,那就使用 copy.deepcopy() 函数来代替。deepcopy() 函数将同时复制它们内部的列表。
8.小结
列表是有用的数据类型,因为它们让你写代码处理一组可以修改的值,同时仅用一个变量。
列表是可变的,这意味着它们的内容可以改变。元组和字符串虽然在某些方面像列表,却是不可变的,不能被修改。包含一个元组或字符串的变量,可以被一个新的元组或字符串覆写,但这和现场修改原来的值不是一回事,不像 append() 和 remove() 方法在列表上的效果。
变量不直接保存列表值,它们保存对列表的"引用"。在复制变量或将列表作为函数调用的参数时,这一点很重要。因为被复制的只是列表引用,所以要注意,对该列表的所有改动都可能影响到程序中的其他变量。如果需要对一个变量中的列表修改,同时不修改原来的列表,就可以用 copy() 或 deepcopy()。
9.实践项目
作为实践,编程完成下列任务。
9.1逗号代码
假定有下面这样的列表:
python
spam = ['apples', 'bananas', 'tofu', 'cats']
编写一个函数,它以一个列表值作为参数,返回一个字符串。该字符串包含所有表项,表项之间以逗号和空格分隔,并在最后一个表项之前插入 and。例如,将前面的 spam 列表传递给函数,将返回 'apples, bananas, tofu, and cats'。但你的函数应该能够处理传递给它的任何列表。
9.2字符图网格

假定有一个列表的列表,内层列表的每个值都是包含一个字符的字符串,像这样:
python
grid = [['.', '.', '.', '.', '.', '.'],
['.', 'O', 'O', '.', '.', '.'],
['O', 'O', 'O', 'O', '.', '.'],
['O', 'O', 'O', 'O', 'O', '.'],
['.', 'O', 'O', 'O', 'O', 'O'],
['O', 'O', 'O', 'O', 'O', '.'],
['O', 'O', 'O', 'O', '.', '.'],
['.', 'O', 'O', '.', '.', '.'],
['.', '.', '.', '.', '.', '.']]
你可以认为 grid[x][y] 是一幅"图"在 x、y 坐标处的字符,该图由文本字符组成。原点 (0, 0) 在左上角,向右 x 坐标增加,向下 y 坐标增加。
复制前面的网格值,编写代码用它打印出图像。
text
..OO.OO..
.OOOOOOO.
.OOOOOOO.
..OOOOO..
...OOO...
....O....
提示 你需要使用循环嵌套循环,打印出
grid[0][0],然后grid[1][0],然后grid[2][0],以此类推,直到grid[8][0]。这就完成第一行,所以接下来打印换行。然后程序将打印出grid[0][1],然后grid[1][1],然后grid[2][1],以此类推。程序最后将打印出grid[8][5]。
而且,如果你不希望在每次 print() 调用后都自动打印换行,记得向 print() 传递 end 关键字参数。

🚀真正的勇者不是流泪的人,而是含泪奔跑的人!
敬请期待下一篇文章内容
每日心灵鸡汤: 把日子过顺,从每天的取舍开始!
为什么很多人的人生反复陷入混乱?关系乱,是不懂得筛选和拒绝,让不合适的人持续消耗自己;房间乱,是不断获取,却缺乏整理和舍弃的机制;反复减肥,是依赖短期意志力,却没有建立长期稳定的生活方式;反复陷入消费性负债,是不断透支未来的收入,满足当下的欲望;时间乱,是分不清轻重缓急,总在回应别人的需求,却忽略了自己的目标;工作乱,是缺乏优先级和有效的流程,每天忙于救火,却始终无法摆脱救火.看似是不同的问题,本质上却是同一个问题:缺乏边界,缺乏秩序,习惯用短期补救代替长期管理.人生的秩序,不是靠不断清理建立的,而是靠持续筛选、明确边界和长期维护形成的.
