Python 列表内存存储本质：存储差异原因与优化建议

---

在 Python 中处理大量字符串时，你可能会遇到意想不到的内存占用问题。比如需要存储一百万个短字符串或数字，按每个字符串平均 10 字节、每个 64 位整数 8 个字节计算，理论上只需约 8 到 10MB 内存，但实际用 Python 列表存储时，内存使用可能会到几十MB。这背后的原因是什么？又该如何优化？

1. 问题引入：列表存储的内存 “膨胀”

先看一段简单的代码，用普通列表存储一百万个短字符串、相同的短字符串、整数、相同的整数：

str_list = [f"item_{i}" for i in range(1000000)]
same_item_str_list = [f"item" for i in range(1000000)]
num_list = [i for i in range(1000000)]
same_item_num_list = [0 for i in range(1000000)]

直觉上，每个字符串 “item_xxx” 大约 8-10 字节，每个整数 8 个字节，一百万条数据应该在 8 到 10MB 左右。但实际内存使用如何呢，我们用pympler来精确测量。

先安装 pympler：

uv add pympler

修改代码，增加测量内存占用情况的打印：

from pympler import asizeofstr_list = [f"item_{i}" for i in range(1000000)]
same_item_str_list = [f"item" for i in range(1000000)]
num_list = [i for i in range(1000000)]
same_item_num_list = [0 for i in range(1000000)]print(f"str_list列表内存: {asizeof.asizeof(str_list) / 1024 / 1024:.2f} MB")
print(f"same_item_str_list列表内存: {asizeof.asizeof(same_item_str_list) / 1024 / 1024:.2f} MB")
print(f"num_list列表内存: {asizeof.asizeof(num_list) / 1024 / 1024:.2f} MB")
print(f"same_item_num_list列表内存: {asizeof.asizeof(same_item_num_list) / 1024 / 1024:.2f} MB")

再次运行，得到的内存报告大致如下（具体数值因环境略有差异）：

str_list列表内存: 61.46 MB
same_item_str_list列表内存: 8.06 MB
num_list列表内存: 38.57 MB
same_item_num_list列表内存: 8.06 MB

可以看到，四个列表的内存占用差异巨大：存储不同字符串的str_list占用 61.46MB，存储不同整数的num_list占用 38.57MB，而存储相同字符串和相同数字的列表都只占用约 8MB 内存。为什么同样是存储一百万条数据，内存占用会相差这么大呢？为什么和我们的根据理论猜测的占用大小不一样呢？这需要先从数据的理论存储与实际存储差异说起。

2. 理论存储与实际存储的差异

我们常说 “每个 64 位整数占用 8 字节”“每个字符占用 1 字节”，这是硬件层面的理论存储需求，但在 Python 中，由于对象模型的设计，实际存储开销会远高于理论值。

2.1 64位整数的存储差异

• 理论值（8 字节）：指在硬件和底层编程语言（如 C 语言）中，存储一个 64 位二进制数字所需的最小空间，仅包含数值本身，没有额外信息。
• Python 实际值（28 字节以上）：Python 中的整数是对象，其结构PyIntObject（在 CPython 源码中实际名为PyLongObject，整数对象统一使用长整型结构）包含：
  • 引用计数（8 字节）：跟踪对象被引用的次数，用于垃圾回收
  • 类型指针（8 字节）：标识该对象是整数类型（指向PyLong_Type）
  • 长度字段（8 字节）：记录整数占用的位数组长度（对于小整数固定为 1）
  • 数值数据（4 字节起）：存储实际的整数数值（以位数组形式存储，小整数至少占用 4 字节对齐空间）
    这些结构字段总和为 8+8+8+4=28 字节，因此即使是最小的整数，在 Python 中也需要 28 字节内存，是理论值的 3.5 倍。

2.2 短字符串的存储差异

