《流畅的Python》读书笔记04(补充02): 字典和集合 - defaultdict内存开销解析

defaultdict 与普通 dict 在内存占用和垃圾回收（GC）行为上的差异主要源于其内部实现机制，具体可归纳为以下几个关键方面：

一、内存占用差异

内存占用示例分析：

import sys from collections import defaultdict # 创建空字典比较 d1 = {} d2 = defaultdict(list) print(f"空dict大小: {sys.getsizeof(d1)} 字节") print(f"空defaultdict大小: {sys.getsizeof(d2)} 字节") # 输出示例：空dict大小: 64 字节，空defaultdict大小: 72 字节 # 添加相同内容后的比较 for i in range(1000): d1.setdefault('key', []).append(i) d2['key'].append(i) print(f"填充后dict大小: {sys.getsizeof(d1)} 字节") print(f"填充后defaultdict大小: {sys.getsizeof(d2)} 字节") # 两者大小基本一致，差异仅在于defaultdict对象头部的default_factory引用

关键差异点在于defaultdict对象头部需要存储对default_factory可调用对象的引用。这个引用在 CPython 实现中通常是一个指针（8字节），因此defaultdict的基础内存开销会比普通dict略高。但当字典中存储大量数据时，这一固定开销相对于整体内存占用的比例可以忽略不计。

二、垃圾回收行为差异

1.默认值工厂的引用循环风险

from collections import defaultdict import gc class CircularReference: def __init__(self): # defaultdict 使用自身方法作为工厂 self.data = defaultdict(self.create_list) def create_list(self): return [] # 创建循环引用 obj = CircularReference() # obj.data 的 default_factory 指向 obj.create_list 方法 # 而 obj.create_list 方法又通过 self 参数隐式引用 obj 实例 # 删除外部引用后，循环引用阻止自动回收 del obj print(f"垃圾回收前对象数: {len(gc.get_objects())}") gc.collect() print(f"垃圾回收后对象数: {len(gc.get_objects())}")

风险分析：

• 当default_factory是一个实例方法时，会创建defaultdict→ 方法 → 实例对象的循环引用链
• 普通dict不会自动创建此类循环引用
• Python 的循环垃圾收集器（cycle GC）能处理这种情况，但会增加 GC 压力

2.默认值对象的生命周期管理

from collections import defaultdict import weakref class ExpensiveObject: def __init__(self, value): self.value = value self.data = [0] * 10000 # 模拟大内存占用 def __del__(self): print(f"ExpensiveObject {self.value} 被销毁") def factory(): return ExpensiveObject(len(cache)) # 场景1：defaultdict 中的默认值缓存 cache = defaultdict(factory) # 多次访问不存在的键，创建多个 ExpensiveObject obj1 = cache['key1'] # 创建新对象 obj2 = cache['key2'] # 创建另一个新对象 print(f"缓存大小: {len(cache)}") # 2 # 注意：即使外部引用消失，这些对象仍被字典持有 # 场景2：使用弱引用字典避免内存泄漏 weak_cache = weakref.WeakValueDictionary() weak_cache.setdefault('key1', ExpensiveObject(1)) weak_cache.setdefault('key2', ExpensiveObject(2)) print(f"弱引用缓存大小: {len(weak_cache)}") # 2 # 当没有其他引用时，这些对象会被自动清理

GC 行为关键差异：

三、性能与内存权衡的实际场景

场景1：频繁处理缺失键的数据分组

from collections import defaultdict import tracemalloc import random def process_with_defaultdict(data): """使用 defaultdict 处理分组""" groups = defaultdict(list) for item in data: # 单次查找 + 自动创建 groups[item[0]].append(item[1]) return groups def process_with_dict(data): """使用普通 dict 处理分组""" groups = {} for item in data: # 可能两次查找 + 手动检查 if item[0] not in groups: groups[item[0]] = [] groups[item[0]].append(item[1]) return groups # 生成测试数据 data = [(f"group_{random.randint(1, 100)}", i) for i in range(10000)] # 内存跟踪 tracemalloc.start() # 测试 defaultdict groups1 = process_with_defaultdict(data) current1, peak1 = tracemalloc.get_traced_memory() tracemalloc.reset_peak() # 测试普通 dict groups2 = process_with_dict(data) current2, peak2 = tracemalloc.get_traced_memory() tracemalloc.stop() print(f"defaultdict 峰值内存: {peak1 / 1024:.2f} KB") print(f"普通 dict 峰值内存: {peak2 / 1024:.2f} KB") print(f"内存差异: {(peak1 - peak2) / 1024:.2f} KB")

