当前位置: 首页 > news >正文

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

文章目录

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


在 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_listsame_item_num_list的内存都在 8MB 左右 —— 它们的指针数组占用 8MB,所有指针指向相同的内存地址,因为元素对象只有一个,所以元素对象的内存几乎可以忽略不计。而str_listnum_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_listnum_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_list8MB28 字节(1 个 0 对象)8.06MB小整数缓存复用,元素内存可忽略
num_list8MB≈27MB(约 99 万个大整数)38.57MB大整数无缓存,每个都是新对象
same_item_str_list8MB50 字节(1 个 “item” 对象)8.06MB字符串驻留复用,元素内存可忽略
str_list8MB≈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 的StringDtypecategory类型,利用其内置的重复元素压缩机制。

6. 总结

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

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

http://www.dtcms.com/a/301894.html

相关文章:

  • 第4章唯一ID生成器——4.2 单调递增的唯一ID
  • 【Android】卡片式布局 滚动容器ScrollView
  • Go语法入门:变量、函数与基础数据类型
  • 飞算科技重磅出品:飞算 JavaAI 重构 Java 开发效率新标杆
  • JAVA后端开发——用 Spring Boot 实现定时任务
  • 【Spring】Spring Boot启动过程源码解析
  • 鸿蒙打包签名
  • HarmonyOS 6 云开发-用户头像上传云存储
  • 前端工程化常见问题总结
  • Windows|CUDA和cuDNN下载和安装,默认安装在C盘和不安装在C盘的两种方法
  • AI技术革命:产业重塑与未来工作范式转型。
  • 深入解析MIPI C-PHY (四)C-PHY物理层对应的上层协议的深度解析
  • 齐护Ebook科技与艺术Steam教育套件 可图形化micropython Arduino编程ESP32纸电路手工
  • 湖南(源点咨询)市场调研 如何在行业研究中快速有效介入 起头篇
  • Triton编译
  • 【n8n教程笔记——工作流Workflow】文本课程(第一阶段)——5.5 计算预订订单数量和总金额 (Calculating booked orders)
  • Rouge:面向摘要自动评估的召回导向型指标——原理、演进与应用全景
  • 分表分库与分区表
  • Android启动时间优化大全
  • 蛋白质反向折叠模型-ProteinMPNN安装教程
  • 学习日志20 python
  • 【unitrix】 6.18 二进制小数特质(t_decimal.rs)
  • EPOLLET 边缘触发模式深度解析
  • 抗辐照芯片在低轨卫星星座CAN总线通讯及供电系统的应用探讨
  • vue3的一些浅显用法
  • Day06–哈希表–242. 有效的字母异位词,349. 两个数组的交集,202. 快乐数,1. 两数之和
  • 浙大公开课—基于深度学习的特征匹配与姿态估计
  • (补题)拼图游戏
  • EPOLLIN事件的详细解析
  • 【时时三省】(C语言基础)指针数组和多重指针