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

简介: list 和 tuple 的差别不只是能不能改:CPython 3.13 实测 tuple 字面量创建快 6.7 倍、迭代快约 16%、索引快约 18%、空容器省 16 字节。根在结构——PyTupleObject 定长不带 allocated 字段,PyListObject 多带扩容冗余。本文用实机数据拆开两者底层,告诉你什么时候该用哪个。

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

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

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 倍,但有个反转

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 重建一个新对象。可变的东西没法折叠,这是"可变"的第一笔税。

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

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 全面小胜

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 纳秒

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

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 默认计时,各场景取文中标注的次数。数值随机器有波动,但相对关系稳定。

相关文章
|
1月前
|
Linux iOS开发 Python
Python 虚拟环境到底怎么选?venv / conda / pipenv / poetry 一张对比表 + 9 个真实踩坑
venv、conda、pipenv、poetry 到底怎么选?本文用一张对比表 + 9 个真实踩坑讲清楚:什么时候 venv 就够了、什么时候必须上 poetry、conda 真正解决的是什么问题,以及虚拟环境里最常见的路径与依赖冲突该怎么排查。
|
2天前
|
程序员 Python
Python 里 := 到底解决什么问题?拆开优先级、作用域和两个 SyntaxError
:=(海象运算符)在表达式内部完成赋值并返回该值:while 读取循环一行顶三行,推导式过滤复用只算一遍。本文用本机 CPython 3.13.14 实测优先级陷阱(不带括号赋进 True 而非长度)、推导式作用域绑定外层、两类编译期 SyntaxError(重名迭代变量、类体禁用)与场景选择表
|
7天前
|
缓存 安全 Python
Python 的 isinstance 到底查了什么:拆开 __instancecheck__、ABC 缓存和 type 的区别
把类型判断写对,关键是理解 isinstance 会「问类的意见」而不是自己翻 MRO。本文用本机 CPython 3.13.14 实测 metaclass 上重写 __instancecheck__ 才生效、ABCMeta.register 的虚拟子类不进 __mro__、__subclasshook__ 只看方法存在性、伪造 __class__ 能改变 isinstance 结果、普通类与 ABC 路径 20 万次耗时差 4.4 倍,附对照表与七条排错清单
|
8月前
|
人工智能 Linux API
OpenClaw全自动小红书运营实战:从0到1全流程部署、技能配置与内容自动化发布指南
在内容自动化运营场景中,OpenClaw(Clawdbot)凭借高度可扩展的Skill体系与多任务执行能力,可实现从热点追踪、文案创作、封面生成到笔记发布、互动管理的全流程自动化。本文基于2026年最新环境,完整讲解如何通过阿里云轻量服务器或本地Windows11/macOS/Linux部署OpenClaw,安装并配置小红书运营Skill,完成Cookie登录、内容生成、笔记发布、数据监控,并接入阿里云百炼Coding Plan免费大模型与QMD记忆优化系统,实现低成本、7×24小时无人值守小红书运营。全文无营销词汇,所有命令可直接复制,零基础用户也能快速跑通全流程。
3600 9
|
13天前
|
Shell C++ Python
Python 里 copy.copy() 和 deepcopy() 到底差在哪:拆开 __copy__、__deepcopy__ 和那个防止无限递归的 memo 字典
copy.copy 换一个壳,copy.deepcopy 照着对象图重画一张并记牢谁指向谁。本文用本机 CPython 3.13.14 实测:浅拷贝嵌套层共享、deepcopy 对 int/str 返回原对象但含 list 的 tuple 会新建、__copy__/__deepcopy__ 钩子与 memo 传递、循环引用正确复刻、函数类不复制,以及 20 万次耗时 0.040s vs 1.052s(26.5 倍),附对照表与六条排错清单
|
14天前
|
缓存 Python
Python 的 class 语句到底执行了什么?拆开 __prepare__、metaclass.__new__ 和那个被讲反的 __set_name__ 顺序
class 语句几乎等价于 metaclass(name, bases, namespace) 调用。本文用本机 CPython 3.13.14 实测完整执行顺序:__prepare__ 先给 namespace、类体写入、type.__new__ 在内部触发 __set_name__ 与 __init_subclass__、最后才是元类 __init__;并实测 type 三参数建类、自定义 __prepare__ 返回 OrderedNS 要转 dict、元类冲突报错与六条排错清单
|
3天前
|
存储 安全 索引
Python 的 enumerate 到底多做了什么:拆开这个 C 层双产出对象
把带索引遍历写对,关键是理解 enumerate 只转发、不存储:它返回独立的双产出对象,共享你的迭代器,按次产 (index, value) 元组。本文用本机 CPython 3.13.14 实测独立对象无下标访问、共享迭代器被同步消费、start 只是偏移、字典只产 key、与 zip 组合的两层解包,以及百万次三方计时对照,附场景选择表
|
4天前
|
Python
Python 的 raise from 到底多接了一根线?拆开 __cause__ 和 __context__ 两条异常链
把异常链写对,关键是理解 __cause__ 和 __context__ 是两条独立的记录:context 由解释器自动挂载,cause 只有写了 from 才会设。本文用本机 CPython 3.13.14 实测隐式链的字段形态、from 的 suppress_context 开关、from None 只关显示不删记录、traceback 连接语选择规则、五层因果链长度与异常对象复用的坑,附场景选择表
|
5天前
|
存储 缓存 索引
Python 里 zip 遍历一次就空了:拆开最短截断、strict 参数和那个一次性迭代器
把并行遍历写对,关键是理解 zip 只转发、不存储:它返回一次性迭代器,按最短输入截断,且长度不等时长的一侧会被多推进一次。本文用本机 CPython 3.13.14 实测二次遍历为空、strict=True 在 3.10 与 3.13 的报错一致性、惰性取一次 next 只推进一次各生成器、zip_longest 补齐,以及 30 万对整数下 zip 比按索引快约 16% 的性能对照
|
6天前
|
Python
Python 的 @property 到底拦住了谁:拆开数据描述符、实例字典和那个删不掉的属性
把只读属性写对,关键是理解数据描述符的查找优先级:类上的 property 永远压过实例 __dict__,而只有 __get__ 的普通函数会被实例字典覆盖。本文用本机 CPython 3.13.14 实测 property 的描述符三件套、手写等价数据描述符、__set_name__ 自动命名校验、del 无 deleter 的报错路径与 20 万次性能对照,附四层属性查找顺序与三条误区