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自动化、性能测试、代码检测、编程技术等。
微信搜索公众号：无量测试之道
添加关注，让我们一起共同成长！
