Python如何释放内存？深入解读对象销毁与垃圾回收机制13

你好，我的编程伙伴们！我是你们的中文知识博主。今天，我们要揭开一个Python编程中常被误解的面纱：那就是关于“删除对象”这件事。很多初学者，特别是从C++等语言转过来的朋友，可能会习惯性地去寻找一个像`delete`操作符那样可以直接销毁对象的机制。然而，在Python的世界里，事情并非如此简单粗暴。事实上，Python在内存管理方面有着一套优雅而智能的自动化系统，它极大地解放了我们程序员的双手。

那么，当我们在Python中说“删除对象”时，我们到底在删除什么？Python又是如何确保不再需要的对象能够被妥善处理，并释放它们所占用的内存呢？今天，我们就来深入剖析Python的对象生命周期、核心的引用计数机制，以及强大的垃圾回收器。

一、Python中“删除对象”的真正含义：删除引用，而非直接销毁

首先，我们要纠正一个核心观念：在Python中，你通常不会“直接删除”一个对象。Python中的变量名（或者说标识符）只是对内存中对象的“引用”（reference），而不是对象本身。你可以把对象想象成一个实体，而变量名则是指向这个实体的标签。

当我们执行`x = some_object`时，我们实际上是创建了一个名为`x`的标签，并将它贴在了`some_object`这个实体上。如果稍后我们执行`y = x`，那么`y`就成了`some_object`的第二个标签。此时，`some_object`有了两个引用。

“删除对象”的真实含义，往往是“删除一个或多个指向该对象的引用”。当一个对象的所有引用都被删除，或者说没有任何标签再指向它时，Python的内存管理机制就会认为这个对象是“垃圾”，并在适当的时候将其从内存中清除，从而释放其占用的资源。

二、核心机制一：引用计数 (Reference Counting)

引用计数是Python最基本、也是最主要的内存管理策略。每个Python对象都带有一个引用计数器，记录着有多少个引用指向它。

1. 引用计数的增减

当发生以下情况时，对象的引用计数会增加：

将对象赋值给一个新变量：`a = my_object`
将对象作为参数传递给函数：`my_function(my_object)`
将对象放入一个容器（如列表、元组、字典等）：`(my_object)`
对象作为函数返回值：`return my_object`

当发生以下情况时，对象的引用计数会减少：

变量离开了作用域（例如函数执行完毕）：函数内部创建的局部变量引用计数会减少。
使用`del`关键字删除变量引用：`del a`
对象从容器中移除：`(my_object)` 或 `del my_list[0]`
变量被重新赋值：`a = another_object`，此时`my_object`的引用计数减少，`another_object`的引用计数增加。

我们可以使用`sys`模块的`getrefcount()`函数来查看对象的引用计数（注意：`getrefcount()`会临时增加一次引用，因为它自己也会引用对象）。

import sys
a = [1, 2, 3]
print((a)) # 2 (a引用一次，getrefcount自身引用一次)
b = a
print((a)) # 3 (a, b各引用一次，getrefcount自身引用一次)
del b
print((a)) # 2 (a引用一次，getrefcount自身引用一次)
del a # 此时对象[1, 2, 3]的引用计数降为0，将被回收
# print((a)) # 这里会报错，因为a变量已不存在

2. 对象的“销毁”时机

一旦对象的引用计数降为零，就意味着没有任何变量再指向这个对象，Python解释器会立即（或几乎立即）回收这个对象所占用的内存。此时，如果对象定义了`__del__()`方法（析构器），这个方法就会被自动调用。

`__del__()`方法允许对象在被销毁前执行一些清理工作，例如关闭文件句柄、网络连接等。然而，请注意，`__del__()`方法的使用需要非常小心，因为它在循环引用等复杂情况下可能会导致不可预测的行为，甚至阻止对象被正确回收。在大多数情况下，Python推荐使用`with`语句（上下文管理器）来管理资源，以确保资源在离开作用域时被及时、可靠地清理，这比依赖`__del__()`更加安全和推荐。

三、核心机制二：垃圾回收 (Garbage Collection - GC)

引用计数机制虽然高效，但它有一个致命的弱点：无法处理“循环引用”（circular references）。

1. 循环引用的问题

考虑以下场景：

class Node:
def __init__(self, value):
= value
= None
= None
a = Node('A')
b = Node('B')
= b
= a
del a
del b

即使我们执行了`del a`和`del b`，理论上`Node('A')`和`Node('B')`的引用计数应该归零，但实际上，``仍然引用着`b`，``仍然引用着`a`。这意味着这两个对象互相持有对方的引用，它们的引用计数永远不会降到零。结果就是，这两个对象会一直占据内存，造成内存泄漏。

2. Python的垃圾回收器

为了解决循环引用问题，Python引入了独立的垃圾回收器（Garbage Collector，简称GC）。Python的GC采用“分代回收”（Generational Garbage Collection）策略，并结合了“标记-清除”（Mark-and-Sweep）算法。

标记-清除算法

GC会在特定时机运行，它主要做两件事：

标记 (Mark)： 从一组根对象（如全局变量、活动栈帧中的局部变量等）开始，遍历所有可达对象，并把它们标记为“活动的”或“可达的”。
清除 (Sweep)： 遍历堆中的所有对象，如果发现某个对象没有被标记为活动状态（即它是不可达的垃圾），那么就将其回收。在清除阶段，它也能识别并回收那些因循环引用而无法通过引用计数回收的对象。

