Python `sys.getsizeof` 与 `pympler`：深入分析对象内存占用

好的，各位观众老爷们，欢迎来到今天的“内存大作战”讲座！今天咱们要扒一扒Python对象的小裤衩，啊不，是内存占用！别害怕，咱们不用显微镜，用的是Python自带的sys.getsizeof和第三方神器pympler。

开场白：你的对象，它真的“瘦”吗？

作为Python程序员，我们每天都在创造对象。列表、字典、类实例……它们就像我们养的宠物，日渐壮大，悄无声息地吞噬着我们的内存。你真的了解你的“宠物”有多重吗？ 也许你觉得一个简单的整数或者字符串没什么大不了的，但成千上万个累积起来呢？内存泄漏、程序崩溃，分分钟教你做人。

所以，搞清楚Python对象的内存占用，是每个有追求的程序员的必修课。准备好了吗？咱们开始！

第一回合：sys.getsizeof——初窥门径

Python内置的sys.getsizeof()函数，就像一个简单的体重秤，能告诉你一个对象直接占用的内存大小，单位是字节。

import sys

# 测量一个整数
num = 10
size_num = sys.getsizeof(num)
print(f"整数 {num} 的大小：{size_num} 字节")

# 测量一个字符串
text = "Hello, world!"
size_text = sys.getsizeof(text)
print(f"字符串 '{text}' 的大小：{size_text} 字节")

# 测量一个列表
my_list = [1, 2, 3, 4, 5]
size_list = sys.getsizeof(my_list)
print(f"列表 {my_list} 的大小：{size_list} 字节")

# 测量一个字典
my_dict = {"a": 1, "b": 2, "c": 3}
size_dict = sys.getsizeof(my_dict)
print(f"字典 {my_dict} 的大小：{size_dict} 字节")

运行一下，你会发现：

• 即使是简单的整数，也占用了不少空间（通常是28字节）。
• 字符串的大小会随着内容增长，但并非线性增长（后面会解释）。
• 列表和字典的大小，即使为空，也有一个初始值。

sys.getsizeof的局限性

sys.getsizeof很方便，但它只能告诉你对象自身的大小，不包括它引用的其他对象。就像你只称了宠物的体重，没算上它吃的食物的重量。

import sys

# 列表包含其他对象
list_of_lists = [[1, 2], [3, 4]]
size_outer_list = sys.getsizeof(list_of_lists)
print(f"外层列表的大小：{size_outer_list} 字节")

# 内层列表的大小
size_inner_list1 = sys.getsizeof(list_of_lists[0])
size_inner_list2 = sys.getsizeof(list_of_lists[1])
print(f"第一个内层列表的大小：{size_inner_list1} 字节")
print(f"第二个内层列表的大小：{size_inner_list2} 字节")

total_size = size_outer_list + size_inner_list1 + size_inner_list2
print(f"总大小（粗略估计）：{total_size} 字节")

# 实际上，外层列表只存储了内层列表的引用，而不是内层列表本身。

上面的例子中，sys.getsizeof(list_of_lists)只计算了外层列表的大小，也就是存储两个内层列表引用所需的空间。要计算所有元素的总大小，需要手动遍历列表，逐个计算。这很麻烦，不是吗？

第二回合：pympler——深入挖掘

pympler闪亮登场！它是一个功能强大的第三方库，专门用于分析Python对象的内存占用。它提供了多种工具，可以帮助我们更准确地了解对象的内存使用情况。

安装pympler

pip install pympler

pympler.asizeof.asizeof：更精准的体重秤

pympler.asizeof.asizeof()函数可以递归地计算一个对象及其所有引用的对象的大小。就像给宠物称重，同时算上它吃的食物的重量，更准确！

from pympler import asizeof

# 列表包含其他对象
list_of_lists = [[1, 2], [3, 4]]
total_size = asizeof.asizeof(list_of_lists)
print(f"列表及其所有引用的对象的总大小：{total_size} 字节")

# 比较 sys.getsizeof
import sys
size_outer_list = sys.getsizeof(list_of_lists)
print(f"sys.getsizeof 测量到的外层列表大小：{size_outer_list} 字节")

可以看到，asizeof.asizeof()的结果比sys.getsizeof()大得多，因为它包含了内层列表的大小。

pympler.muppy：内存追踪器

pympler.muppy模块可以帮助我们追踪Python进程中的所有对象。它就像一个内存追踪器，可以告诉我们有哪些类型的对象占用了最多的内存。

from pympler import muppy, summary

# 获取所有Python对象
all_objects = muppy.get_objects()

# 打印对象数量
print(f"当前Python进程中共有 {len(all_objects)} 个对象")

