深入剖析 Python 最常用数据结构：列表(List) & 元组(Tuple)

1. 定义

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

在大多数编程语言中，集合内元素的数据类型必须保持一致，但在 Python 的列表与元组中，没有这个约束。

示例

列表 List = [‘Tom’, 22, 33, ‘tony’]

元组 Tuple = (‘China’, 10)

如上列表与元组的示例，列表与元组集合内同时存放了 int 类型和 string 类型的元素

2. 区别

列表是动态的，长度大小不固定，可以随意地新增、删除、修改集合内元素

input:

test_list = ['Tom', 22, 33, 'tony']
test_tuple = ('jack', 10)

# test_list新增元素
test_list.append('100')
test_list.append('200')
print(test_list)

# test_list修改元素
test_list[0] = 'xiaomin'
print(test_list)

# test_list删除元素
test_list.pop()
print(test_list)

output:

['Tom', 22, 33, 'tony', '100', '200']
['xiaomin', 22, 33, 'tony', '100', '200']
['xiaomin', 22, 33, 'tony', '100']

从输入，输出可以证明列表支持集合内元素的新增、删除、修改

元组是静态的，长度大小固定，不可以新增、删除、修改集合内元素

input:

test_tuple = ('jack', 10)

# test_tuple修改元素
test_tuple[0] = 'xiaomin'
print(test_tuple)

output:

Traceback (most recent call last):
  File "test001.py", line 5, in <module>
    test_tuple[0] = 'xiaomin'
TypeError: 'tuple' object does not support item assignment

从输入，输出可以证明元组不支持集合内元素的修改，新增和删除也不支持，大家可以自己动手实验下。

这也证明了Python中元组是静态不可变的。如果就想在原有元组集合中添加元素，有没有办法可以实现呢？

答案：“有的”，见如下示例

input:

test_tuple = ('jack', 10)
new_test_tuple = test_tuple + (20, 'xiaomin')
print(new_test_tuple)

output:

('jack', 10, 20, 'xiaomin')

虽然能实现想要的效果，但并不是真正意义上的原元组集合基础上元素的添加，而是创建了一个新的元组 new_test_tuple 来实现。

3. 索引

Python 中的列表和元组都支持正负数索引，正常索引区间，非正常索引区间取值。验证如下：

input:

test_list = [100, 200, 300, 400, 500]
# 列表支持区间索引取值: 取索引下标为1至倒数第2个元素之间的所有元素，规则：左闭右开
print(test_list[1:-1])
# 列表支持单个正数索引取值: 取正数第2个元素
print(test_list[2])
# 列表支持单个负数索引取值: 取倒数第2个元素
print(test_list[-2])
# 列表支持非区间索引取值: 从倒数第2个元素一直往前取所有
print(test_list[:-1])
print("*" * 20)

test_tuple = ('jack', 10, 20, 'tom')
# 元组支持区间索引取值: 取索引下标为1至倒数第2个元素之间的所有元素，规则：左闭右开
print(test_tuple[1:-1])
# 元组支持单个正数索引取值: 取正数第2个元素
print(test_tuple[2])
# 元组支持单个负数索引取值: 取倒数第2个元素
print(test_tuple[-2])
# 元组支持非区间索引取值: 从倒数第2个元素一直往前取所有
print(test_tuple[:-1])

output:

[200, 300, 400]
300
400
[100, 200, 300, 400]
********************
(10, 20)
20
20
('jack', 10, 20)

4. 嵌套 & 数据类型强转

列表和元组都可以随意嵌套和数据类型转换，见如下示例。

1). 嵌套

input:

# 列表内的元素支持嵌套，元素可以是一个列表
test_list = [[100, 200, 300], [400, 500]]
print("test_list列表中第1个元素的数据类型，{}".format(type(test_list[0])))
# 元组内的元素支持嵌套，元素可以是一个元组
test_tuple = (('jack', 10, 20, 'tom'), (4, 5, 6))
print("test_tuple列表中第1个元素的数据类型，{}".format(type(test_tuple[0])))

output:

test_list列表中第1个元素的数据类型，<class 'list'>
test_tuple列表中第1个元素的数据类型，<class 'tuple'>

2). 数据类型强转

input:

test_list = [100, 200, 300]
print("test_list列表使用tuple()函数进行强转后，元素输出结果为：{}".format(tuple(test_list)))
print("test_list列表使用tuple()函数进行强转后，元素所属数据类型输出结果为：{}".format(type(tuple(test_list))))
print("*" * 60)
test_tuple = ('jack', 10, 20, 'tom')
print("test_tuple元组使用list()函数进行强转后，元素输出结果为：{}".format(list(test_tuple)))
print("test_tuple元组使用list()函数进行强转后，元素所属数据类型输出结果为：{}".format(type(list(test_tuple))))

