1
import sys
2

3
# 每个对象维护一个引用计数
4
a = []  # 引用计数 +1
5
b = a   # 引用计数 +1
6
print(sys.getrefcount(a))  # 3 (包括 getrefcount 的临时引用)
7

8
del a   # 引用计数 -1
9
del b   # 引用计数 -1 -> 对象被回收
10

11
# 引用计数为 0 时，对象立即被销毁

1
# 循环引用导致引用计数无法归零
2
class Node:
3
    def __init__(self):
4
        self.next = None
5

6
a = Node()
7
b = Node()
8
a.next = b  # a -> b
9
b.next = a  # b -> a
10

11
# 引用计数：a=1, b=1（相互引用）
12
# 无法通过引用计数回收，造成内存泄漏
13

14
# 解决：标记-清除（Mark-Sweep）算法
15
import gc
16
gc.collect()  # 手动触发垃圾回收

1
import gc
2

3
# Python 将对象分为三代
4
# 第 0 代：新创建的对象
5
# 第 1 代：经历一次 GC 仍存活的对象
6
# 第 2 代：经历两次 GC 仍存活的对象
7

8
# 分代阈值
9
print(gc.get_threshold())  # (700, 10, 10)
10
# 触发条件：第 0 代对象数量 > 700
11

12
# 分代回收策略
13
# 第 0 代：频繁回收
14
# 第 1 代：次频繁回收
15
# 第 2 代：很少回收
16

17
# 自动回收
18
gc.enable()   # 启用自动回收
19
gc.disable()  # 禁用自动回收

1
# 1. 全局变量引用
2
leaked_data = []
3

4
def add_data(item):
5
    leaked_data.append(item)  # 数据永不释放
6

7
# 2. 闭包引用
8
def create_leak():
9
    data = [1, 2, 3]
10
    def inner():
11
        return data  # data 被闭包持有
12
    return inner
13

14
# 3. 循环引用
15
class Node:
16
    def __init__(self):
17
        self.self_ref = self  # 循环引用
18

19
# 4. 监听器未移除
20
class EventEmitter:
21
    def __init__(self):
22
        self.listeners = []
23

24
    def on(self, event, callback):
25
        self.listeners.append((event, callback))
26

27
    # 如果没有 off() 移除，监听器会累积
28

29
# 5. 缓存未清理
30
cache = {}
31

32
def get_data(key):
33
    if key not in cache:
34
        cache[key] = load_data(key)  # 缓存无限增长
35
    return cache[key]

1
import tracemalloc
2

3
# 启动跟踪
4
tracemalloc.start()
5

6
# ... 执行代码 ...
7

8
# 获取快照
9
snapshot = tracemalloc.take_snapshot()
10

11
# 显示最大内存占用
12
top_stats = snapshot.statistics('lineno')
13
for stat in top_stats[:10]:
14
    print(stat)
15

16
# 按文件名过滤
17
stats = snapshot.filter_traces((
18
    tracemalloc.Filter(False, "<module>"),
19
))

1
# pip install objgraph
2

3
import objgraph
4

5
# 显示增长最多的对象类型
6
print(objgraph.show_most_common_types(limit=10))
7

8
# 显示某个类型的所有实例
9
print(objgraph.by_type('MyClass'))
10

11
# 统计某个对象的引用
12
obj = some_object()
13
print(objgraph.find_refchain(obj, max_depth=5))

1
import sys
2

3
class WithoutSlots:
4
    def __init__(self, x, y):
5
        self.x = x
6
        self.y = y
7

8
class WithSlots:
9
    __slots__ = ['x', 'y']
10

11
    def __init__(self, x, y):
12
        self.x = x
13
        self.y = y
14

15
# 对比内存占用
16
obj1 = WithoutSlots(1, 2)
17
obj2 = WithSlots(1, 2)
18

19
print(sys.getsizeof(obj1))  # 56 bytes (含 __dict__)
20
print(sys.getsizeof(obj2))  # 40 bytes (更小)
21

22
# 注意：slots 不影响实例方法的内存

1
class SafeClass:
2
    __slots__ = ['x', 'y']
3

4
    def __init__(self, x, y):
5
        self.x = x
6
        self.y = y
7

8
obj = SafeClass(1, 2)
9
obj.z = 3  # AttributeError: 'SafeClass' object has no attribute 'z'

1
# 慢：每次访问 math 模块都需查找
2
def slow_sin():
3
    import math
4
    for i in range(1000):
5
        math.sin(i)
6

7
# 快：模块级导入
8
import math
9

10
def fast_sin():
11
    for i in range(1000):
12
        math.sin(i)

1
# 慢：append in loop
2
result = []
3
for i in range(10000):
4
    result.append(i * 2)
5

6
# 快：列表推导式
7
result = [i * 2 for i in range(10000)]
8

9
# 更快：生成器（内存）
10
result = (i * 2 for i in range(10000))
11

12
# 字符串拼接优化
13
# 慢
14
s = ""
15
for i in range(1000):
16
    s += str(i)
17

18
# 快
19
parts = []
20
for i in range(1000):
21
    parts.append(str(i))
22
s = "".join(parts)
23

24
# 最快（如果可能）
25
s = "".join(str(i) for i in range(1000))

1
# map 比循环快
2
import time
3

4
start = time.perf_counter()
5
result = list(map(lambda x: x * 2, range(1000000)))
6
print(f"map: {time.perf_counter() - start:.4f}s")
7

8
start = time.perf_counter()
9
result = [x * 2 for x in range(1000000)]
10
print(f"list comp: {time.perf_counter() - start:.4f}s")

1
# 慢：全局变量查找开销
2
def slow_func():
3
    for i in range(1000):
4
        value = math.sin(i) + math.cos(i)
5
    return value
6

7
# 快：缓存局部变量
8
def fast_func():
9
    sin = math.sin
10
    cos = math.cos
11
    for i in range(1000):
12
        value = sin(i) + cos(i)
13
    return value

1
from itertools import islice
2

3
# 迭代器替代列表切片
4
# 慢
5
data = list(range(1000000))
6
subset = data[100:200]
7

8
# 快：使用 islice
9
subset = list(islice(range(1000000), 100, 200))

1
from functools import lru_cache
2

3
@lru_cache(maxsize=128)
4
def fibonacci(n):
5
    if n < 2:
6
        return n
7
    return fibonacci(n - 1) + fibonacci(n - 2)
8

9
# 缓存信息
10
print(fibonacci.cache_info())
11
# CacheInfo(hits=0, misses=0, maxsize=128, currsize=0)
12

13
fibonacci(10)
14
print(fibonacci.cache_info())
15
# CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)
16

17
# 清除缓存
18
fibonacci.cache_clear()

1
from functools import lru_cache
2
import time
3

4
# 带过期时间的缓存
5
class Cache:
6
    def __init__(self, ttl=60):
7
        self.cache = {}
8
        self.ttl = ttl
9

10
    def get(self, key):
11
        if key in self.cache:
12
            value, timestamp = self.cache[key]
13
            if time.time() - timestamp < self.ttl:
14
                return value
15
            del self.cache[key]
16
        return None
17

18
    def set(self, key, value):
19
        self.cache[key] = (value, time.time())
20

21
    def clear(self):
22
        self.cache.clear()