【Python编程快速上手—让繁琐工作自动化】(列表:把数据排成队,从下标取值到深拷贝)


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

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

目录

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 知道,没有看到结束方括号,列表就没有结束。例如,代码可以看起来像这样:

python 复制代码
spam = ['apples',
    'oranges',
                    'bananas',
'cats']
print(spam)

当然,从实践的角度来说,大部分人会利用 Python 的行为,让他们的列表看起来漂亮且可读,就像神奇 8 球程序中的消息列表一样。

也可以在行末使用续行字符 \,将一条指令写成多行。可以把 \ 看成是"这条指令在下一行继续"。\ 续行字符之后的一行中,缩进并不重要。例如,下面是有效的 Python 代码:

python 复制代码
print('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 关键字参数。

🚀真正的勇者不是流泪的人,而是含泪奔跑的人!


敬请期待下一篇文章内容


每日心灵鸡汤: 把日子过顺,从每天的取舍开始!

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

相关推荐
大胖爱学习_MJ16 分钟前
Agent 如何安全地拿数据库密码?基于 HashiCorp Vault 的动态凭证下发
经验分享·python
tryCbest1 小时前
Python 爬虫从入门到实战(一):基础篇——从零写出第一个爬虫
开发语言·爬虫·python
无小道1 小时前
Python语句的特色
python·语句
多加点辣也没关系2 小时前
JavaScript|第40章:JavaScript 工程化实践
开发语言·javascript·ecmascript
2601_967980112 小时前
python pytest如何编写测试
python·测试用例·pytest·函数·assert
2601_967980113 小时前
Python中heapq模块的各种用法实例
数据结构·python·算法·应用实例·heapq模块
大胖爱学习_MJ3 小时前
超越向量检索:用 Spring Boot + Neo4j 手搓 GraphRAG 知识图谱记忆
java·后端·python
RobinDevNotes3 小时前
24GB Mac 做数字人:声音放本地,画面租云端
人工智能·python·macos·开发工具
吃我一窝jio4 小时前
Java Bug复盘与性能优化实战
java·开发语言·笔记