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

好的，各位观众老爷，晚上好！欢迎来到“Python对象内存占用大揭秘”特别节目！今天，咱们要聊聊Python里那些看不见摸不着的“内存小秘密”。别怕，咱们不搞枯燥的理论，保证让你听得懂、用得上、还能在小伙伴面前秀一把操作！

一、开场白：你的数据，占了多少地儿？

咱们都知道，Python里一切皆对象。但是，你有没有想过，这些对象在内存里占了多少空间？一个整数，一个字符串，一个列表……它们可不是“免费入住”的，得占用内存这块“黄金地段”。

为什么要知道这个？理由很简单：

优化性能： 如果你的代码占用内存太多，程序运行速度就会变慢，甚至可能导致崩溃。知道哪些对象占用了大量内存，才能有针对性地进行优化。
排查Bug： 有时候，内存泄漏会导致程序运行一段时间后崩溃。了解对象的内存占用，有助于你发现内存泄漏的根源。
更好地理解Python： 深入了解对象的内存占用，能让你对Python的底层机制有更深刻的认识，写出更高效的代码。

那么，问题来了，怎么才能知道一个Python对象占用了多少内存呢？别着急，Python已经为我们准备好了工具！

二、sys.getsizeof()：快速入门，简单粗暴

Python自带的sys模块里有一个getsizeof()函数，它可以告诉你一个对象占用了多少字节的内存。用法非常简单：

import sys

a = 10
b = "Hello, world!"
c = [1, 2, 3, 4, 5]

print(f"整数 a 的大小：{sys.getsizeof(a)} 字节")
print(f"字符串 b 的大小：{sys.getsizeof(b)} 字节")
print(f"列表 c 的大小：{sys.getsizeof(c)} 字节")

运行结果大概是这样：

整数 a 的大小：28 字节
字符串 b 的大小：61 字节
列表 c 的大小：104 字节

看起来很简单，对吧？但是，sys.getsizeof()并没有你想的那么完美。它只能告诉你对象自身的大小，不包括它引用的其他对象的大小。

举个例子：

import sys

a = [1, 2, 3]
b = [a, a, a]  # b 引用了 3 次 a

print(f"列表 a 的大小：{sys.getsizeof(a)} 字节")
print(f"列表 b 的大小：{sys.getsizeof(b)} 字节")

你可能觉得，列表 b 包含了三个 a，所以它的大小应该是 sys.getsizeof(a) 的三倍。但实际上，sys.getsizeof(b) 只会告诉你列表 b 自身的大小，不包括它引用的列表 a 的大小。

所以，sys.getsizeof() 只能作为快速了解对象大小的工具，如果要深入分析对象的内存占用，还需要更强大的武器。

三、pympler：内存分析的瑞士军刀

pympler 是一个强大的Python内存分析工具包，它提供了多种工具，可以帮助你深入了解对象的内存占用情况。

首先，你需要安装 pympler：

pip install pympler

安装好之后，就可以开始使用了。pympler 里有很多模块，咱们重点介绍几个常用的：

asizeof：深入分析对象大小

asizeof 模块可以递归地计算对象及其引用的对象的大小，比 sys.getsizeof() 更精确。

from pympler import asizeof

a = [1, 2, 3]
b = [a, a, a]

print(f"列表 a 的大小：{asizeof.asizeof(a)} 字节")
print(f"列表 b 的大小：{asizeof.asizeof(b)} 字节")

现在，asizeof.asizeof(b) 会告诉你列表 b 自身以及它引用的三个列表 a 的总大小。

asizeof 还有一些高级用法，比如可以排除某些类型的对象：

from pympler import asizeof

class MyClass:
    pass

a = MyClass()
b = [a, 1, "hello"]

print(f"列表 b 的大小（包含 MyClass 实例）：{asizeof.asizeof(b)} 字节")
print(f"列表 b 的大小（排除 MyClass 实例）：{asizeof.asizeof(b, exclude=[MyClass])} 字节")

这个功能在分析复杂对象时非常有用，可以让你专注于你感兴趣的部分。

muppy：追踪所有对象

muppy 模块可以追踪Python进程中的所有对象，并按照类型进行分类。
```
from pympler import muppy, summary

all_objects = muppy.get_objects()
summary_all = summary.summarize(all_objects)
summary.print_(summary_all)
```
这段代码会列出当前Python进程中所有对象的类型以及它们的数量和总大小。

muppy 还可以只追踪特定类型的对象：
```
from pympler import muppy

list_objects = muppy.get_objects(typename='list')
print(f"当前进程中共有 {len(list_objects)} 个列表对象")
```
这个功能可以帮助你找到程序中占用大量内存的特定类型的对象。
tracker：追踪对象生命周期

tracker 模块可以追踪对象的创建和销毁，帮助你发现内存泄漏。
```
from pympler import tracker

tr = tracker.SummaryTracker()

# 你的代码

tr.print_summary()
```
在你的代码前后分别创建一个 SummaryTracker 对象，然后调用 print_summary() 方法，就可以看到对象创建和销毁的统计信息。如果某个类型的对象创建了很多，但是没有被销毁，那就很可能存在内存泄漏。