# 按类型汇总对象
summary_by_type = summary.summarize(all_objects)

# 打印汇总信息
summary.print_(summary_by_type)

运行结果会显示各种类型的对象（例如int、str、list、dict、function等）的数量和总大小。这可以帮助我们找到内存占用最多的对象类型，从而进行优化。

pympler.tracker：对象生命周期追踪

pympler.tracker模块可以帮助我们追踪特定对象的生命周期，查看它们何时被创建、何时被销毁。这对于调试内存泄漏问题非常有用。

from pympler import tracker

# 创建一个追踪器
tr = tracker.SummaryTracker()

# 执行一些操作
my_list = [1, 2, 3]
my_dict = {"a": 1, "b": 2}

# 获取当前内存使用情况
tr.print_diff()

# 删除对象
del my_list
del my_dict

# 再次获取内存使用情况
tr.print_diff()

tracker.print_diff()会显示两次调用之间内存的变化情况，包括创建和销毁的对象。

进阶：深入剖析字符串的内存占用

之前提到，字符串的大小并非线性增长。这是因为Python的字符串使用了intern机制。

Intern机制

Intern机制是一种字符串驻留技术，用于共享相同的字符串对象，从而节省内存。当创建一个新的字符串时，Python会先检查是否已经存在相同的字符串对象。如果存在，则直接返回已存在的对象，而不是创建一个新的对象。

import sys

# 创建相同的字符串
str1 = "hello"
str2 = "hello"

# 检查它们的身份（内存地址）
print(f"str1 的 id: {id(str1)}")
print(f"str2 的 id: {id(str2)}")

# 使用 is 运算符比较身份
print(f"str1 is str2: {str1 is str2}") # True，因为它们指向同一个对象

# 创建不同的字符串
str3 = "hello world"
str4 = "hello world"

# 检查它们的身份
print(f"str3 的 id: {id(str3)}")
print(f"str4 的 id: {id(str4)}")

# 使用 is 运算符比较身份
print(f"str3 is str4: {str3 is str4}") # False，因为它们指向不同的对象

# 手动 intern
import sys
str5 = sys.intern("hello world")
str6 = sys.intern("hello world")

print(f"str5 的 id: {id(str5)}")
print(f"str6 的 id: {id(str6)}")
print(f"str5 is str6: {str5 is str6}") # True, 现在它们指向同一个对象

可以看到，对于短字符串，Python会自动进行intern。对于长字符串，需要手动使用sys.intern()函数。

Intern机制的优缺点

• 优点： 节省内存，提高性能（字符串比较更快）。
• 缺点： 创建字符串时需要额外的检查，可能会降低性能。

表格总结：sys.getsizeof vs pympler.asizeof

特性	sys.getsizeof	pympler.asizeof
计算范围	对象自身的大小	对象及其所有引用的对象的大小
精度	较低，不包括引用的对象	较高，包括引用的对象
速度	较快	较慢，需要递归遍历
适用场景	快速了解对象自身大小，不关心引用的对象	需要准确了解对象及其所有依赖的总大小，例如调试内存泄漏
内置/第三方	内置	第三方库

实战演练：优化内存占用

现在，我们来用pympler分析一个实际的例子，并进行优化。

import sys
from pympler import asizeof

# 创建一个包含大量重复字符串的列表
data = []
for i in range(10000):
    data.append("example string")

# 测量内存占用
size_before = asizeof.asizeof(data)
print(f"优化前，列表大小：{size_before} 字节")

# 使用intern机制优化
interned_data = []
for i in range(10000):
    interned_data.append(sys.intern("example string"))

# 测量优化后的内存占用
size_after = asizeof.asizeof(interned_data)
print(f"优化后，列表大小：{size_after} 字节")

# 比较优化效果
print(f"节省了 {size_before - size_after} 字节")

可以看到，通过使用intern机制，我们大大减少了内存占用。

其他优化技巧

• 使用生成器（Generators）和迭代器（Iterators）： 避免一次性加载大量数据到内存中。
• 删除不再使用的对象： 使用del语句显式删除对象，或者利用with语句管理资源。
• 使用更高效的数据结构： 例如，使用set代替list来存储唯一元素。
• 避免循环引用： 循环引用会导致垃圾回收器无法释放内存。

总结：内存管理，永无止境

今天的“内存大作战”就到这里。我们学习了如何使用sys.getsizeof和pympler来分析Python对象的内存占用，以及一些常用的内存优化技巧。

记住，内存管理是一个持续的过程，需要我们不断学习和实践。希望今天的讲座能帮助你更好地了解你的“宠物”有多重，让你的程序跑得更快、更稳！

下次再见！