output:

test_list列表使用tuple()函数进行强转后，元素输出结果为：(100, 200, 300)
test_list列表使用tuple()函数进行强转后，元素所属数据类型输出结果为：<class 'tuple'>
************************************************************
test_tuple元组使用list()函数进行强转后，元素输出结果为：['jack', 10, 20, 'tom']
test_tuple元组使用list()函数进行强转后，元素所属数据类型输出结果为：<class 'list'>

5. 常用内置函数

1). count(item)

表示统计列表 / 元组中 item(元素) 出现的次数

input:

test_list = [100, 200, 300, 100, 400]
test_tuple = ('jack', 10, 20, 'tom', 10, 20, 10)
print("test_list列表中统计元素100出现的次数为：{}".format(test_list.count(100)))
print("test_tuple元组中统计元素10出现的次数为：{}".format(test_tuple.count(10)))

output:

test_list列表中统计元素100出现的次数为：2
test_tuple元组中统计元素10出现的次数为：3

2). index(item)

表示返回列表 / 元组中 item(元素) 第一次出现的索引值

input:

test_list = [100, 200, 300, 100, 400]
test_tuple = ('jack', 10, 20, 'tom', 10, 20, 10)
print("test_list列表中返回元素100第1次出现的索引值为：{}".format(test_list.index(100)))
print("test_tuple元组中返回元素10第1次出现的索引值为：{}".format(test_tuple.index(10)))

output:

test_list列表中返回元素100第1次出现的索引值为：0
test_tuple元组中返回元素10第1次出现的索引值为：1

3). list.reverse()

表示原地倒转列表（注意：元组没有这个内置函数)

input:

test_list = [100, 200, 300, 100, 400]
test_list.reverse()
print("test_list列表原地倒转后返回元素为：{}".format(test_list))

output:

test_list列表原地倒转后返回元素为：[400, 100, 300, 200, 100]

4). list.sort()

表示排序列表（注意：元组没有这个内置函数)

input:

test_list = [100, 200, 300, 100, 400]
test_list.sort()
print("test_list列表原地倒转后返回元素为：{}".format(test_list))

output:

test_list列表原地倒转后返回元素为：[100, 100, 200, 300, 400]

6. 存储方式

PS: 以下示例使用的是 Python3.9版本

input:

test_list = [100, 200, 300]
print("初始化相同元素，列表所占用的大小为：{}".format(test_list.__sizeof__()))
test_tuple = (100, 200, 300)
print("初始化相同元素，元组所占用的大小为：{}".format(test_tuple.__sizeof__()))

output:

初始化相同元素，列表所占用的大小为：104
初始化相同元素，元组所占用的大小为：48

从输出结果可以看到，初始化相同元素，但是元组的存储空间，却比列表要少56字节，这是由于什么原因导致的呢？

1). 存储指针占用：8字节

因为列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于int型，存储指针占用：8字节）

2). 分配8字节长度用于追踪列表空间使用情况

由于列表可变，所以需要额外存储已经分配的长度大小：8字节，用于实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间

3). 预留3个元素的存储空间共24字节

因为列表是动态的，需要提前预留3个元素的存储空间，每个元素是8字节，可以大大节省频繁分配空间的开销

4). 空列表占用空间比空元组占用空间多16字节

空列表所占用的大小为：40字节，空元组所占用的大小为：24字节

所以，最终列表比元组多占用的 56字节 = 8字节 + 8字节 + 24字节 + 16字节

PS:

元组长度大小固定，元素不可变，所以存储空间固定，空元组占用24字节，在初始化3个元素时，每个元素占用8字节，最终共占用48字节。

从上面的示例可知，元组要比列表更加轻量级一些，所以总体上而言，元组的性能速度要略优于列表。

欢迎关注 无量测试之道 公众号，回复：领取资源

Python+Unittest框架API自动化、

Python+Unittest框架API自动化、

Python+Pytest框架API自动化、

Python+Pandas+Pyecharts大数据分析、

Python+Selenium框架Web的UI自动化、

Python+Appium框架APP的UI自动化、

Python编程学习资源干货、

Vue前端组件化框架开发、

资源和代码 免费送啦~
文章下方有公众号二维码，可直接微信扫一扫关注即可。

备注：我的个人公众号已正式开通，致力于IT互联网技术的分享。

包含：数据分析、大数据、机器学习、测试开发、API接口自动化、测试运维、UI自动化、性能测试、代码检测、编程技术等。

微信搜索公众号：无量测试之道

添加关注，让我们一起共同成长！