Python基础：序列（列表、元组）

一、概述

列表（list）是由一个个 Python对象 组成的序列。其中，Python对象 可以是任何类型的对象，包括 Python标准类型（数值、字符串、列表、元组和字典）以及 用户自定义类型（类）。相比而言，字符串 仅仅是字符的序列，因此列表的概念和用途比字符串更广泛。

元组（tuple）也是 Python对象 的序列，与列表非常接近。二者的主要差异点如下：

差异点	列表	元组
表示方法	空列表：[] 单元素列表：[1] 多元素列表[1, 'a']	空元组：() 单元素元组：(1,) 多元素元组：(1, 'a')
可变性	可变	不可变
可操作性	支持丰富的操作	仅支持序列操作
可哈希性	不可哈希，不能作为字典的关键字	可哈希，可以作为字典的关键字

其中，可变性 是列表和元组之间最本质的差异：列表是一个可变序列，而元组是一个不可变序列。用C/C++的话来讲，元组是一个const版本的列表。

二、操作

由于列表和元组都是序列类型，因此它们都支持 Python基础：序列 中给出的 通用序列操作 。

特别地，作为一个可变序列，列表还支持以下 列表操作：

操作	说明
s[i] = x	用x替换s中的第i个成员
del s[i]	从s中删除第i个成员
s[i:j] = t	用t替换s[i:j]
del s[i:j]	从s中删除s[i:j]（等价于s[i:j] = []）
s[i:j:k] = t	用t替换s[i:j:k]（len(t)必须等于len(s[i:j:k])）
del s[i:j:k]	从s中删除s[i:j:k]
s.append(x)	向s中添加一个成员x（等价于s[len(s):len(s)] = [x]）
s.count(x)	返回x在s中出现的次数（即满足s[i]==x的下标i的个数）
s.extend(x)	将迭代对象x中的成员扩充到s的末尾（等价于s[len(s):len(s)] = x）
s.index(x[, i[, j]])	返回x在s[i:j]中的最小下标，不存在则抛出ValueError异常
s.insert(i, x)	等价于s[i:i] = [x]
s.pop([i])	返回并删除s中的第i（默认为-1）个成员（等价于x = s[i]; del s[i]; return x）
s.remove(x)	等价于del s[s.index(x)]
s.reverse()	将s中的成员反序排列
s.sort([cmp[, key[, reverse]]])	对s进行排序

以上操作的示例如下：

>>> s = [1, 2, 3, 4, 5, 6]
>>> s[0] = 8
>>> s
[8, 2, 3, 4, 5, 6]
>>> del s[1]
>>> s
[8, 3, 4, 5, 6]
>>> s[2:4] = [7, 9, 10]
>>> s
[8, 3, 7, 9, 10, 6]
>>> del s[1:3]
>>> s
[8, 9, 10, 6]
>>> s[::-2] = [7, 4]
>>> s
[8, 4, 10, 7]
>>> del s[2::-1]
>>> s
[7]
>>> s.append(2)
>>> s
[7, 2]
>>> s.extend([5, 4, 3, 4, 2, 2, 1])
>>> s
[7, 2, 5, 4, 3, 4, 2, 2, 1]
>>> s.count(2), s.count(4)
(3, 2)
>>> s.index(2), s.index(4)
(1, 3)
>>> s.insert(1, [8, 9])
>>> s
[7, [8, 9], 2, 5, 4, 3, 4, 2, 2, 1]
>>> s.pop()
1
>>> s
[7, [8, 9], 2, 5, 4, 3, 4, 2, 2]
>>> s.pop(5)
3
>>> s
[7, [8, 9], 2, 5, 4, 4, 2, 2]
>>> s.remove(2)
>>> s
[7, [8, 9], 5, 4, 4, 2, 2]
>>> s.reverse()
>>> s
[2, 2, 4, 4, 5, [8, 9], 7]
>>> s.sort()
>>> s
[2, 2, 4, 4, 5, 7, [8, 9]]

三、列表特性

1、列表解析

列表解析 是列表特有的构建操作：结合列表的方括弧和for循环（还可以使用if进行过滤），在逻辑上描述要创建的列表的成员内容。

简单示例如下：

>>> [i * 2 for i in [8, -2, 5]]
[16, -4, 10]
>>> [i for i in range(8) if i % 2 == 0]
[0, 2, 4, 6]

2、数据结构

列表非常灵活，它是一个 操作丰富 的 可变序列。因此，使用列表可以很方便地实现一些经典的数据结构：如堆栈、队列等（具体可以参考 用Python实现的数据结构与算法：开篇）。

四、元组特性

1、可变与不可变

元组本身是不可变的，这意味着：如果元组为t，则可以通过t[i]来得到第i个成员的值，但无法通过t[i]去修改第i个成员的值。

元组包含的成员是否可变，与元组的不可变无关，只取决于成员本身的可变性。例如元组t的第i个成员是一个列表l，则可以通过t[i][j]去修改列表l的第j个成员的值。

>>> t = ('a', [1, 2], (7, 8))
>>> t[0] = 'b' # 元组t本身不可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[1][1] = 5 # 成员t[1]是列表，可变
>>> t
('a', [1, 5], (7, 8))
>>> t[2][1] = 10 # 成员t[2]是元组，不可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

2、默认集合类型

所有逗号分隔的、没有明确用符号包括的 多对象集合 的类型都默认为元组。

# 一般表达式
>>> 'abc', -4.24e93, 18+6.6j
('abc', -4.24e+93, (18+6.6j))
>>> x, y = 1, 2
>>> x, y
(1, 2)

# 函数返回值
>>> def func():
...     return 1, 2, 3
... 
>>> func()
(1, 2, 3)

特别地，函数的 位置参数 也是通过元组来实现的（具体参考 Python函数的带星号*参数）。

五、浅拷贝和深拷贝

在Python的世界里，对所有对象的操作都是通过 引用（本质上就是C中的 指针）来完成的。由此不难得知，在列表和元组中存储的 真正成员，不是成员对象本身，而是成员对象的引用。

对列表和元组进行拷贝时，默认进行的是 浅拷贝：只拷贝成员对象的引用，而不会拷贝引用指向的成员对象本身。借助于 copy模块 的deepcopy方法，可以实现 深拷贝：既拷贝成员对象的引用，又会拷贝引用指向的成员对象本身。

值得注意的是，上述说法并不完全正确：如果成员对象本身是原子类型的（数值、字符串，或者只包含数值或字符串的元组），那么对该成员不会发生真正的深拷贝，即便执行深拷贝动作，内部也只会进行浅拷贝。

浅拷贝和深拷贝的示意图如下：

关于浅拷贝和深拷贝的实际案例，可以参考 《Python核心编程（第二版）》 中的 『6.20』 一节：『*拷贝Python对象、浅拷贝和深拷贝』。