Chapter 02 列表和元组，你该怎么用

---

前言

对于编程语言来说，数据结构肯定是根基了。那么我们学习python，肯定也要学习python的数据结构。
今天我们来学习python中的两种常见的数据结构：列表和元组。

一、列表和元组

列表和元组非常的相似，都是一个可以放置任意数据类型的有序集合。

列表基础

列表是可变对象（它们可以在原位置被修改），长度大小不固定，可以随意地增加、删除或者改变元素。

l = []  # 空列表
l = list()  # 空列表
l = [123, 'abc', 1.23, {}] # 四个元素，索引为0-3
l = [[1,2,3], [4,5,6], ['a', 'b', 'c']] # 嵌套列表
l = list('python')  # 可迭代独享元素的列表
l = list(range(-4,4)) # 连续整数的列表
l[i] # 索引
l[i][j] # 索引的索引
l[i:j] # 切片
len(l) # 长度
l1 + l2 # 拼接
l * 3 # 重复
1
2
3
4
5
6
7
8
9
10
11
12

for x in ls: print(x) # 迭代
3 in ls # 成员关系
ls.append(4) # 尾部添加
ls.extend([5,6,7]) # 尾部扩展
ls.insert(i, x) # 插入
ls.index(x) # 索引
ls.count(x) # 统计元素出现次数
ls.sort() # 排序
ls.reverse() # 反转
ls.copy() # 复制
ls.pop(i) # 删除i处元素
ls.remove(x) # 删除元素x
del ls[i] # 删除i处元素
del ls[i:j] # 删除i到j处片段
ls[i:j] = [] # 删除i到j处的片段
ls[i] = 3 # 索引赋值 
ls[i:j] = [4,5,6] # 切片赋值
ls = [x**2 for x in range(5)] # 列表推到和映射
list(map(ord, 'python')) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

元组基础

元组是静态的，不可变的，长度大小固定、无法增加删减或者改变。

() # 空元组
t = (0, ) # 单个元素的元组（非表达式）
t = (0, 'Ni', 1.2, 3) # 元组
t = ('Bob', ('dev', 'mgr')) # 嵌套元组
t = tuple('spam') # 一个可迭代对象的元素组成的元组
t[i] # 索引
t[i][j] # 索引的索引
t[i:j] # 切片
len(t) # 求长度
t1 + t2 # 拼接
t * 3 # 重复
1
2
3
4
5
6
7
8
9
10
11

如果你修改元组中的元素，则会报错，原因就是元组是不可变的。

如果你想对已有的元组做任何的‘改变’，则需要重新开辟一块内存，创建新的元组了。

for x in t: print(x) # 迭代
'p' in t # 成员关系测试
[x**2 for x in t]
t.index('p') 
t.count('p')
1
2
3
4
5

1. python中的列表和元组的索引从左往右是从0开始，从右往左是-1，-2，-3…
2. 列表和元组也支持切片操作；
3. 列表和元组也可以随意嵌套；
4. 同时两者也可以通过list() 和 tuple()函数相互转换；

ls = [1,2,3]
print('the type if ls is {}'.format(type(ls)))
tup = tuple(ls)
print('the type if tup is {}'.format(type(tup)))
t = ((1,2), ('a', 'b'))
print('the type if t is {}'.format(type(t)))
ls_t = list(t)
print('the type if ls_t is {}'.format(type(ls_t)))
1
2
3
4
5
6
7
8

输出：
the type if ls is <class 'list'>
the type if tup is <class 'tuple'>
the type if t is <class 'tuple'>
the type if ls_t is <class 'list'>
1
2
3
4
5

列表和元组存储方式的差异

ls = [[1,2,3], ['a','b','c']]
print(ls.__sizeof__())
tup = ((1,2,3), ('a','b','c'))
print(tup.__sizeof__())
1
2
3
4

输出：
56
40
1
2
3

可以看到，对于相同元素的元组和列表，但是元组的存储空间要小。这是因为列表是可变的，它需要存储指针，来指向对应的元素。由于列表动态可变，所以需要分配额外的存储来记录已经分配的长度大小，这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外的空间。

但相对于元组就不一样了，元组长度大小固定，元素不可变，所以存储空间固定。

列表和元组的性能与使用

从存储方式上可以看出：元组要比列表更轻量级一些，所以元组的性能速度略优于列表。

另外，python在后台的对静态数据做一些资源缓存。意思就是因为垃圾回收机制的存在，如果一些变量不被使用了，python就会回收它们所占用的内存，返还给操作系统。

但是对于元组这样的静态数据，如果它不被使用且所占的内存空间并不大时，python会暂时缓存这部分内存。这样，下次我们再创建相同大小的元组时，python就可以不再向操作系统发出请求，去寻找内存，而是可以直接分配之前缓存的内存空间这样就可以大大加快程序的运行速度。

• 元组的初始化要比列表快；
• 二者的索引操作，速度差别不大；
• 增加和删减，肯定是选用列表了。

使用场景：

1. 如果存储的数据和数量不变，肯定是元组合适；例如返回的不变的数据，地图的某些参数等
2. 如果存储的数据是可变的，比如网站的数据统计，则是列表更合适。