x = [1,2,3])a = [1,2,3]; b = a 后,a 和 b 指向同一列表对象。此时清除 a(如 del a)仅删除 a 这个名字,列表对象仍被 b 引用,不会被回收。这是理解变量清除的关键前提。
>>> x = [1, 2, 3] # 创建列表对象,引用计数=1
>>> import sys
>>> sys.getrefcount(x) # 实际为2(含临时参数)
2
>>> y = x # 引用+1,计数=2
>>> sys.getrefcount(x)
3
>>> del y # 删除y,引用-1,计数=1
>>> del x # 删除x,引用-1,计数=0 → 对象立即回收
del 是Python的语句而非函数,它仅删除变量名与对象的绑定关系,不直接释放内存。其语法为:del <变量名>。若变量是唯一引用,则触发对象回收;否则仅减少引用计数。
def demo():
x = [1, 2, 3]
print(f"使用中: {x}")
del x # 解除绑定
try:
print(x) # 报错:NameError
except NameError:
print("变量已清除,无法访问")
demo() # 输出:使用中: [1, 2, 3] → 变量已清除,无法访问
a = [1, 2, 3]
b = a
c = a
print(sys.getrefcount(a)) # 输出5(含临时参数)
del a # 仅删除a,对象仍被b、c引用
print(sys.getrefcount(b)) # 输出4
del b # 仅删除b,对象仍被c引用
print(sys.getrefcount(c)) # 输出3
del c # 最后一个引用被删除 → 对象回收
data = {"name": "Alice", "age": 25, "city": "Beijing"}
del data["age"] # 删除键值对,非清除变量
print(data) # {'name': 'Alice', 'city': 'Beijing'}
del 是语句,不是函数!del(x) 在Python中合法但易混淆,因括号仅表示优先级,实际执行 del x。正确写法应为 del x,避免冗余括号。
import math
print(math.pi) # 3.14159...
del math.pi # 删除模块属性(仅限可写属性)
print(hasattr(math, 'pi')) # False
gc 模块负责检测并清理循环引用对象。常用方法:gc.collect() 主动触发回收。
import gc
class Node:
def __init__(self, name):
self.name = name
self.next = None
self.prev = None
# 创建循环引用
a = Node("A")
b = Node("B")
a.next = b
b.prev = a
# 删除引用
del a
del b
# 此时Node对象因循环引用无法被引用计数回收
print(gc.collect()) # 主动回收,输出:2(回收2个对象)
| 函数 | 作用 | 适用场景 |
|---|---|---|
gc.collect() | 手动触发垃圾回收 | 内存紧张时释放循环引用对象 |
gc.disable() | 禁用自动GC | 实时系统需减少GC暂停 |
gc.enable() | 启用自动GC | 恢复默认行为 |
gc.get_stats() | 获取GC统计信息 | 分析内存回收效率 |
import gc
gc.set_threshold(700, 10, 10) # 调整回收阈值
stats = gc.get_stats()
print(f"Generation 0回收次数: {stats[0]['collections']}")
print(f"Generation 0收集对象数: {stats[0]['collected']}")
print(f"当前禁用状态: {gc.isenabled()}")
gc.set_debug(gc.DEBUG_SAVEALL) # 保存所有被回收对象
collected = gc.collect()
for obj in gc.garbage:
print(f"循环引用对象: {type(obj).__name__}, id={id(obj)}")
gc.set_debug(0) # 恢复默认
ob_refcnt。当对象被引用时+1,被解除引用时-1。当计数为0时,对象立即调用 __del__ 并释放内存。这是Python内存管理的核心机制。
import sys
def track_ref(obj):
refs = sys.getrefcount(obj)
print(f"引用计数: {refs}(含临时参数,实际为{refs-1})")
x = [1, 2, 3]
track_ref(x) # 引用计数: 2(x + 临时参数)
y = x
track_ref(x) # 引用计数: 3(x, y, 临时参数)
z = [x]
track_ref(x) # 引用计数: 4(x, y, z[0], 临时参数)
del y, z
track_ref(x) # 引用计数: 2(x, 临时参数)
>>> import gc
>>> gc.get_threshold() # 默认阈值(700, 10, 10)
(700, 10, 10)
# 含义:第0代达700个对象时触发回收;若回收后存活对象≥10,则第1代达10个对象时触发;第2代同理
# 降低第0代阈值,加快回收频率
gc.set_threshold(500, 5, 5)
# 查看当前设置
print(gc.get_threshold()) # (500, 5, 5)
def leak():
large_list = list(range(1000000))
temp = large_list # 临时引用
del large_list
return temp # 返回对象,内存未释放
gc.collect() 仅回收循环引用对象,无法处理引用计数非零的常规对象。必须先用 del 解除绑定,再调用 gc.collect()。
del globals()[var_name] 清除全局变量:
global_var = "data"
print(global_var) # data
del globals()["global_var"]
print(global_var) # NameError
def bad_practice():
data = list(range(10000))
del data # 多余操作:函数结束自动清除
return sum(data) # 错误:已删除变量
def process_large_data():
raw_data = load_large_dataset() # 1GB数据
processed = transform(raw_data)
del raw_data # 显式清除,避免内存峰值
gc.collect() # 触发回收
return processed
# 推荐:局部变量
def process():
temp = compute()
return finalize(temp)
# 不推荐:全局变量
global_temp = None
def process():
global global_temp
global_temp = compute()
return finalize(global_temp)
weakref模块创建弱引用__del__中显式断开循环import weakref
class Node:
def __init__(self, name):
self.name = name
self._next = None
@property
def next(self):
return self._next() if self._next else None
@next.setter
def next(self, value):
self._next = weakref.ref(value) if value else None
class ResourceManager:
def __enter__(self):
self.data = load_data()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
del self.data # 确保资源释放
gc.collect()
with ResourceManager() as rm:
process(rm.data) # 自动清理,避免泄漏
# 避免:创建完整列表
data = [i**2 for i in range(1000000)]
del data # 清除后仍占内存峰值
# 推荐:生成器延迟计算
def squares():
for i in range(1000000):
yield i**2
for sq in squares():
process(sq) # 内存占用恒定
del 是Python的内置语句,用于删除变量名绑定。例如 del x 正确,而 del(x) 虽合法但易混淆(括号仅表示优先级)。切记:它不直接释放内存,仅解除绑定。
del globals()[var_name] 可清除全局变量,但需谨慎:
global_var = "data"
print(global_var)
del globals()["global_var"]
print(global_var) # NameError
更推荐用配置类封装状态,避免全局变量污染。
gc.collect() 仅回收因循环引用导致引用计数非零的对象。常规对象应通过 del 解除绑定,再由Python自动回收。典型场景:
a = [1, 2, 3]
b = a
del a # b仍引用,对象未释放
del b # 此时才真正回收
del语句增强控制力。tracemalloc模块追踪内存分配,结合gc.get_objects()检查存活对象。