• 理论值（字符数 ×1 字节）：在 ASCII 编码中，每个字符占用 1 字节，一个 8 字符的字符串理论上只需 8 字节。
• Python 实际值（50 字节左右）：Python 的字符串对象PyUnicodeObject包含：
  • 引用计数（8 字节）和类型指针（8 字节）：基础对象元数据
  • 字符串长度（8 字节）：记录字符数量
  • 哈希值（8 字节）：用于快速比较和字典查找
  • 编码标志位（4 字节）：记录字符串使用的编码格式（如 ASCII、UTF-8 等）
  • 字符数据及内存对齐（8 字符 ×1 字节 + 4 字节对齐填充）：实际字符存储需要按 8 字节对齐，8 个字符本需 8 字节，但为满足内存对齐要求会填充 4 字节
  • 额外内存开销：Python 内存分配器会为小对象添加 4-8 字节的管理信息
    以 8 字符的 “item” 字符串为例，元数据（36 字节）+ 字符数据（8 字节）+ 对齐填充（4 字节）+ 分配器开销（2 字节）≈50 字节，因此实际内存是理论值的 6 倍多。
    这种理论与实际的差异，是导致列表内存 “膨胀” 的基础原因。当存储大量元素时，每个元素的额外开销会累积成巨大的内存差异。

3. 列表的内存存储本质

了解了整数和字符串的理论存储和实际存储差异，我们就可以开始学习列表的内存存储了。Python 列表本质上是指针数组，它存储的不是元素本身，而是元素对象在内存中的地址（指针）。在 64 位系统中，每个指针固定占用 8 字节，因此：

• 无论列表中的元素是什么类型，一个包含 100 万个元素的列表，其指针数组本身的内存固定为 8MB（1000000×8 字节）。
• 列表的总内存 = 指针数组内存 + 所有元素对象的内存总和。
  这就解释了为什么same_item_str_list和same_item_num_list的内存都在 8MB 左右 —— 它们的指针数组占用 8MB，所有指针指向相同的内存地址，因为元素对象只有一个，所以元素对象的内存几乎可以忽略不计。而str_list和num_list内存飙升的原因，正是元素对象的内存开销很大。

3.1 相同元素列表内存少的核心原因：对象复用

当列表中的元素完全相同时（如same_item_str_list全是 “item”，same_item_num_list全是 0），Python 会复用同一个对象，避免重复创建，从而大幅减少内存开销。

3.1.1 小整数的缓存复用机制

Python 对小整数（通常是 -5 到 256 之间） 采用预创建和缓存机制：这些整数在 Python 启动时就被提前创建，并存入全局缓存池，后续使用时直接复用，不会重复分配内存。

• 在same_item_num_list = [0 for i in range(1000000)]中，所有元素都是 0，而 0 属于小整数，会被全局缓存复用。
• 整个列表中，所有指针都指向同一个 0 对象，因此元素对象的内存只需存储1 个 0 的内存（约 28 字节）。
• 总内存 = 指针数组（8MB）+1 个 0 对象内存（可忽略）≈8MB（与实测的 8.06MB 一致）。
  这种机制极大提高了小整数的使用效率，尤其在循环计数、状态标记等场景中，避免了频繁创建和销毁整数对象的开销。

3.1.2 字符串的驻留（Intern）机制

Python 会对短字符串、标识符类字符串进行 “驻留”（Intern）处理：相同的字符串会被存储在全局字符串池中，后续使用时直接复用，不会重复创建新对象。

• 在same_item_str_list = [f"item" for i in range(1000000)]中，所有元素都是 “item”，这是一个短字符串且符合标识符规则（字母组成），会被自动驻留。
• 整个列表中，所有指针都指向同一个 “item” 对象，元素对象的内存只需存储1 个 “item” 的内存（约 50 字节）。
• 总内存 = 指针数组（8MB）+1 个 “item” 对象内存（可忽略）≈8MB（与实测的 8.06MB 一致）。
  字符串驻留机制主要用于优化程序中频繁出现的相同字符串，如变量名、关键字、常量字符串等，减少内存浪费和字符串比较的时间开销。

