第2章 列表和元组

​ 本章将介绍一个新概念：数据结构。数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，第一个元素的索引为0，第二个元素的索引为1，依次类推。

1、序列概述

​ 列表[]可以修改，元组()不可以修改。

---

​ 注意：Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。

---

2、通用的序列操作

​ 注意Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。

2.1 索引

​ 序列中的所有元素都有编号——从0开始递增。

>>> greeting = 'Hello'
>>> greeting[0]
'H'

​ 这称为索引（indexing）。你可使用索引来获取元素。这种索引方式适用于所有序列。当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此1是最后一个元素的位置。

>>> greeting[-1]
'o'

​ 对于字符串字面量（以及其他的序列字面量），可直接对其执行索引操作，无需先将其赋给变量。

>>> 'Hello'[1]
'e'

​ 如果函数调用返回一个序列，可直接对其执行索引操作。例如，如果你只想获取用户输入的年份的第4位，可像下面这样做：

>>> fourth = input('Year: ')[3]
Year: 2005
>>> fourth
'5'

2.2 切片

​ 除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素。为此，可使用两个索引，并用冒号分隔：

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6] 
[4, 5, 6]
>>> numbers[0:1] 
[1]

​ 简而言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。

1. 绝妙的简写

如果切片结束于序列末尾，可省略第二个索引。

>>> numbers[-3:]
[8, 9, 10]

​ 同样，如果切片始于序列开头，可省略第一个索引。

>>> numbers[:3]
[1, 2, 3]

2. 更大的步长

​ 执行切片操作时，你显式或隐式地指定起点和终点，但通常省略另一个参数，即步长。在普通切片中，步长为1。例如，步长为2时，将从起点和终点之间每隔一个元素提取一个元素。

>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
numbers[3:6:3]
[4]

​ 当然，步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。

>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
>>> numbers[10:0:-2]
[10, 8, 6, 4, 2]
>>> numbers[0:10:-2]
[]
>>> numbers[::-2]
[10, 8, 6, 4, 2]

2.3 序列相加

​ 可使用加法运算符来拼接序列。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello, world!'
>>> [1, 2, 3] + 'world!'
Traceback (innermost last):
File "", line 1, in ?
[1, 2, 3] + 'world!'
TypeError: can only concatenate list (not "string") to list

​ 从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。

2.4 乘法

​ 将序列与数x相乘时，将重复这个序列x次来创建一个新序列：

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

​ None、空列表和初始化

​ 在Python中，None表示什么都没有。因此，要将列表的长度初始化为10，可像下面这样做：

>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

2.5 成员资格

​ 要检查特定的值是否包含在序列中，可使用运算符in。这个运算符与前面讨论的运算符（如乘法或加法运算符）稍有不同。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值。

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False

​ 长度、最小值和最大值

​ 内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素。

>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34

3、列表：Python 的主力

​ 列表是可变的，即可修改其内容。另外，列表有很多特有的方法。

3.1 函数list

​ 鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。为此，可使用函数list。

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']

​ 请注意，可将任何序列（而不仅仅是字符串）作为list的参数。

---

提示 要将字符列表（如前述代码中的字符列表）转换为字符串，可使用下面的表达式：

''.join(somelist)

​ 其中somelist是要转换的列表。

---

3.2 基本的列表操作

​ 本节将介绍一些修改列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。

1. 修改列表：给元素赋值

​ 修改列表很容易，只需使用第1章介绍的普通赋值语句即可，但不是使用类似于x = 2这样的赋值语句，而是使用索引表示法给特定位置的元素赋值，如x[1] = 2。

>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]

2. 删除元素

​ 从列表中删除元素也很容易，只需使用del语句即可。

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']

3. 给切片赋值

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']

​ 从上述代码可知，可同时给多个元素赋值。你可能认为，这有什么大不了的，分别给每个元素赋值不是一样的吗？确实如此，但通过使用切片赋值，可将切片替换为长度与其不同的序列。

>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']

​ 使用切片赋值还可在不替换原有元素的情况下插入新元素。

>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]

​ 在这里，我“替换”了一个空切片，相当于插入了一个序列。你可采取相反的措施来删除切片。

>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]

3.3 列表方法

​ 方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：

object.method(arguments)

​ 方法调用与函数调用很像，只是在方法名前加上了对象和句点（第7章将详细阐述方法到底是什么）。列表包含多个可用来查看或修改其内容的方法。

1. append

​ 方法append用于将一个对象附加到列表末尾。

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

2. clear

​ 方法clear就地清空列表的内容。

>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[]

​ 这类似于切片赋值语句lst[:] = []。

3. copy