性能分析结论：

1. 时间性能：defaultdict在频繁处理缺失键的场景下性能更优，因为它将两次查找（检查 + 插入）合并为一次
2. 内存占用：两者最终内存占用几乎相同，但defaultdict可能因默认值对象的创建时机而略有不同
3. GC 压力：defaultdict在长时间运行的服务中可能积累更多对象，增加 GC 频率

场景2：长期运行服务的优化策略

from collections import defaultdict import time import gc class OptimizedDataProcessor: def __init__(self): # 使用可重用的默认值对象 self._empty_list = [] self._empty_dict = {} self._zero_int = 0 # 创建工厂函数（避免实例方法循环引用） self.data_store = defaultdict(self._list_factory) def _list_factory(self): """返回预分配的空列表，减少对象创建开销""" return self._empty_list.copy() # 浅拷贝避免共享 def process_batch(self, batch_data): """处理一批数据""" for key, value in batch_data: self.data_store[key].append(value) def clear_unused(self): """清理长时间未使用的键""" # 模拟基于时间的清理策略 current_time = time.time() keys_to_remove = [ key for key, lst in self.data_store.items() if not lst and random.random() < 0.1 # 10%概率清理空列表 ] for key in keys_to_remove: del self.data_store[key] # 显式触发 GC（谨慎使用） if len(keys_to_remove) > 1000: gc.collect(2) # 代数为2的更彻底回收 # 使用建议 processor = OptimizedDataProcessor() # 批量处理 for _ in range(100): batch = [(f"key_{i % 1000}", i) for i in range(1000)] processor.process_batch(batch) # 定期清理 if _ % 10 == 0: processor.clear_unused()

四、最佳实践建议

1. 内存敏感场景：

   • 如果应用对内存极其敏感，优先使用普通dict配合setdefault
   • 避免在defaultdict中使用会创建大对象的工厂函数
   • 考虑使用__slots__减少对象内存开销

2. 性能优先场景：

   • 频繁处理缺失键时，defaultdict性能更优
   • 使用简单的内置类型作为工厂（list、int、str）
   • 避免在工厂函数中创建复杂对象

3. 长期运行服务：

   • 监控defaultdict的大小增长
   • 实现定期清理策略
   • 考虑使用弱引用（weakref）管理缓存

4. 避免常见陷阱：

   # 错误示例：工厂函数创建循环引用 class BadExample: def __init__(self): self.cache = defaultdict(self.create_entry) # 循环引用！ def create_entry(self): return [] # 正确示例：使用 lambda 或函数避免循环引用 class GoodExample: def __init__(self): self.cache = defaultdict(lambda: []) # 无循环引用

五、总结

defaultdict与普通dict在内存和 GC 方面的核心差异可总结为：

1. 内存占用：defaultdict有固定额外开销（存储default_factory），但数据存储部分与普通dict相同
2. 对象生命周期：defaultdict自动创建并缓存默认值，可能延长对象生命周期
3. GC 行为：defaultdict更容易创建循环引用，可能增加 GC 压力
4. 使用策略：根据场景选择——内存敏感选普通dict，代码简洁和性能优先选defaultdict

在实际应用中，大多数情况下defaultdict的微小内存开销可以被其带来的代码简洁性和性能优势所抵消。关键是要避免在工厂函数中创建可能造成内存泄漏的大对象或循环引用。

参考来源

• 《流畅的Python》读书笔记04: 第一部分 数据结构 - 字典和集合