3.2 不同元素列表内存高的原因：对象重复创建

当列表中的元素不同时（如str_list和num_list），每个元素都是独立的新对象，需要为每个元素分配单独的内存，导致总内存剧增。

3.2.1 不同整数的内存开销

num_list = [i for i in range(1000000)]中，元素是 0 到 999999：

• 其中 0 到 256 是小整数，会被缓存复用，但 257 到 999999 是大整数，每个大整数都是独立的新对象。
• 每个 Python 整数对象（尤其是大整数）的内存开销约 28 字节（包含引用计数、类型指针等元数据）。
• 总内存 = 指针数组（8MB）+ 约 999744 个大整数对象内存（999744×28 字节≈27MB）≈35MB（与实测的 38.57MB 接近，差异来自小整数缓存和内存对齐）。
  大整数没有缓存机制，每个大整数都需要单独分配内存，这就是num_list内存比相同元素数字列表高的原因。

3.2.2 不同字符串的内存开销

str_list = [f"item_{i}" for i in range(1000000)]中，每个元素是不同的字符串（“item_0” 到 “item_999999”）：

• 这些字符串都是动态生成的不同内容，不会被驻留复用，每个都是独立的新字符串对象。
• 每个短字符串对象的内存开销约 50-60 字节（包含元数据和字符数据）。
• 总内存 = 指针数组（8MB）+100 万个独立字符串对象内存（1000000×50 字节≈48MB）≈56MB（与实测的 61.46MB 接近，差异来自字符串长度不同和元数据开销）。
  动态生成的不同字符串无法被驻留机制复用，每个字符串都需要单独存储元数据和字符数据，导致内存开销远高于相同元素的字符串列表。

4. 内存占用对比分析

列表类型	指针数组内存（固定）	元素对象内存（变量）	总内存	内存差异原因
same_item_num_list	8MB	28 字节（1 个 0 对象）	8.06MB	小整数缓存复用，元素内存可忽略
num_list	8MB	≈27MB（约 99 万个大整数）	38.57MB	大整数无缓存，每个都是新对象
same_item_str_list	8MB	50 字节（1 个 “item” 对象）	8.06MB	字符串驻留复用，元素内存可忽略
str_list	8MB	≈48MB（100 万个不同字符串）	61.46MB	动态字符串无驻留，每个都是新对象

5. 优化建议：利用对象复用减少内存开销

了解了 Python 的对象复用机制后，我们可以采取以下策略优化列表内存占用：

1. 复用小整数和短字符串：在需要存储大量重复元素的场景中，尽量使用小整数（-5 到 256）和可驻留的短字符串，避免动态生成不同的元素。
2. 使用数据结构优化重复元素存储：对于包含大量重复元素的列表，可使用array模块或 Pandas 的category类型，这些结构会自动复用重复元素，减少内存开销。
3. 避免无意义的对象创建：在循环中避免重复创建相同的对象，例如将[f"abcdefghijklmnopqrstuvwxyz" for i in range(1000000)]改为item = "abcdefghijklmnopqrstuvwxyz"; [item for i in range(1000000)]，确保元素对象只创建一次。
4. 针对大整数和长字符串的优化：对于大量大整数，可考虑使用 NumPy 数组存储；对于大量字符串，可使用 Pandas 的StringDtype或category类型，利用其内置的重复元素压缩机制。

6. 总结

Python 列表的内存占用差异主要来自元素对象的复用情况：相同元素的列表通过小整数缓存和字符串驻留机制复用对象，内存开销主要来自指针数组；而不同元素的列表需要为每个元素创建独立对象，每个对象的元数据开销累积导致内存飙升。

在实际开发中，当需要存储大量数据时，应充分利用 Python 的对象复用机制，选择合适的数据结构，避免无意义的对象重复创建。通过合理设计数据存储方式，既能减少内存占用，也能提高程序运行效率。