Python 的列表和元组到底差在哪?拆开 PyListObject 和 PyTupleObject,为什么一个能改一个不能

结论先行 :list 和 tuple 的差别不只是"能不能改"这么简单。实测 CPython 3.13.14:tuple 字面量创建比 list 快 6.7 倍 (0.012s vs 0.078s,各 100 万次)、迭代快约 16% 、索引快约 18% 、空容器省 16 字节。代价只有一个:创建后不能改。本文用实机数据拆开两者的底层结构,告诉你什么时候该用哪个。

1. 先看内存:同样装 1000 个元素,差了多少

python 复制代码
import sys
for n in [0, 3, 10, 1000]:
    l = list(range(n)); t = tuple(range(n))
    print(n, sys.getsizeof(l), sys.getsizeof(t))

实测输出(CPython 3.13.14,64 位):

元素数 list tuple 差值
0 56 B 40 B 16 B
3 88 B 64 B 24 B
10 136 B 120 B 16 B
1000 8056 B 8040 B 16 B

为什么 list 永远更胖? 拆开 C 源码看结构:PyTupleObject 只需要存一个定长的指针数组;而 PyListObject 除了指针数组,还多带一个 allocated 字段------它要记录"预分配了多少空间",为后面的 append 扩容做准备。这个字段就是 8 字节,加上对象头差异,list 天生比 tuple 重。

2. 创建速度:tuple 字面量快 6.7 倍,但有个反转

python 复制代码
import timeit
print(timeit.timeit("[1,2,3,4,5]", number=1000000))   # 0.078s
print(timeit.timeit("(1,2,3,4,5)", number=1000000))   # 0.012s

100 万次字面量创建:list 0.078s,tuple 0.012s,tuple 快 6.7 倍。

原因藏在编译期:只含常量的 tuple 字面量会被 CPython 做常量折叠 ------编译时就算好存进常量表,运行时直接从常量表里取引用,几乎零成本;而 list 字面量每次都要真刀真枪地调 BUILD_LIST 重建一个新对象。可变的东西没法折叠,这是"可变"的第一笔税。

但别急着下结论,换个写法就反转了:

python 复制代码
print(timeit.timeit("list(range(1000))", number=1000))   # 19.4ms
print(timeit.timeit("tuple(range(1000))", number=1000))  # 21.0ms

从迭代器构造时,list 反而略快 (19.4ms vs 21.0ms)。因为 tuple(...) 对任意可迭代对象要先走一遍通用迭代协议,而 list(...) 有专门的快速路径。所以"tuple 一定快"这个说法,只在字面量场景成立。

3. 读操作:tuple 全面小胜

python 复制代码
l = list(range(10000)); t = tuple(range(10000))
print(timeit.timeit("for x in l: pass", globals={'l': l}, number=1000))  # 103.8ms
print(timeit.timeit("for x in t: pass", globals={'t': t}, number=1000))  #  89.4ms
print(timeit.timeit("l[500]", globals={'l': l}, number=1000000))  # 0.0359s
print(timeit.timeit("t[500]", globals={'t': t}, number=1000000))  # 0.0295s

迭代 10000 元素 × 1000 次:tuple 快 16%;索引取值:tuple 快约 18%。

两者底层都是指针数组 + 随机访问,为什么 tuple 还快?因为 tuple 是定长不可变对象,解释器对它少了边界和容量检查的分支,GC 跟踪也更轻。差距不大,但在热循环里是白捡的。

4. 写操作:append 68 纳秒 vs 拼接 430 纳秒

python 复制代码
l = [0]*100
print(timeit.timeit("l.append(1)", globals={'l': l}, number=1000000))  # 0.068s → 68ns/次
t = tuple(range(100))
print(timeit.timeit("t + (1,)", globals={'t': t}, number=10000))       # 430ns/次

这就是"不可变"的真正代价:tuple 没有 append,想"加"一个元素只能 t + (1,) 重建一个全新对象,把旧元素整个拷贝一遍。n 元素的 tuple 拼一次是 O(n);而 list 的 append 靠超额分配,摊还下来是 O(1),实测 68 纳秒一次。

更关键的是 allocated 字段的扩容策略:list 的空间不是用一个分一个,而是按约 1.125 倍超额分配,所以连续 append 1000 次,真正重新分配内存的次数只有十几次。这就是为什么循环里往 list 追加很快,往 tuple"追加"是灾难。

5. 一个常被忽略的功能差异:能不能当字典的 key

python 复制代码
d = {(1, 2): "ok"}   # 正常
d = {[1, 2]: "ok"}   # TypeError: unhashable type: 'list'

tuple 在元素全部可哈希时自己也可哈希,能当 dict 的 key、能进 set;list 不能。做坐标点、复合键、缓存键的时候,tuple 是唯一选择。 另外函数默认参数、*args 收进来的东西,CPython 一律给的是 tuple------因为解释器要保证你拿到的这份东西不会被别处悄悄改掉。

6. 选型清单(收藏这张表)

场景 用哪个 原因
常量序列 / 字面量 tuple 常量折叠,创建快 6.7 倍
需要增删改 list append 68ns vs tuple 重建 O(n)
当 dict key / 进 set tuple 可哈希
热路径只读遍历 tuple 迭代/索引快 16~18%
函数返回值(多值) tuple 不可变,调用方改不坏
从迭代器大批量构造 list 专门快速路径,略快

小结 :tuple 的"快"来自不可变------常量折叠省创建、定长省检查、省 16 字节头部;list 的"灵活"也贵在有预分配字段和扩容策略。一句话:数据是"定死的一坨"就用 tuple,是"会长大的容器"就用 list,选反了不会报错,但会白白交性能税。

你在项目里因为把 list 当 tuple(或反过来)踩过坑吗?评论区聊聊。

实测环境:CPython 3.13.14(64 位 Windows),timeit 默认计时,各场景取文中标注的次数。数值随机器有波动,但相对关系稳定。

相关推荐
特立独行的猫A17 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
吃我一窝jio20 小时前
Python与Go线程模型深度对比
java·开发语言·python
zwd200521 小时前
Manim 怎么放大画面的某一部分?
python·动画·可视化·manim·数学动画
屿华AI21 小时前
AUTOSAR 实战-诊断工具 | UDS 0x27 安全访问的配置化实现:种子密钥算法插件化设计
python·测试工具·汽车
RobinDevNotes21 小时前
Claude Code 剪视频,不上传、不要 API Key
人工智能·python·音视频·开发工具·ipython
如夏倾城1 天前
VRRP(虚拟路由器冗余协议Virtual Router Redundancy Protocol)
网络·python·网络协议·安全·智能路由器·负载均衡·信息与通信
IvanCodes1 天前
LangChain(04):Runnable 与 LCEL 的执行与组合机制
python·langchain·agent
特创数字科技1 天前
纯本地离线运行的文档脱敏工具(技术分享)
前端·驱动开发·python
东莞市云毅网络有限公司1 天前
用 Playwright 搭一套问答平台引用监测的最小骨架
python·数据清洗·rag·企业知识库·文档解析
Thanks_ks1 天前
【第 010 讲】全面掌握 Python 变量与常量:变量的定义与赋值 | 标识符与命名规范 | 变量的底层机制 | 常量与魔术数字
python·内存·变量·标识符·常量·赋值·命名规范