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

文章目录

[1. 问题引入：列表存储的内存 "膨胀"](#1. 问题引入：列表存储的内存 "膨胀")
[2. 理论存储与实际存储的差异](#2. 理论存储与实际存储的差异)
- [2.1 64位整数的存储差异](#2.1 64位整数的存储差异)
- [2.2 短字符串的存储差异](#2.2 短字符串的存储差异)
[3. 列表的内存存储本质](#3. 列表的内存存储本质)
- [3.1 相同元素列表内存少的核心原因：对象复用](#3.1 相同元素列表内存少的核心原因：对象复用)
- - [3.1.1 小整数的缓存复用机制](#3.1.1 小整数的缓存复用机制)
  - [3.1.2 字符串的驻留（Intern）机制](#3.1.2 字符串的驻留（Intern）机制)
- [3.2 不同元素列表内存高的原因：对象重复创建](#3.2 不同元素列表内存高的原因：对象重复创建)
- - [3.2.1 不同整数的内存开销](#3.2.1 不同整数的内存开销)
  - [3.2.2 不同字符串的内存开销](#3.2.2 不同字符串的内存开销)
[4. 内存占用对比分析](#4. 内存占用对比分析)
[5. 优化建议：利用对象复用减少内存开销](#5. 优化建议：利用对象复用减少内存开销)
[6. 总结](#6. 总结)

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

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

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

python 复制代码

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：

bash 复制代码

uv add pympler

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

python 复制代码

from pympler import asizeof

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)]

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 的对象复用机制后，我们可以采取以下策略优化列表内存占用：

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

6. 总结

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

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