深入学习和对比Python 列表与元组
在 python 中列表和元组，都是一个可以放置任意数据类型的有序集合。
其主要异同点如下：
一、基本操作的异同点：
1、语法差异，定义方式不同
- 列表用方括号
[]，元组用圆括号()。 - 单元素元组需加逗号：
(1,)，否则会被识别为普通括号表达式。
a = [1] # 单元素列表
aa = [1,2,3,4] #多元素列表
l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素b = (1) # 整数 1，不是元组
c = (1,) # 单元素元组
cc = (1,2,3) # 多元素元组
tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素2、相同的索引支持
（1）Python 中的列表和元组 索引从 0 开始。
（2）Python 中的列表和元组都支持负数索引，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
l = [1, 2, 3, 4]
print(l[-1])
## 输出4
tup = (1, 2, 3, 4)
print(tup[-1])
## 输出43、列表和元组都支持切片操作
l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从 1 到 2 的子列表
## 输出结果[2, 3]tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从 1 到 2 的子元组
## 输出结果(2, 3)4、列表和元组都支持随意嵌套
l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表
tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一元组5、两者也可以通过 list() 和 tuple() 函数相互转换
# 元组转列表
list((1, 2, 3))
## 结果：列表结构 [1, 2, 3]# 列表转元组
tuple([1, 2, 3])
## 结果：元组结构 (1, 2, 3)6、支持的方法丰富性不同
- 列表方法丰富：
list.append() ： 直接在列表末尾添加一个元素，无返回值。list.extend()：将可迭代对象（如列表、元组、字符串）中的元素逐个添加到列表末尾，直接修改原列表，无返回值。list.insert()：在指定索引位置插入元素，原元素后移。直接修改原列表。list.remove()：删除列表中第一个匹配的元素。若不存在则引发ValueError。list.pop()：删除并返回指定索引的元素（默认最后一个元素），若索引越界引发IndexError。list.sort() ：原地对列表排序（默认升序），无返回值。list.reverse()：原地反转列表元素顺序，无返回值。
注： 详细使用示例参考文章：Python 列表常用函数介绍
- 元组仅支持基本操作：
count()和index()（与列表相同），但无修改方法。- tup.count(item) 表示统计列表 / 元组中 item 出现的次数。
- tup.index(item) 表示返回列表 / 元组中 item 第一次出现的索引。
- reversed() 和 sorted() 新列表或元组的倒转和排序。
- reversed() 和 sorted() 同样表示对列表 / 元组进行倒转和排序，但是会返回一个倒转后或者排好序的新的列表 / 元组。
-
l = [3, 2, 3, 7, 8, 1]
print(l.count(3))
## 结果 2
print(l.index(7))
## 结果3
l.reverse()
##结果 1
print(l)
## 结果 [1, 8, 7, 3, 2, 3]
l.sort() ## 排序
print(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]二、核心特性：可变性不同
- 列表：可变；列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素（mutable）。
- 元组：不可变；元组是静态的，长度大小固定，无法增加删减或者改变（immutable）。
l = [1, 2, 3, 4]
l[3] = 40 # 和很多语言类似，python 中索引同样从 0 开始，l[3] 表示访问列表的第四个元素
print(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、通过开辟新内存，创建新元组实现元组可变。
tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组 new_tup，并依次填充原元组的值
print(new _tup)
## 输出结果 (1, 2, 3, 4, 5)l = [1, 2, 3, 4]
l.append(5) # 添加元素 5 到原列表的末尾
## 输出结果 [1, 2, 3, 4, 5]2、若元组包含可变对象（如列表），这些对象仍可修改。
mixed_tuple = (1, [2, 3], "hello")
mixed_tuple[1].append(4) # 合法，变为 (1, [2, 3, 4], "hello")四、存储方式的差异：内存占用不同
- 元组是静态的，其内存分配更紧凑，占用更小（不可变性允许优化）。
- 列表是动态的，其会预留额外空间以适应动态增长，内存占用更大。
示例一：放置相同元素，列表占用存储空间明显多于元组
l = [1, 2, 3]
l.__sizeof__()
## 结果 64tup = (1, 2, 3)
tup.__sizeof__()
## 结果 48分析：事实上，由于列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于 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. 为了减小每次增加 / 删减操作时空间分配的开销，Python 每次分配空间时都会额外多分配一些，这样的机制 （over-allocating）保证了其操作的高效性：增加 / 删除的时间复杂度均为 O(1)。
五、性能不同
- 列表的存储空间略大于元组，性能略逊于元组。
- 元组相对于列表更加轻量级，性能稍优。
- 创建速度：元组比列表更快（构造简单）。
- 访问速度：两者差异可忽略不计。
示例一：初始化元组VS 列表
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分析：元组的初始化速度，要比列表快 5 倍。
示例二：索引操作
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六、使用场景不同
-
适合列表的场景：
- 需要动态修改数据（如数据收集、增删元素）。
- 需要丰富的内置方法（如
sort(),reverse()）。 - 示例：日志记录、用户输入处理。
-
适合元组的场景：
- 不可变数据容器：保证数据完整性（如函数返回值、字典键）。
- 高性能需求：快速创建和访问的常量数据集。
七、总结与选择建议
| 特性 | 列表（List） | 元组（Tuple） |
|---|---|---|
| 可变性 | 可变 | 不可变 |
| 性能 | 创建和内存效率较低 | 创建快、内存占用小 |
| 用途 | 动态数据操作 | 静态数据、字典键、函数返回值 |
| 语法 |
|
|
| 方法 | 丰富 | 仅 |
最佳实践：
- 默认使用元组存储不应修改的数据，确保安全性。
- 在数据频繁变化时使用列表。
- 大规模只读数据优先考虑元组以优化内存。