分代回收

研究发现，新创建的对象往往很快就会变得不可达（短生命周期），而存活时间长的对象往往会继续存活很长时间（长生命周期）。分代回收正是基于这个思想：

0代 (Generation 0)： 新创建的对象都位于0代。GC会频繁地检查这一代的对象。
1代 (Generation 1)： 在0代GC中存活下来的对象会被提升到1代。GC检查1代的频率较低。
2代 (Generation 2)： 在1代GC中存活下来的对象会被提升到2代。GC检查2代的频率最低。

这种策略大大提高了GC的效率，因为它避免了频繁地检查那些很可能已经死亡或很可能长期存活的对象。

3. 何时触发垃圾回收？

Python的GC是自动运行的，它有自己的触发机制，通常是当某一“代”中新分配的对象数量达到某个阈值时。你也可以通过`gc`模块手动控制或查询GC的状态：

import gc
# 启用垃圾回收器
()
# 禁用垃圾回收器
()
# 手动触发一次垃圾回收
()
# 获取垃圾回收器的阈值和统计信息
print(gc.get_threshold()) # (700, 10, 10) 默认阈值：0代700个对象，1代10次0代回收后，2代10次1代回收后
print(gc.get_count()) # (0代对象数，1代对象数，2代对象数)

在大多数情况下，我们无需手动干预GC，让Python自动管理即可。

四、`del` 关键字的真正作用

回到`del`关键字，它常常被误解为直接“删除”对象，但通过前面的解释，我们现在清楚了它的实际功能：

删除变量名与对象的绑定： `del x`只是解除了变量名`x`和它所引用的对象之间的绑定关系。这意味着`x`将不再指向那个对象。
减少引用计数： 当`del x`执行后，如果`x`是该对象的唯一引用，那么该对象的引用计数就会降为零，从而触发引用计数机制的内存回收。
可用于容器： `del`也可以用于删除列表中的元素（`del my_list[index]`）或字典中的键值对（`del my_dict[key]`），同样是移除引用并减少对应元素的引用计数。

一个重要的误区是：`del`并不会立即调用对象的`__del__()`方法。`__del__()`方法的调用时机是对象的引用计数降为零，或GC回收了该对象之后。`del`仅仅是减少引用计数的一个手段。

class MyObject:
def __init__(self, name):
= name
print(f"Object {} created.")
def __del__(self):
print(f"Object {} is being destroyed.")
obj1 = MyObject("A")
obj2 = obj1 # obj1和obj2都引用"A"
del obj1 # 此时，"A"的引用计数从2变为1，__del__不会被调用
print("--- After del obj1 ---")
del obj2 # 此时，"A"的引用计数从1变为0，__del__才会被调用
print("--- After del obj2 ---")

运行上述代码，你会发现`"Object A is being destroyed."`这条消息只会在`del obj2`之后才出现，这正是因为在`del obj2`之前，对象`MyObject("A")`的引用计数仍为1（被`obj2`引用），并没有归零。

五、何时需要关注对象“删除”？

在绝大多数Python编程场景中，我们无需手动去“删除”对象或释放内存。Python的自动化机制已经做得足够好。然而，在以下几种情况，了解这些机制会非常有帮助：

资源管理： 当你的对象持有操作系统资源，如文件句柄、网络套接字、数据库连接等时，确保这些资源能够被及时关闭是至关重要的。Python推荐使用`with`语句（上下文管理器），它能保证无论代码块正常执行还是发生异常，资源的`__exit__`方法都会被调用，从而进行清理。这是比依赖`__del__()`更健壮、更推荐的方式。
性能调优和内存优化： 尽管Python会自动管理内存，但在处理海量数据或长时间运行的服务时，如果出现内存占用过高或内存泄漏（通常是由于不经意的循环引用或未关闭的资源），就需要借助`gc`模块、`()`以及内存分析工具（如`memory_profiler`）来诊断问题。
理解Python底层： 对引用计数和垃圾回收机制的理解，能让你更好地编写高效、健壮的Python代码，并解决一些深层次的问题。

六、总结与最佳实践

通过今天的深入探讨，我们应该对Python的对象“删除”和内存管理有了更清晰的认识：

Python主要通过引用计数来管理内存。当对象的引用计数降为零时，对象立即被回收。
垃圾回收器 (GC) 作为补充，专门处理引用计数无法解决的循环引用问题，采用分代回收和标记-清除算法。
`del`关键字的真正作用是解除变量名与对象的绑定，从而可能减少对象的引用计数，但它不直接销毁对象，也不保证立即调用`__del__()`方法。
对于持有外部资源的对象，优先使用`with`语句（上下文管理器）来确保资源的及时释放，而不是依赖`__del__()`。
在日常编程中，信任Python的自动内存管理机制，避免过度干预。专注于编写清晰、正确的业务逻辑，让Python处理底层的内存细节。

希望这篇文章能帮助你更好地理解Python的内存管理奥秘。下次当你想“删除对象”时，请记住，你更多的是在管理“引用”，而Python的智慧会为你打理剩下的事情。感谢阅读，我们下期再见！

2026-03-10

下一篇：高中生Python编程实战：从趣味工具到AI入门，项目式学习助你玩转代码世界！