美团原生AI编辑器

Python 列表与元组：搞懂这 3 个核心差异，再也不纠结用哪个

Python列表与元组：搞懂这3个核心差异，再也不纠结用哪个

在Python编程的世界里，数据结构是构建一切的基石。而列表（list）和元组（tuple），作为Python中最基础、最常用的两种数据结构，却常常让初学者陷入选择困境——到底什么时候用列表？什么时候用元组？今天，我们就从概念、操作、性能三个维度，彻底讲透这对“兄弟”的区别，帮你轻松掌握它们的用法。

一、先搞懂基础：列表和元组是什么？

首先要明确的是，列表和元组本质上都是可容纳任意数据类型的有序集合。这意味着它们有两个共同特点：

1. 元素类型无限制：不用像其他编程语言那样要求集合内元素类型统一，整数、字符串、布尔值甚至嵌套集合都能放；
2. 顺序固定：元素的存储顺序与添加顺序一致，支持通过索引访问。

我们用代码直观感受下：

# 列表：用方括号[]定义，元素类型可混合
my_list = [1, "Python", True, [2024, "学习"]]
print("列表内容：", my_list)  # 输出：[1, "Python", True, [2024, "学习"]]

# 元组：用圆括号()定义，元素类型同样可混合
my_tuple = (2, "编程", False, (300, "实战"))
print("元组内容：", my_tuple)  # 输出：(2, "编程", False, (300, "实战"))

从定义上看，两者似乎很相似，但核心差异藏在“可变性”上——这也是决定它们用法的关键。

二、核心差异：一个“灵活”，一个“死板”

列表和元组最本质的区别，在于是否支持元素的修改（增删改）：

• 列表（list）：动态可变：长度不固定，可随时添加、删除、修改元素；
• 元组（tuple）：静态不可变：长度一旦确定就无法改变，不能增删改元素，否则会报错。

我们通过代码对比这一差异：

# 1. 列表的“灵活”操作：修改、添加、删除元素
my_list = [1, 2, 3, 4]
# 修改元素（索引为3的元素，从4改成40）
my_list[3] = 40
print("修改后的列表：", my_list)  # 输出：[1, 2, 3, 40]

# 添加元素（在末尾加50）
my_list.append(50)
print("添加后的列表：", my_list)  # 输出：[1, 2, 3, 40, 50]

# 删除元素（删除值为2的元素）
my_list.remove(2)
print("删除后的列表：", my_list)  # 输出：[1, 3, 40, 50]

# 2. 元组的“死板”：试图修改会报错
my_tuple = (1, 2, 3, 4)
try:
    my_tuple[3] = 40  # 尝试修改元组元素
except TypeError as e:
    print("修改元组时的错误：", e)  
    # 输出：TypeError: 'tuple' object does not support item assignment

这里要注意：元组的“不可变”是指元素本身不能改，但如果元素是可变类型（比如列表），则元素内部的内容可以改。例如：

# 元组中的元素是列表（可变类型）
tuple_with_list = (1, [2, 3], 4)
# 修改元组中列表的元素
tuple_with_list[1][1] = 30
print("修改内部列表后的元组：", tuple_with_list)  
# 输出：(1, [2, 30], 4)

三、通用操作：这些用法两者都支持

虽然可变性不同，但列表和元组作为有序集合，支持很多相同的基础操作，比如索引、切片、嵌套、相互转换等。

1. 索引访问（正负索引都支持）

通过索引可以快速定位元素，正索引从0开始，负索引从-1开始（-1表示最后一个元素）：

my_list = [10, 20, 30, 40]
my_tuple = (100, 200, 300, 400)

# 正索引：取第2个元素（索引1）
print("列表索引1的元素：", my_list[1])  # 输出：20
print("元组索引1的元素：", my_tuple[1])  # 输出：200

# 负索引：取最后一个元素（索引-1）
print("列表索引-1的元素：", my_list[-1])  # 输出：40
print("元组索引-1的元素：", my_tuple[-1])  # 输出：400

2. 切片操作（截取部分元素）

通过[起始索引:结束索引:步长]的格式，可以截取集合中的部分元素，结果类型与原类型一致（列表切片仍为列表，元组切片仍为元组）：

my_list = [1, 2, 3, 4, 5]
my_tuple = (10, 20, 30, 40, 50)

# 截取索引1到3的元素（左闭右开，不包含结束索引）
print("列表切片[1:3]：", my_list[1:3])  # 输出：[2, 3]
print("元组切片[1:3]：", my_tuple[1:3])  # 输出：(20, 30)

# 步长为2，截取所有元素（隔一个取一个）
print("列表切片[::2]：", my_list[::2])  # 输出：[1, 3, 5]
print("元组切片[::2]：", my_tuple[::2])  # 输出：(10, 30, 50)

3. 嵌套使用（集合内放集合）

列表和元组都支持嵌套，即元素可以是另一个列表或元组：

