列表(list)和元组(tuple)的使用
基础
列表和元组,都是可以放置任意数据类型的有序集合,且不要求元素类型一致
e.g.
1
2list = [1,2,'hello','world']
tup = ('jason',22)list有点像是matlab中的array, 只不过是一般化了的array
- 注意一个是[], 一个是() 来表示数据
区别在于:
- 列表是动态的,长度大小不固定,可以随意地增加、删减或者改变元素
- 元组是静态的,长度大小固定,无法增加删减或者改变
- e.g. 试着改变最后一个元素:
1
2
3
4
5
6
7
8
9
10l = [1, 2, 3, 4]
l[3] = 40 # 更改最后一个元素
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
如果想增加一个元素,元组只能另创建一个元组,但列表可以直接加在末尾:
1
2
3
4
5
6
7
8
9tup = (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]列表和元组都支持负数索引(索引都是用[]):
1
2
3
4
5
6
7l = [1, 2, 3, 4]
l[-1]
4
tup = (1, 2, 3, 4)
tup[-1]
4都支持切片操作(注意切片操作不包括最后一个索引):
1
2
3
4
5
6
7l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从 1 到 2 的子列表
[2, 3]
tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从 1 到 2 的子元组
(2, 3)可以随意嵌套:
1
2
3l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表
tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一元组可以通过 list() 和 tuple() 函数相互转换
1
2
3
4
5list((1, 2, 3))
[1, 2, 3]
tuple([1, 2, 3])
(1, 2, 3)列表和元组常用的内置函数:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21l = [3, 2, 3, 7, 8, 1]
l.count(3)
2
l.index(7)
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
list(reversed(tup))
[1, 8, 7, 3, 2, 3]
sorted(tup)
[1, 2, 3, 3, 7, 8]
储存方式
先看一个例子:
1
2
3
4
5
6l = [1, 2, 3]
l.__sizeof__()
64
tup = (1, 2, 3)
tup.__sizeof__()
48可见同样的元素,元组的存储空间比列表少16字节
- 这是因为列表是动态的,它需要存储指针,来指向对应的元素(上述例子中,对于int型是8字节)
- 此外,由于列表可变,所以需要额外存储已经分配的长度大小(8 字节),这样才可以实时追踪列表空间的使用情况,当空间不足时,及时分配额外空间
例子如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18l = []
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 个元素的空间所以列表空间分配的时,为了减小每次增加 / 操作空间分配的开销,每次分配空间时都会额外分配一些,这样Over-allocating保证了其操作的高效性:即增加、删除 的时间复杂度为O(1).
- list和tuple的内部实现都是array的形式,list因为可变,所以是一个over-allocate的array,tuple因为不可变,所以长度大小固定。
列表和元组的性能
- 元组要比列表更加轻量级一些,所以总体上来说,元组的性能速度要略优于列表
- 此外,Python会在后台,对静态数据做一些资源缓存(resource caching). 通常来讲,因为垃圾回收机制的存在,如果一些变量不被使用了,Python就会回收他们所占用的内存,返还给操作系统
- 但是对一些静态变量,比如元组,如果它不被使用并且占用空间不大时,Python 会暂时缓存这部分内存,这样下次创建同样大小的元组时,Python 就可以不用再向操作系统发出请求,去寻找内存,而是可以直接分配之前缓存的内存空间,这样就能大大加快程序的运行速度
以下例子是计算初始化一个相同元素的列表和元组分别所需的时间。我们可以看到,元组的初始化速度,要比列表快 5 倍。
1
2
3
4python3 -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但如果是索引操作的话,两者速度差别非常小:
1
2
3
4python3 -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
列表和元组的使用场景
- 如果存储的数据和数量不变,比如你有一个函数,需要返回的是一个地点的经纬度,然后直接传给前端渲染,那么肯定选用元组更合适
- 如果存储的数据或数量是可变的,比如社交平台上的一个日志功能,是统计一个用户在一周之内看了哪些用户的帖子,那么则用列表更合适
思考题
想创建一个空的列表,我们可以用下面的 A、B 两种方式,请问它们在效率上有什么区别吗?应该优先考虑使用哪种?1
2
3
4
5
6# 创建空列表
# option A
empty_list = list()
# option B
empty_list = []
- answer: 区别主要在于list()是一个function call,Python的function call会创建stack,并且进行一系列参数检查的操作,比较expensive,反观[]是一个内置的C函数,可以直接被调用,因此效率高。