​ 方法copy 复制列表。前面说过，常规复制只是将另一个名称关联到列表。

>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]

​ 要让a和b指向不同的列表，就必须将b关联到a的副本。

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]

​ 这类似于使用a[:]或list(a)，它们也都复制a。

4. count

​ 方法count计算指定的元素在列表中出现了多少次。

>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1

5. extend

​ 方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

6. index

​ 方法index在列表中查找指定值第一次出现的索引。

>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
4
index(value,[start,[stop]])
>>> a=[1,2,3,4,5,6,7,8,2,5,7] 
>>> a.index(2,2)
8

7. insert

​ 方法insert用于将一个对象插入列表。

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

8. pop

​ 方法pop从列表中删除一个元素（默认为最后一个元素），并返回这一元素。

>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

​ 使用pop可实现一种常见的数据结构——栈（stack）。栈就像一叠盘子，你可在上面添加盘子，还可从上面取走盘子。最后加入的盘子最先取走，这被为后进先出（LIFO）。

​ push和pop是大家普遍接受的两种栈操作（加入和取走）的名称。Python没有提供push，但可使用append来替代。方法pop和append的效果相反，因此将刚弹出的值压入（或附加）后，得到的栈将与原来相同。

---

提示 要创建先进先出（FIFO）的队列，可使用insert(0, …)代替append。另外，也可继续使用append，但用pop(0)替代pop()。一种更佳的解决方案是，使用模块collections中的deque。

---

9. remove

​ 方法remove用于删除第一个为指定值的元素。

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

10. reverse

​ 方法reverse按相反的顺序排列列表中的元素。

>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]

---

提示 如果要按相反的顺序迭代序列，可使用函数reversed。这个函数不返回列表，而是返回一个迭代器（迭代器将在第9章详细介绍）。你可使用list将返回的对象转换为列表。

>>> x = [1, 2, 3]
>>> list(reversed(x))
[3, 2, 1]

---

11. sort

​ 方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

​ 为获取排序后的列表的副本，另一种方式是使用函数sorted。

>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

​ 实际上，这个函数可用于任何序列，但总是返回一个列表。

>>> sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']

​ 如果要将元素按相反的顺序排列，可先使用sort（或sorted），再调用方法reverse，也可使用参数reverse，这将在下一小节介绍。

12. 高级排序

​ 方法sort接受两个可选参数：key和reverse。这两个参数通常是按名称指定的，称为关键字参数，将在第6章详细讨论。参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。

>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

​ 对于另一个关键字参数reverse，只需将其指定为一个真值（True或False，将在第5章详细介绍），以指出是否要按相反的顺序对列表进行排序。

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]

​ 函数sorted也接受参数key和reverse。在很多情况下，将参数key设置为一个自定义函数很有用。

4、元组：不可修改的序列

​ 与列表一样，元组也是序列，唯一的差别在于元组是不能修改的（你可能注意到了，字符串也不能修改）。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组，元组还可用圆括号括起（这也是通常采用的做法）。

>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3)
(1, 2, 3)

​ 你可能会问，如何表示只包含一个值的元组呢？这有点特殊：虽然只有一个值，也必须在它后面加上逗号。

>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)

​ 函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)

​ 元组的切片也是元组，就像列表的切片也是列表一样。为何要熟悉元组呢？原因有以下两个。

• 它们用作映射中的键（以及集合的成员），而列表不行。映射将在第4章详细介绍。
• 有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的index和count等方法时例外）。

5、小结

​ 下面来回顾一下本章介绍的一些最重要的概念。

• 序列：序列是一种数据结构，其中的元素带编号（编号从0开始）。列表、字符串和元组都属于序列，其中列表是可变的（你可修改其内容），而元组和字符串是不可变的（一旦创建，内容就是固定的）。要访问序列的一部分，可使用切片操作：提供两个指定切片起始和结束位置的索引。要修改列表，可给其元素赋值，也可使用赋值语句给切片赋值。
• 成员资格：要确定特定的值是否包含在序列（或其他容器）中，可使用运算符in。将运算符in用于字符串时情况比较特殊——这样可查找子串。
• 方法：一些内置类型（如列表和字符串，但不包括元组）提供了很多有用的方法。方法有点像函数，只是与特定的值相关联。方法是面向对象编程的一个重要方面，这将在第7章介绍。

本章介绍的新函数

函数	描述
len(seq)	返回序列的长度
list(seq)	将序列转换为列表
max(args)	返回序列或一组参数中的最大值
min(args)	返回序列和一组参数中的最小值
reversed(seq)	让你能够反向迭代序列
sorted(seq)	返回一个有序列表，其中包含指定序列中的所有元素
tuple(seq)	将序列转换为元组