python必背源代码collections常用容器代码

拾光
拾光
发布时间:2026-11-20 | 10人浏览过
原创

整理Python标准库collections模块中最常用的高频容器核心源代码模板与用法解析,涵盖Counter、defaultdict、deque、namedtuple、OrderedDict等核心数据结构,提供规范开箱即用的代码与性能场景指导。

Python 内置的列表(list)、元组(tuple)和字典(dict)满足了多数日常场景,但在处理频次计数、缺失键分组、双端队列操作与轻量结构体传输时,直接使用原生结构往往需要编写冗长的防御性检查代码,甚至导致严重的时间性能衰减。Python 标准库内置的 collections 模块针对特定高频场景提供了特化的高性能容器。本文系统整理其中最常用的 5 大容器——Counter、defaultdict、deque、namedtuple 以及 OrderedDict / ChainMap 的核心源代码模板、关键运行表现与避坑要点。
python必背源代码collections常用容器代码
图 0:Python collections 常用高性能容器体系概览

一、Counter:元素频次统计与多集合运算必背代码

Counter 本质上是一个继承自标准 dict 的特化字典,专门用于计算可哈希对象的出现次数。在原生字典中统计频次,必须先判断键是否存在或频繁调用 dict.get(k, 0);而 Counter 在访问不存在的键时,直接返回整数 0,不会抛出 KeyError,也不会隐式将缺失键存入字典。

1. 核心源代码模板

from collections import Counter

# 1. 快速统计序列元素频次
words = ['python', 'code', 'data', 'python', 'code', 'python', 'algorithm']
word_counts = Counter(words)

# 2. 访问存在与不存在的键
print(f"python 出现次数: {word_counts['python']}")
print(f"unknown 出现次数: {word_counts['unknown']}")  # 返回 0,不报错

# 3. 提取出现频次最高的 Top-K 项
top_2_words = word_counts.most_common(2)
print(f"最高频前2项: {top_2_words}")

# 4. 多集合算术加减与交并运算
c1 = Counter(apple=4, orange=2, banana=1)
c2 = Counter(apple=2, orange=3, grape=5)

added = c1 + c2     # 频次相加
diff = c1 - c2      # 频次相减(仅保留差值大于0的键)
intersect = c1 & c2 # 交集(取各项频次的较小值)
union = c1 | c2     # 并集(取各项频次的较大值)

print(f"加法运算: {dict(added)}")
print(f"减法运算: {dict(diff)}")
print(f"交集运算: {dict(intersect)}")
print(f"并集运算: {dict(union)}")

# 5. 还原数据迭代器
unpacked = list(c1.elements())
print(f"还原序列: {unpacked}")
示例输出: python 出现次数: 3
unknown 出现次数: 0
最高频前2项: [('python', 3), ('code', 2)]
加法运算: {'apple': 6, 'orange': 5, 'banana': 1, 'grape': 5}
减法运算: {'apple': 2}
交集运算: {'apple': 2, 'orange': 2}
并集运算: {'apple': 4, 'orange': 3, 'banana': 1, 'grape': 5}
还原序列: ['apple', 'apple', 'apple', 'apple', 'orange', 'orange', 'banana']
python必背源代码collections常用容器代码
图 1:Counter 频次统计与 Top-K 提取处理流程
注意事项:most_common(k) 底层使用 heapq.nlargest 实现,时间复杂度为 \(O(N \log K)\),远优于先对全量字典排序的 \(O(N \log N)\)。此外,Counter 减法运算 c1 - c2 会自动剔除计数小于等于 0 的结果项;若需保留负数或零值,需直接使用 c1.subtract(c2) 原地修改。

二、defaultdict:分组归类与默认值字典必背代码

在数据清洗和归类聚合时,我们经常需要把相同分类的数据聚合到列表或集合中。原生字典需要通过 if key not in d: d[key] = [] 或者 d.setdefault(key, []).append(val) 维护。其中 setdefault 无论键是否存在,都会先对参数中的 [] 进行实例化评估,带来无谓的内存开销与调用惩罚。

defaultdict 在初始化时接收一个可调用的工厂函数(如 list、set、int)。只有当查找的键真正不存在时,才会自动调用工厂函数创建默认值,逻辑精简且吞吐更高。

1. 核心源代码模板

from collections import defaultdict

