[TOC]
列表和元组基础
基本概念
列表和元组,都是一个可以放置任意数据类型的有序集合。
在绝大多数编程语言中,集合的数据类型必须一致。但是在 Python 语言中,并无要求:
l = [1, 2, 'hello', 'world'] # 列表中同时含有int和string类型的元素
l
[1, 2, 'hello', 'world']
tup = ('jason', 22) # 元组中同时含有int和string类型的元素
tup
('jason', 22)
主要区别:
- 列表是动态的,长度大小不固定,可以随意地增加、删减或者改变元素(mutable)。
- 元组是静态的,长度大小固定,无法增加删减或者改变(immutable)。
举个栗子:
l = [1, 2, 3, 4]
l[3] = 40 # 和很多语言类似,python中索引同样从0开始,l[3]表示访问列表的第四个元素
l
[1, 2, 3, 40]
tup = (1, 2, 3, 4)
tup[3] = 40
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
虽然元组不可变,但是你想对已有的元组做 “改变” 的操作,怎么办? 那就重新开辟一块内存,创建新的元组好了。
举例:(会修改原来列表中的元素,而不会创建新的列表)
tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组new_tup,并依次填充原元组的值
new _tup
(1, 2, 3, 4, 5)
l = [1, 2, 3, 4]
l.append(5) # 添加元素5到原列表的末尾
l
[1, 2, 3, 4, 5]
基本操作
和其他语言不同,Python 中的列表和元组都支持负数索引,-1 表示最后一个元素,-2 表示倒数第二个元素,以此类推。
举例:
l = [1, 2, 3, 4]
l[-1]
4
tup = (1, 2, 3, 4)
tup[-1]
4
列表和元组都支持切片操作:
l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从1到2的子列表
[2, 3]
tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从1到2的子元组
(2, 3)
列表和元组都可以随意嵌套:
l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表
tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一个元组
列表和元组都可以相互转换:
list((1, 2, 3))
[1, 2, 3]
tuple([1, 2, 3])
(1, 2, 3)
列表和元组常用的内置函数:
l = [3, 2, 3, 7, 8, 1]
l.count(3) # count(item) 表示统计列表 / 元组中 item 出现的次数
2
l.index(7) # index(item) 表示返回列表 / 元组中 item 第一次出现的索引
3
l.reverse()
l
[1, 8, 7, 3, 2, 3]
l.sort() # 排序,元组没有此内置函数
l
[1, 2, 3, 3, 7, 8]
tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
2
tup.index(7)
3
# reversed() 和 sorted() 同样表示对列表 / 元组进行倒转和排序,reversed() 返回一个倒转后的迭代器(上文例子使用 list() 函数再将其转换为列表);sorted() 返回排好序的新列表。
#
list(reversed(tup))
[1, 8, 7, 3, 2, 3]
sorted(tup)
[1, 2, 3, 3, 7, 8]
注意,列表的 reverse() 和 sort() 函数,执行时并不会创建一个新的对象,而是将原有值翻转或者是排序,返回值为 None
reversed 返回一个迭代器 revere 原地相当于修改原列表,元组没有。
注意事项
存储方式上的差异:
列表和元组最重要的区别就是,列表是动态的、可变的,而元组是静态的、不可变的。这样的差异,势必会影响两者存储方式,举例:
l = [1, 2, 3]
l.__sizeof__()
64
tup = (1, 2, 3)
tup.__sizeof__()
48
对列表和元组,我们放置了相同的元素,但是元组的存储空间,却比列表要少 16 字节。为什么?
原因:
由于列表是动态的,所以它需要存储指针,来指向对应的元素(上述例子中,对于 int 型,8 字节)。另外,由于列表可变,所以需要额外存储已经分配的长度大小(8 字节),这样才可以实时追踪列表空间的使用情况,当空间不足时,及时分配额外空间。比如:
l = []
l.__sizeof__() // 空列表的存储空间为40字节
40
l.append(1)
l.__sizeof__()
72 // 加入了元素1之后,列表为其分配了可以存储4个元素的空间 (72 - 40)/8 = 4
l.append(2)
l.__sizeof__()
72 // 由于之前分配了空间,所以加入元素2,列表空间不变
l.append(3)
l.__sizeof__()
72 // 同上
l.append(4)
l.__sizeof__()
72 // 同上
l.append(5)
l.__sizeof__()
104 // 加入元素5之后,列表的空间不足,所以又额外分配了可以存储4个元素的空间
总结一下:
为了减小每次增加 / 删减操作时空间分配的开销,Python 每次分配空间时都会额外多分配一些,这样的机制(over-allocating)保证了其操作的高效性:增加 / 删除的时间复杂度均为 O(1)。但是对于 元组,情况就不同了。元组长度大小固定,元素不可变,所以存储空间固定。
性能上的差异
通过上面的对比,可以得到结论:元组要比列表更加轻量级一些,所以总体上来说,元组的性能速度要略优于列表。
另外,Python 会在后台对静态资源做一些缓存 (resource caching)。通常来说,因为垃圾回收机制的存在,如果一些变量不被使用了,Python 就会回收它们所占用的内存,返还给操作系统,以便其他变量或其他应用使用。
但是对于一些静态变量,比如元组,如果它不被使用并且占用空间不大时,Python 会暂时缓存这部分内存。这样,下次我们再创建同样大小的元组时,Python 就可以不用再向操作系统发出请求,去寻找内存,而是可以直接分配之前缓存的内存空间,这样就能大大加快程序的运行速度。
举例:(计算初始化一个相同元素的列表和元组分别所需的时间)
元组的初始化速度,要比列表快 5 倍
python3 -m timeit 'x=(1,2,3,4,5,6)'
20000000 loops, best of 5: 9.97 nsec per loop
python3 -m timeit 'x=[1,2,3,4,5,6]'
5000000 loops, best of 5: 50.1 nsec per loop
索引操作的话,两者的速度差别非常小,几乎可以忽略不计。
python3 -m timeit -s 'x=[1,2,3,4,5,6]' 'y=x[3]'
10000000 loops, best of 5: 22.2 nsec per loop
python3 -m timeit -s 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 5: 21.9 nsec per loop
当然,如果你想要增加、删减或者改变元素,那么列表显然更优。
列表和元组的使用场景
- 如果存储的数据和数量不变,那么肯定选用元组更合适。
- 如果存储的数据或数量是可变的,比如日志处理,那么则用列表更合适。