一、概述
列表(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 "", line 1, in
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 "", line 1, in
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方法，可以实现 深拷贝：既拷贝成员对象的引用，又会拷贝引用指向的成员对象本身。
值得注意的是，上述说法并不完全正确：如果成员对象本身是原子类型的(数值、字符串，或者只包含数值或字符串的元组)，那么对该成员不会发生真正的深拷贝，即便执行深拷贝动作，内部也只会进行浅拷贝。