# 场景 1:一对多列表分组聚合(按分类归集学生成绩)
records = [
    ('GroupA', 'Alice', 92),
    ('GroupB', 'Bob', 85),
    ('GroupA', 'Charlie', 88),
    ('GroupB', 'David', 90),
    ('GroupA', 'Eva', 95)
]

grouped_students = defaultdict(list)
for group, name, score in records:
    grouped_students[group].append((name, score))

print("分组结果:")
for group, members in grouped_students.items():
    print(f"  {group}: {members}")

# 场景 2:唯一值集合去重(按用户归集访问过的模块)
user_modules = defaultdict(set)
logs = [('user_1', 'home'), ('user_2', 'cart'), ('user_1', 'home'), ('user_1', 'pay')]
for uid, mod in logs:
    user_modules[uid].add(mod)

print(f"用户去重访问模块: {dict(user_modules)}")

# 场景 3:自定义工厂函数(嵌套默认字典或默认基准值)
default_metric = defaultdict(lambda: {'count': 0, 'total': 0.0})
default_metric['request_api']['count'] += 1
default_metric['request_api']['total'] += 12.5
print(f"复合统计结构: {dict(default_metric)}")
示例输出: 分组结果:
  GroupA: [('Alice', 92), ('Charlie', 88), ('Eva', 95)]
  GroupB: [('Bob', 85), ('David', 90)]
用户去重访问模块: {'user_1': {'home', 'pay'}, 'user_2': {'cart'}}
复合统计结构: {'request_api': {'count': 1, 'total': 12.5}}
避坑指南:单纯执行读取操作(如 val = grouped_students['NonExistent'])就会静默调用工厂函数并将该键写入字典。若只想判断键是否存在而不写入脏数据,请务必使用 'key' in d 检查,而不是直接读取。

三、deque:O(1) 双端队列与固定滑动窗口必背代码

Python 原生 list 是连续线性存储数组。在列表尾部追加(append)或弹出(pop)时间复杂度为 \(O(1)\),但在列表头部执行 list.insert(0, val) 或 list.pop(0) 时,需要将后续全部元素在内存中整体右移或左移,时间复杂度高达 \(O(N)\)。

collections.deque 内部采用双向块链表(Block-Linked Doubly-Linked List)实现,两端的 append/pop 以及 appendleft/popleft 均为严格 \(O(1)\) 时间复杂度。另外,通过指定 maxlen 参数,deque 能在超出容量时自动弹出陈旧元素,是构建无损环形缓冲区和定长滑动窗口的理想结构。

1. 核心源代码模板

from collections import deque

# 1. 基础双端操作:O(1) 两端极速插入与弹出
dq = deque(['b', 'c', 'd'])
dq.append('e')          # 右端添加
dq.appendleft('a')      # 左端添加
print(f"双端插入后: {dq}")

left_item = dq.popleft() # 左端 O(1) 弹出,原生 list.pop(0) 为 O(N)
right_item = dq.pop()    # 右端 O(1) 弹出
print(f"弹出左端 '{left_item}' 与右端 '{right_item}' 后: {dq}")

# 2. 定长滑动窗口(maxlen 环形淘汰)
# 适用于保持最近 3 条系统日志,超出的历史数据自动且静默淘汰
recent_logs = deque(maxlen=3)
for log_id in range(1, 6):
    recent_logs.append(f"log_event_{log_id}")
    print(f"添加 log_{log_id} 当前缓冲: {list(recent_logs)}")

# 3. 元素轮转(rotate 平移操作)
nums = deque([1, 2, 3, 4, 5])
nums.rotate(2)   # 向右循环移位 2 位
print(f"向右循环平移 2 位: {nums}")
nums.rotate(-2)  # 向左循环复原
print(f"向左循环平移 2 位: {nums}")
示例输出: 双端插入后: deque(['a', 'b', 'c', 'd', 'e'])
弹出左端 'a' 与右端 'e' 后: deque(['b', 'c', 'd'])
添加 log_1 当前缓冲: ['log_event_1']
添加 log_2 当前缓冲: ['log_event_1', 'log_event_2']
添加 log_3 当前缓冲: ['log_event_1', 'log_event_2', 'log_event_3']
添加 log_4 当前缓冲: ['log_event_2', 'log_event_3', 'log_event_4']
添加 log_5 当前缓冲: ['log_event_3', 'log_event_4', 'log_event_5']
向右循环平移 2 位: deque([4, 5, 1, 2, 3])
向左循环复原: deque([1, 2, 3, 4, 5])
python必背源代码collections常用容器代码
图 2:deque 双端队列分块链表结构 vs list 连续内存数组对比

