如何使用Python进行内存管理和优化？-Python教程-PHP中文网

Python内存管理基于引用计数和分代垃圾回收，可通过gc模块干预回收行为，但优化核心在于使用高效数据结构、生成器、__slots__及内存分析工具定位瓶颈。

如何使用python进行内存管理和优化？

Python的内存管理主要依赖引用计数和分代垃圾回收，但真正的优化往往需要深入理解数据结构、对象生命周期以及利用专业的分析工具。核心在于识别并解决不必要的内存占用，这通常通过选择更高效的数据结构、使用生成器、合理管理资源以及精确的性能分析来实现。

解决方案：理解Python的引用计数机制和分代垃圾回收器的工作原理。优先使用内存效率更高的数据结构，例如

tuple

登录后复制

代替

list

登录后复制

（当内容固定时），

set

登录后复制

代替

list

登录后复制

（需要快速查找且不关心顺序时），或者专门的库如

numpy

登录后复制

处理大量数值数据。利用

__slots__

登录后复制

减少自定义类实例的内存占用。使用生成器（generators）和迭代器（iterators）处理大型数据集，避免一次性将所有数据加载到内存。善用

with

登录后复制

语句进行资源管理，确保文件、网络连接等资源在不再需要时及时释放。通过

del

登录后复制

关键字手动解除对不再使用对象的引用，尤其是在处理大型对象时。使用

gc

登录后复制

模块进行垃圾回收器的精细控制，例如手动触发回收或禁用/启用回收。利用内存分析工具（如

memory_profiler

登录后复制

objgraph

登录后复制

tracemalloc

登录后复制

）定位内存瓶颈和潜在的内存泄漏。

Python的垃圾回收机制是如何工作的，我们能干预它吗？

说实话，Python的内存管理是一个挺有意思的话题，它不像C/C++那样需要我们手动

malloc

登录后复制

free

登录后复制

，但也绝非完全的“无脑”自动。核心是引用计数，每个对象都有一个引用计数器，当有新的引用指向它时，计数器加一；引用失效时，计数器减一。当计数器归零时，对象占用的内存就会被释放。这个机制简单高效，但它有一个致命弱点：循环引用。比如对象A引用了B，B又引用了A，即使外部没有其他引用了，它们的引用计数永远不会归零，这就会导致内存泄漏。

为了解决循环引用问题，Python引入了分代垃圾回收器。它会定期扫描那些引用计数不为零但实际上已经无法访问的对象。这个回收器将对象分为三代（0、1、2代），新创建的对象都在0代。如果0代对象在一次垃圾回收后仍然“存活”，它就会被提升到1代；1代对象存活后被提升到2代。越老的代，被扫描的频率越低，因为经验表明，大多数对象都是短命的。

我们当然可以干预垃圾回收。Python提供了

gc

登录后复制

模块，你可以用

gc.disable()

登录后复制

关闭自动垃圾回收，用

gc.enable()

登录后复制

重新开启。

gc.collect()

登录后复制

可以手动触发一次垃圾回收。

gc.set_threshold(threshold0, threshold1, threshold2)

登录后复制

允许你设置触发不同代回收的阈值。不过，坦白讲，大多数情况下，我们真的不应该去手动干预太多。Python的默认策略通常已经足够好。过度干预反而可能引入性能问题，或者更糟糕地，掩盖了真正的问题——比如你可能只是在不恰当地持有大量对象引用。在我看来，理解它的工作原理，更多是为了在出现内存问题时，能更好地诊断和定位问题，而不是日常去调优。

立即学习“Python免费学习笔记（深入）”；

除了基础的垃圾回收，还有哪些实用的Python内存优化技巧？

除了对垃圾回收机制的理解，实际开发中有很多更直接、更实用的内存优化技巧。我个人觉得，这些技巧往往比去调

gc

登录后复制

参数更有效。

一个很经典的例子是使用

__slots__

登录后复制

。当你定义一个类时，默认情况下，每个实例都会有一个

__dict__

登录后复制

字典来存储它的属性。这个字典本身就占用内存，而且查找属性也会有额外的开销。如果你知道一个类的实例会有哪些固定的属性，就可以在类中定义

__slots__

登录后复制

。

class MyClassWithDict:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class MyClassWithSlots:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

登录后复制

使用

__slots__

登录后复制

后，实例不再拥有

__dict__

登录后复制

，属性直接存储在实例的内存块中，这能显著减少内存占用，尤其是在创建大量小对象时。但要注意，

__slots__

登录后复制

也会带来一些限制，比如你不能再动态添加属性，也不能使用多重继承（如果父类没有定义

__slots__

登录后复制

）。

另一个非常重要的概念是生成器（Generators）。想象一下你需要处理一个包含数百万行的大文件，或者一个巨大的数据流。如果你把所有内容一次性读入一个