# 列表嵌套列表
nested_list = [[1, 2], [3, 4, 5], [6]]
print("列表嵌套的元素：", nested_list[1][2])  # 输出：5（取第2个列表的第3个元素）

# 元组嵌套元组
nested_tuple = ((10, 20), (30, 40), (50,))
print("元组嵌套的元素：", nested_tuple[2][0])  # 输出：50（取第3个元组的第1个元素）

# 也支持交叉嵌套（列表里放元组，元组里放列表）
mixed_nested = [1, (2, 3), [4, (5, 6)]]
print("交叉嵌套的元素：", mixed_nested[2][1][0])  # 输出：5

4. 相互转换（list()和tuple()函数）

通过list()函数可以将元组转成列表，通过tuple()函数可以将列表转成元组：

# 元组转列表
my_tuple = (1, 2, 3)
tuple_to_list = list(my_tuple)
print("元组转列表的结果：", tuple_to_list, type(tuple_to_list))  
# 输出：[1, 2, 3] <class 'list'>

# 列表转元组
my_list = [4, 5, 6]
list_to_tuple = tuple(my_list)
print("列表转元组的结果：", list_to_tuple, type(list_to_tuple))  
# 输出：(4, 5, 6) <class 'tuple'>

四、性能与存储：元组比列表更“轻量”

除了可变性，列表和元组在存储空间和初始化速度上也有差异，这源于它们的底层设计：

• 列表：动态可变需要额外存储“指针”（指向元素的地址）和“长度信息”，且为了减少后续扩容的开销，会提前分配更多的空间；
• 元组：静态不可变，元素地址和长度固定，无需额外存储信息，空间占用更小。

我们用__sizeof__()方法查看存储空间（单位：字节），用timeit模块测试初始化速度：

# 1. 查看存储空间
my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
print("列表的存储空间：", my_list.__sizeof__())  # 输出：64字节
print("元组的存储空间：", my_tuple.__sizeof__())  # 输出：48字节

# 2. 测试初始化速度（用timeit模块，执行100万次的时间）
import timeit

# 列表初始化时间
list_time = timeit.timeit('my_list = [1,2,3,4,5,6]', number=1000000)
# 元组初始化时间
tuple_time = timeit.timeit('my_tuple = (1,2,3,4,5,6)', number=1000000)

print("列表初始化100万次时间：", list_time)  # 约0.03秒（不同环境略有差异）
print("元组初始化100万次时间：", tuple_time)  # 约0.006秒（约为列表的1/5）

不过要注意：索引访问速度两者相差不大，只有在频繁初始化或存储大量固定数据时，元组的性能优势才会明显。

五、终极选择：什么时候用列表？什么时候用元组？

看完上面的内容，相信你已经有了答案，这里总结两个核心场景：

用列表的场景：数据需要“变”

• 存储需要动态修改的数据，比如用户的购物车（随时添加/删除商品）、文章的评论列表（随时新增评论）；
• 数据长度不确定，后续可能需要扩容或缩容。

示例：购物车功能（用列表存储商品，支持添加/删除）

# 购物车（列表）
shopping_cart = ["手机", "耳机", "充电器"]
# 添加商品
shopping_cart.append("手机壳")
print("添加后的购物车：", shopping_cart)  # 输出：["手机", "耳机", "充电器", "手机壳"]
# 删除商品
shopping_cart.remove("耳机")
print("删除后的购物车：", shopping_cart)  # 输出：["手机", "充电器", "手机壳"]

用元组的场景：数据需要“稳”

• 存储固定不变的数据，比如用户的身份证号、出生日期（一旦确定不会修改）；
• 函数的返回值（比如divmod(5,2)返回(2,1)，用元组确保返回值不被意外修改）；
• 作为字典的键（列表不可哈希，不能当键，而元组可以）。

示例：存储用户固定信息（用元组，防止意外修改）

# 用户信息（元组：身份证号、姓名、出生日期，均为固定数据）
user_info = ("110101200001011234", "张三", "2000-01-01")
# 尝试修改身份证号（会报错，确保数据安全）
try:
    user_info[0] = "110101200001015678"
except TypeError as e:
    print("修改用户信息错误：", e)  # 输出：'tuple' object does not support item assignment

总结

列表和元组虽然都是Python中的有序集合，但核心差异决定了它们的适用场景：

• 列表：动态、灵活，适合存储需要修改的数据，代价是空间和初始化速度稍差；
• 元组：静态、安全，适合存储固定不变的数据，优势是更轻量、初始化更快。

记住一句话：“变则用列表，不变则用元组”。掌握这个原则，你就能在编程中快速做出选择，写出更高效、更安全的Python代码。

最后留一个小思考：如果需要存储一组“半固定”的数据（比如大部分元素不变，只有一个元素需要偶尔修改），你会选择列表还是元组？欢迎在评论区分享你的想法～

本文由mdnice多平台发布