由于 deque 基于指针分块组织内存,其访问中间索引(如 dq[len(dq)//2])需要沿块链表跳转,时间复杂度为 \(O(N)\)。因此,如果业务场景需要频繁通过随机下标读取元素,应优先使用 list;如果是队列排队、生产者消费者缓冲区或滑动窗口,deque 无论在速度还是内存稳定性上都是第一选择。

四、namedtuple:轻量具名元组与数据载体必背代码

在函数间传递结构化数据时,直接使用字典(dict)存在键名可能拼错、无字段保护且每个实例附带 __dict__ 哈希表开销的问题;而定义完整的自定义 class 又显得代码繁琐。

namedtuple 是一个工厂函数,用于创建具有字段名称的不可变元组子类。它兼具元组的极低内存占用、解构特性与对象的点号属性访问便捷性,是轻量数据传输对象(DTO)的首选方案。

1. 核心源代码模板

from collections import namedtuple

# 1. 定义数据结构类型
# 声明类型名称与包含的字段列表
UserRecord = namedtuple('UserRecord', ['user_id', 'username', 'email', 'role'])

# 2. 实例化对象
u1 = UserRecord(101, 'alex', 'alex@example.com', 'admin')

# 3. 具名属性访问与常规元组下标访问
print(f"属性访问: ID={u1.user_id}, 用户名={u1.username}, 角色={u1.role}")
print(f"下标与解构: 首字段={u1[0]}, 长度={len(u1)}")
uid, uname, *rest = u1
print(f"解构赋值: uid={uid}, uname={uname}")

# 4. 只读保护验证(尝试修改会抛出 AttributeError)
try:
    u1.role = 'guest'
except AttributeError as e:
    print(f"只读保护触发: {e}")

# 5. 生成修改副本与字典序列化
# namedtuple 实例是不可变的,使用 _replace 生成修改部分字段的新实例
u2 = u1._replace(role='editor')
print(f"修改后新实例: {u2}")

# 转换为普通字典(方便 JSON 序列化)
u_dict = u1._asdict()
print(f"转换为字典: {u_dict}")

# 6. 从可迭代对象或现有字典构造
dict_source = {'user_id': 102, 'username': 'sarah', 'email': 'sarah@test.com', 'role': 'user'}
u3 = UserRecord(**dict_source)
print(f"由解包字典构造: {u3}")
示例输出: 属性访问: ID=101, 用户名=alex, 角色=admin
下标与解构: 首字段=101, 长度=4
解构赋值: uid=101, uname=alex
只读保护触发: can't set attribute
修改后新实例: UserRecord(user_id=101, username='alex', email='alex@example.com', role='editor')
转换为字典: {'user_id': 101, 'username': 'alex', 'email': 'alex@example.com', 'role': 'admin'}
由解包字典构造: UserRecord(user_id=102, username='sarah', email='sarah@test.com', role='user')

需要注意,namedtuple 的辅助方法和属性均以下划线开头(如 _replace、_asdict、_fields),目的是防止与开发者自定义的字段名称产生命名冲突。

五、ChainMap 与 OrderedDict:特定高频场景必背代码

除了上述四大常用容器,ChainMap 和 OrderedDict 在特定工程需求中能够省去大量手动逻辑:

  • ChainMap(多层作用域级联):将多个映射合并为一个逻辑视图。在参数解析中,通常存在“命令行参数 > 环境变量 > 配置文件 > 默认参数”的优先级。使用 ChainMap 可直接完成短路查找,无需调用 dict.update() 覆盖深拷贝。
  • OrderedDict(保序与 LRU 缓存):虽然 Python 3.7+ 的标准 dict 已经保证了插入顺序,但 OrderedDict 额外提供了 move_to_end() 方法以及双向链表重排能力,能够以 \(O(1)\) 复杂度轻松构建最近最少使用(LRU)淘汰机制。

1. 核心源代码模板

from collections import ChainMap, OrderedDict

# --- 场景 A: ChainMap 多层级联配置短路查找 ---
cli_params = {'port': 9000}                           # 优先级 1: 命令行参数
os_env = {'host': '0.0.0.0', 'port': 8000}            # 优先级 2: 环境变量
app_defaults = {'host': '127.0.0.1', 'port': 5000, 'workers': 4} # 优先级 3: 默认底线

# 构造链式映射视图,查找时按传入顺序自左向右短路命中
config = ChainMap(cli_params, os_env, app_defaults)

print(f"解析 port: {config['port']}")      # 优先命中 cli_params 的 9000
print(f"解析 host: {config['host']}")      # cli 未指定,命中 os_env 的 0.0.0.0
print(f"解析 workers: {config['workers']}")# 前者均未指定,回退到 app_defaults 的 4

# 新增动态上级作用域(例如某个子任务覆盖配置)
local_scope = config.new_child({'port': 3000})
print(f"局部覆盖后 port: {local_scope['port']}")


# --- 场景 B: OrderedDict 快速手写 LRU 缓存容器 ---
class SimpleLRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key):
        if key not in self.cache:
            return None
        # 命中后,O(1) 将该键移到末尾,标记为最近使用
        self.cache.move_to_end(key, last=True)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key, last=True)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            # 移除最左端最久未被访问的项
            evicted_key, _ = self.cache.popitem(last=False)
            print(f"  [LRU淘汰] 移除陈旧键: '{evicted_key}'")