list

登录后复制

，内存肯定会爆炸。生成器允许你“按需”生成数据，每次只在需要时计算并返回一个值，而不是一次性生成所有值。

# 内存效率低：一次性加载所有数据
def read_large_file_list(filepath):
    with open(filepath, 'r') as f:
        return f.readlines()

# 内存效率高：使用生成器按行读取
def read_large_file_generator(filepath):
    with open(filepath, 'r') as f:
        for line in f:
            yield line

登录后复制

当你调用

read_large_file_generator()

登录后复制

时，它不会立即读取整个文件，而是返回一个生成器对象。只有当你迭代它（例如在

for

登录后复制

循环中）时，它才会逐行读取文件并

yield

登录后复制

一行。这对于处理大数据流来说是救命稻草。

此外，选择正确的数据结构也至关重要。

list

登录后复制

是动态数组，

tuple

登录后复制

是不可变数组。如果你的元素集合是固定不变的，用

tuple

登录后复制

通常比

list

登录后复制

更省内存。

set

登录后复制

和

dict

登录后复制

的底层实现是哈希表，对于快速查找非常有效，但它们也比

list

登录后复制

或

tuple

登录后复制

占用更多内存。对于同构的数值数据，

array.array

登录后复制

模块提供的数组对象比标准Python列表更紧凑，因为它直接存储C语言类型的数据。而对于科学计算，

numpy

登录后复制

数组更是无可匹敌，它将数据存储在连续的内存块中，并利用C语言级别的优化，内存效率和计算速度都远超Python原生数据结构。

易森网络企业版

如果您是新用户，请直接将本程序的所有文件上传在任一文件夹下，Rewrite 目录下放置了伪静态规则和筛选器，可将规则添加进IIS，即可正常使用，不用进行任何设置；(可修改图片等)默认的管理员用户名、密码和验证码都是：yeesen系统默认关闭，请上传后登陆后台点击“核心管理”里操作如下:进入“配置管理”中的&ld

查看详情

如何准确地诊断Python程序的内存使用情况和潜在泄漏？

要真正优化内存，首先得知道哪里出了问题。盲目优化往往事倍功半。诊断内存问题，我主要会用到几个工具和方法。

首先是

sys.getsizeof()

登录后复制

，这是一个非常基础但实用的函数，可以用来获取单个对象在内存中占用的字节数。

import sys

my_list = [1, 2, 3]
print(f"Size of my_list: {sys.getsizeof(my_list)} bytes")

my_dict = {'a': 1, 'b': 2}
print(f"Size of my_dict: {sys.getsizeof(my_dict)} bytes")

登录后复制

但这只告诉你对象本身的大小，不包括它引用的其他对象。比如一个列表的大小，不包含列表中元素的大小。

更强大的工具是

memory_profiler

登录后复制

。这是一个第三方库，可以通过

pip install memory_profiler

登录后复制

安装。它允许你以装饰器的方式，对函数进行逐行内存使用分析。

# from memory_profiler import profile

# @profile
# def my_function():
#     a = [1] * (10 ** 6)
#     b = [2] * (2 * 10 ** 7)
#     del b
#     return a

# if __name__ == '__main__':
#     my_function()

登录后复制

当你运行带有

@profile

登录后复制

装饰器的脚本时，它会输出每行代码执行后内存的变化，这对于找出内存峰值和内存增长点非常有用。

另一个我发现非常有用的库是

objgraph

登录后复制

。它能生成对象的引用图，这对于可视化和诊断循环引用引起的内存泄漏特别有效。你可以用它来查看哪些对象被谁引用着，形成一个直观的图形。

# import objgraph
# import gc

# class Node:
#     def __init__(self, value):
#         self.value = value
#         self.next = None

# n1 = Node(1)
# n2 = Node(2)
# n3 = Node(3)
# n1.next = n2
# n2.next = n3
# n3.next = n1 # Create a circular reference

# del n1, n2, n3
# gc.collect()

# objgraph.show_backrefs([obj for obj in gc.get_objects() if isinstance(obj, Node)], filename='circular_ref.png')

登录后复制

这段代码（如果运行）会尝试生成一个图，显示

Node

登录后复制

对象的引用链，帮助你看到那个顽固的循环引用。

Python 3.4及更高版本还内置了

tracemalloc

登录后复制

模块，它是一个非常强大的工具，可以跟踪内存分配的来源。你可以用它来查看哪些文件和行号分配了最多的内存，甚至可以比较两个时间点的内存分配差异，从而找出内存增长的原因。

import tracemalloc

tracemalloc.start()

# ... Your code that allocates memory ...
data = [str(i) * 100 for i in range(10000)]

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Top 10 ]")
for stat in top_stats[:10]:
    print(stat)

tracemalloc.stop()

登录后复制