一、概述
列表（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对象、浅拷贝和深拷贝』。