201_Python内存管理与GC¶

import sys

# 查看引用计数
a = [1, 2, 3]
print(sys.getrefcount(a))  # 2 (a本身 + getrefcount参数)

b = a  # 引用计数+1
print(sys.getrefcount(a))  # 3

c = [a, a]  # 又+2
print(sys.getrefcount(a))  # 5

del b  # -1
print(sys.getrefcount(a))  # 4

# 引用计数增加的场景：
# 1. 赋值: b = a
# 2. 作为参数: func(a)
# 3. 容器元素: lst = [a]
# 4. 属性引用: obj.attr = a

# 引用计数减少的场景：
# 1. del语句: del a
# 2. 变量重新赋值: a = None
# 3. 离开作用域
# 4. 容器删除元素

import gc

# 循环引用示例
class Node:
    def __init__(self, name):
        self.name = name
        self.next = None
    def __del__(self):
        print(f"Deleting {self.name}")

# 创建循环引用
a = Node("A")
b = Node("B")
a.next = b
b.next = a  # 循环引用！

# 删除外部引用
del a, b
# 此时A和B的引用计数都是1（互相引用）
# 引用计数不会变成0，需要GC介入

# 手动触发GC
gc.collect()  # 输出: Deleting A, Deleting B

# 查看GC信息
print(gc.get_stats())  # 各代的收集统计
print(gc.get_threshold())  # 触发收集的阈值 (700, 10, 10)

# 调整GC行为
gc.set_threshold(500, 5, 5)  # 更激进的收集
gc.disable()  # 禁用自动GC（谨慎使用！）
gc.enable()   # 启用

import weakref

class ExpensiveObject:
    def __init__(self, data):
        self.data = data

# 正常引用
obj = ExpensiveObject("重要数据")
ref = weakref.ref(obj)  # 弱引用不增加引用计数

print(ref())      # <ExpensiveObject object>
print(ref().data) # 重要数据

del obj
print(ref())  # None（对象已被回收）

# WeakValueDictionary：缓存的好帮手
class ImageCache:
    def __init__(self):
        self._cache = weakref.WeakValueDictionary()

    def get_image(self, path):
        img = self._cache.get(path)
        if img is None:
            img = self._load_image(path)
            self._cache[path] = img
        return img

    def _load_image(self, path):
        return f"Image({path})"
    # 当外部不再引用Image时，缓存自动清理

import tracemalloc
import sys

# tracemalloc追踪内存分配
tracemalloc.start()

data = [list(range(1000)) for _ in range(1000)]

snapshot = tracemalloc.take_snapshot()
top = snapshot.statistics('lineno')
for stat in top[:5]:
    print(stat)

# 对象大小
print(f"int大小: {sys.getsizeof(42)} bytes")
print(f"空list: {sys.getsizeof([])} bytes")
print(f"空dict: {sys.getsizeof({})} bytes")
print(f"空str: {sys.getsizeof('')} bytes")

# __slots__节省内存
class WithoutSlots:
    def __init__(self, x, y):
        self.x = x
        self.y = y

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

import sys
a = WithoutSlots(1, 2)
b = WithSlots(1, 2)
print(f"Without slots: {sys.getsizeof(a) + sys.getsizeof(a.__dict__)} bytes")
print(f"With slots: {sys.getsizeof(b)} bytes")
# slots通常节省40-50%内存

# 生成器vs列表（节省大量内存）
import sys
lst = [i**2 for i in range(1000000)]     # ~8MB
gen = (i**2 for i in range(1000000))     # ~200 bytes
print(f"List: {sys.getsizeof(lst)} bytes")
print(f"Generator: {sys.getsizeof(gen)} bytes")

import gc
import objgraph  # pip install objgraph

# 查找最常见的对象类型
objgraph.show_most_common_types(limit=10)

# 查找增长的对象类型
objgraph.show_growth(limit=5)

# 查找循环引用
gc.collect()
garbage = gc.garbage  # 无法回收的循环引用对象

# 使用memory_profiler逐行分析
# pip install memory_profiler
from memory_profiler import profile

@profile
def memory_intensive():
    big_list = [i for i in range(1000000)]
    del big_list
    return "done"

# 命令行运行: python -m memory_profiler script.py

# 引用计数
sys.getrefcount(obj)

# GC控制
gc.collect(); gc.get_stats(); gc.set_threshold(700, 10, 10)

# 弱引用
ref = weakref.ref(obj); weakref.WeakValueDictionary()

# 内存分析
tracemalloc.start(); snapshot = tracemalloc.take_snapshot()

# 命令行分析
# python -m memory_profiler script.py
# python -m tracemalloc script.py