lru = SimpleLRUCache(capacity=2)
lru.put('A', 10)
lru.put('B', 20)
print(f"读取键 'A': {lru.get('A')}")  # 此时 'A' 变为最新,'B' 变为最旧
lru.put('C', 30)                    # 容量超限,'B' 被自动淘汰
print(f"当前剩余键: {list(lru.cache.keys())}")
示例输出: 解析 port: 9000
解析 host: 0.0.0.0
解析 workers: 4
局部覆盖后 port: 3000
读取键 'A': 10
  [LRU淘汰] 移除陈旧键: 'B'
当前剩余键: ['A', 'C']
python必背源代码collections常用容器代码
图 3:ChainMap 作用域链级联查找 与 OrderedDict 双向链表重排机制

六、技术选型与核心容器复杂度速查

为了在实际开发中快速定位最合适的数据容器,下表横向梳理了各容器的底层核心实现、代表性操作复杂度与推荐匹配场景:

容器类型 内部实现机制 高频操作时间复杂度 适用核心场景 开发注意事项
Counter 哈希表 (继承 dict) 写入/计数累加: \(O(1)\)
most_common(k): \(O(N \log K)\)
词频统计、数据分布打标、多集合数量加减交并 访问未记录键返回 0;减法运算会过滤掉非正数
defaultdict 带工厂函数的哈希表 查找与初始化写入: \(O(1)\) 一对多数据归类、去重聚合集合、复合指标归集 直接下标读取缺失键会立即创建默认值写入字典
deque 双向分块链表 两端 append/pop: \(O(1)\)
中间随机索引访问: \(O(N)\)
先进先出 FIFO 队列、定长滑动窗口、无损环形缓存 禁止高频执行依据下标随机读取和中间插入操作
namedtuple 具名元组工厂 (tuple 子类) 属性访问与解构: \(O(1)\)
字段替换: \(O(N)\) 产生新副本
轻量只读 DTO、数据行包装、替代轻量实体类 属性为严格只读;需要可变字段时应使用 dataclass
ChainMap 字典引用列表 链式查找: \(O(M imes 1)\) (M为层数)
写操作: \(O(1)\) (仅作用首层)
命令行/环境/文件多层配置继承、嵌套局部作用域 只在第一个字典中执行增删改,修改不会下穿到底层
OrderedDict 哈希表 + 双向循环链表 键移动: move_to_end: \(O(1)\)
首尾弹出: popitem: \(O(1)\)
需要精细调控顺序的场景、纯 Python 手写 LRU 缓存 常规排序在 3.7+ 字典中已内置,非特殊操作无需引入
python必背源代码collections常用容器代码
图 4:Python collections 常用核心容器技术选型决策树

在实际编写 Python 代码时,牢记“统计用 Counter、归类用 defaultdict、两端增删用 deque、载体用 namedtuple”。善用这些专门特化的高阶容器,不仅能显著减少重复的模板代码,还能直接获得底层经过严密优化的运行性能。

相关专题:

本站声明

本文内容仅供参考,不代表本站观点。转载或引用请注明出处。如发现内容问题,请通过联系我们页面反馈。

Python 相关产品和应用

全部下载

专题列表