四、实战演练：优化你的代码

光说不练假把式，咱们来看一个实际的例子，看看如何使用 pympler 来优化代码。

假设你有这样一个函数，它会生成一个很大的列表：

def generate_large_list(n):
    result = []
    for i in range(n):
        result.append(i)
    return result

这个函数很简单，但是当 n 很大时，它会占用大量的内存。咱们可以使用 pympler 来分析一下：

import sys
from pympler import asizeof

def generate_large_list(n):
    result = []
    for i in range(n):
        result.append(i)
    return result

n = 1000000
large_list = generate_large_list(n)

print(f"列表的大小：{sys.getsizeof(large_list)} 字节")
print(f"列表的大小（递归计算）：{asizeof.asizeof(large_list)} 字节")

运行结果会告诉你，这个列表占用了大量的内存。

那么，如何优化呢？一个简单的方法是使用生成器：

def generate_large_list_generator(n):
    for i in range(n):
        yield i

生成器不会一次性生成所有的元素，而是按需生成，可以大大减少内存占用。

import sys
from pympler import asizeof

def generate_large_list_generator(n):
    for i in range(n):
        yield i

n = 1000000
large_list_generator = generate_large_list_generator(n)

# 注意：这里我们没有把生成器转换成列表，而是直接使用它

print(f"生成器的大小：{sys.getsizeof(large_list_generator)} 字节")
print(f"生成器的大小（递归计算）：{asizeof.asizeof(large_list_generator)} 字节")

运行结果会告诉你，生成器占用的内存非常少。

当然，这只是一个简单的例子。在实际开发中，你可能需要分析更复杂的对象，并使用 pympler 提供的更多工具来优化你的代码。

五、sys.getrefcount()：引用计数的世界

虽然 sys.getsizeof 侧重于对象的大小，但理解 Python 的内存管理机制离不开引用计数。 sys.getrefcount(object) 函数可以告诉你一个对象被引用的次数。当一个对象的引用计数降为 0 时，Python 解释器会回收该对象占用的内存。

import sys

a = [1, 2, 3]
print(f"列表 a 的引用计数：{sys.getrefcount(a)}")

b = a
print(f"列表 a 的引用计数：{sys.getrefcount(a)}")

del b
print(f"列表 a 的引用计数：{sys.getrefcount(a)}")

需要注意的是，sys.getrefcount() 的结果可能比你预期的要大，因为它也会计算函数调用时传入的参数的引用。因此，它主要用于理解引用计数的基本原理，而不是精确地跟踪对象的生命周期。

六、一些内存优化的建议

除了使用 pympler 进行分析之外，这里还有一些通用的内存优化建议：

使用生成器： 就像咱们刚才演示的那样，生成器可以按需生成数据，减少内存占用。
使用迭代器： 迭代器和生成器类似，也可以按需访问数据，避免一次性加载大量数据到内存中。
使用适当的数据结构： 不同的数据结构在内存占用和性能方面有不同的特点。选择合适的数据结构可以提高程序的效率。例如，如果你需要频繁地查找元素，可以使用集合（set）或字典（dict），而不是列表（list）。
及时释放不再使用的对象： 虽然Python有垃圾回收机制，但是及时释放不再使用的对象可以帮助减少内存占用。你可以使用 del 语句来删除对象的引用。
避免循环引用： 循环引用会导致对象无法被垃圾回收，从而导致内存泄漏。
使用 __slots__： 对于类，可以使用 __slots__ 来限制实例可以添加的属性，从而减少内存占用。

七、总结：成为内存管理大师

好了，今天的“Python对象内存占用大揭秘”特别节目就到这里了。希望通过今天的学习，你已经掌握了如何使用 sys.getsizeof() 和 pympler 来分析Python对象的内存占用，并了解了一些通用的内存优化建议。

记住，内存管理是优化Python程序性能的关键。只有深入了解对象的内存占用情况，才能写出更高效、更稳定的代码。

最后，送大家一句话：

“内存管理，从我做起！”

感谢大家的收看，咱们下期再见！

附录：常用函数和模块总结

函数/模块	功能
`sys.getsizeof()`	返回对象自身的大小，不包括它引用的其他对象的大小。
`pympler.asizeof`	递归地计算对象及其引用的对象的大小。
`pympler.muppy`	追踪Python进程中的所有对象，并按照类型进行分类。
`pympler.tracker`	追踪对象的创建和销毁，帮助你发现内存泄漏。
`sys.getrefcount()`	返回对象的引用计数。
`del`	删除对象的引用，当对象的引用计数降为 0 时，Python 解释器会回收该对象占用的内存。
`__slots__`	对于类，可以使用 `__slots__` 来限制实例可以添加的属性，从而减少内存占用。

发表回复 取消回复

发表回复取消回复