Python 模块精讲：collections —— 高级数据结构深度解析（defaultdict、Counter、deque）

前言

在 Python 开发体系中，内置数据结构如列表（list）、字典（dict）、集合（set）、元组（tuple）构成了基础的数据存储与操作骨架，满足绝大多数入门级与常规业务逻辑需求。但在实际工程开发、算法实现、数据分析、爬虫解析、高频数据处理等场景下，原生结构的短板逐渐暴露：字典键不存在时直接抛出 KeyError、列表头部插入删除效率极低、元素频率统计需要手动循环计数、多场景下数据分组逻辑冗余等问题，不仅增加代码量，还会降低程序运行效率，提升逻辑出错概率。

Python 官方为解决上述痛点，在标准库中内置了 collections 模块，该模块基于原生数据结构进行高度封装与扩展，提供了一系列高性能、高易用性的高级容器类型，无需额外安装第三方库，即可直接调用。collections 模块包含 defaultdict、Counter、deque、OrderedDict、namedtuple、ChainMap 等多种工具，其中 defaultdict、Counter、deque 是日常开发中使用频率最高、实用性最强的三大核心组件，覆盖了字典缺省处理、元素计数、高效队列等核心场景，是 Python 工程师从初级迈向中高级必须掌握的核心技能。

本文将从模块起源、核心原理、基础语法、进阶用法、性能对比、实战场景、源码解析、常见坑点等维度，对 defaultdict、Counter、deque 进行系统性精讲，结合大量可直接运行的代码案例，帮助读者彻底吃透 collections 模块，实现代码精简、性能提升、逻辑优化的目标。

一、collections 模块深度认知

1.1 模块定位与设计初衷

collections 是 Python 标准库中的容器数据类型扩展模块 ，由 Python 核心开发团队设计并维护，兼容所有 Python 3.x 版本，无需通过 pip 安装，导入即可使用。其核心设计初衷是弥补原生数据结构的功能缺陷，简化高频数据操作逻辑，提升复杂场景下的代码执行效率。

原生数据结构的核心痛点：

dict：访问不存在的键会抛出 KeyError，需手动判断键是否存在，代码冗余；
list ：底层为动态数组，头部插入 / 删除（insert(0, x)、pop(0)）时间复杂度为 O (n)，大数据量下性能极差；
无专用计数工具：统计列表、字符串等可迭代对象的元素频率，需手动循环累加，代码繁琐；
数据分组繁琐：按指定规则对数据分组时，需反复判断键是否存在并初始化值。

collections 模块通过继承原生结构、重写核心方法，完美解决上述问题，同时保持与原生结构的兼容性，降低学习与迁移成本。

1.2 模块核心组件概览

collections 模块包含多个实用组件，各组件分工明确，覆盖不同业务场景：

表格

组件名称	核心功能	适用场景
defaultdict	带默认值的字典，避免 KeyError	数据分组、多级字典存储、默认值初始化
Counter	可哈希对象频率统计工具	词频统计、元素计数、TopN 筛选
deque	双端队列，两端高效增删	队列 / 栈实现、BFS 算法、滑动窗口、消息缓存
namedtuple	带字段名的元组，增强可读性	结构化数据存储、替代简易类
OrderedDict	有序字典（Python 3.7+ dict 已有序）	兼容低版本、严格控制键值顺序
ChainMap	多个字典合并，逻辑上统一视图	配置合并、多环境参数整合
UserDict/UserList/UserString	自定义容器基类	扩展字典 / 列表 / 字符串功能

其中 defaultdict、Counter、deque 是工程开发、算法刷题、数据处理中使用率超 80% 的核心组件，也是本文重点精讲内容。

1.3 模块使用前置条件

collections 为 Python 标准库，无需安装，直接通过 import 语句导入即可：

python

运行

复制代码

# 全量导入
import collections

# 按需导入核心组件（推荐）
from collections import defaultdict, Counter, deque

导入后即可直接创建对应对象，无需额外配置，兼容 Windows、Linux、macOS 等所有操作系统，无环境依赖问题。

二、defaultdict：彻底解决字典 KeyError 痛点

2.1 defaultdict 核心原理

defaultdict 是 Python 字典（dict）的子类，完全继承 dict 的所有方法与特性，同时重写了 __missing__ 魔术方法。原生 dict 访问不存在的键时，会触发 __missing__ 方法并直接抛出 KeyError；而 defaultdict 重写该方法，当访问不存在的键时，会自动调用初始化时传入的工厂函数，生成默认值并将该键值对插入字典，避免报错。

核心逻辑：

初始化 defaultdict 时，必须传入一个无参工厂函数 （如 int、list、set、lambda 表达式等）；
当访问不存在的键时，自动执行工厂函数，生成默认值；
默认值与键绑定，后续可直接操作该键对应的值，无需重复初始化。

工厂函数本质是可调用对象，无需手动传参，仅用于生成默认值，常见工厂函数对应默认值：

int → 默认值 0
list → 默认值 []
set → 默认值 set()
str → 默认值 ''
自定义 lambda → 任意指定默认值

2.2 defaultdict 基础用法全解

2.2.1 基础类型默认值

（1）int 类型默认值

适用于计数场景，无需手动初始化键为 0，直接累加：

python

运行

复制代码

from collections import defaultdict

# 初始化默认值为 int(0)
count_dict = defaultdict(int)

# 访问不存在的键 'apple'，自动赋值为 0
print(count_dict['apple'])  # 输出：0

# 直接累加，无需判断键是否存在
count_dict['apple'] += 1
count_dict['banana'] += 2
count_dict['apple'] += 1

print(count_dict)  # 输出：defaultdict(int, {'apple': 2, 'banana': 2})

（2）list 类型默认值

适用于数据分组场景，将同一类数据存入对应列表，无需手动创建空列表：

python

运行

复制代码

from collections import defaultdict

# 初始化默认值为 空列表
group_dict = defaultdict(list)

# 向不存在的键添加元素，自动创建空列表并追加
group_dict['fruit'].append('苹果')
group_dict['fruit'].append('香蕉')
group_dict['vegetable'].append('菠菜')
group_dict['vegetable'].append('胡萝卜')

print(group_dict['fruit'])     # 输出：['苹果', '香蕉']
print(group_dict['vegetable']) # 输出：['菠菜', '胡萝卜']
print(group_dict['drink'])     # 输出：[]

（3）set 类型默认值

适用于去重分组场景，自动对分组后的数据去重：

python

运行

复制代码

from collections import defaultdict

# 初始化默认值为 空集合
set_dict = defaultdict(set)

# 向集合中添加重复元素，自动去重
set_dict['language'].add('Python')
set_dict['language'].add('Java')
set_dict['language'].add('Python')
set_dict['tool'].add('Git')
set_dict['tool'].add('Maven')

print(set_dict['language']) # 输出：{'Python', 'Java'}

（4）str 类型默认值

适用于字符串拼接场景，默认值为空字符串，直接拼接：

python

运行

复制代码

from collections import defaultdict

str_dict = defaultdict(str)
str_dict['name'] += '张'
str_dict['name'] += '三'
print(str_dict['name']) # 输出：张三
print(str_dict['age'])  # 输出：''

2.2.2 自定义默认值

通过 lambda 表达式 自定义任意默认值，满足个性化业务需求：

python

运行

复制代码

from collections import defaultdict

# 自定义默认值为 '未知'
user_dict = defaultdict(lambda: '未知')
user_dict['name'] = '李四'
user_dict['age'] = 25

# 访问不存在的键
print(user_dict['gender'])  # 输出：未知
print(user_dict['address']) # 输出：未知

# 自定义默认值为 空字典（多级字典场景）
multi_dict = defaultdict(dict)
multi_dict['user']['name'] = '王五'
multi_dict['user']['age'] = 30
print(multi_dict['user']) # 输出：{'name': '王五', 'age': 30}

2.2.3 多级嵌套 defaultdict

处理多级嵌套数据（如树形结构、多级分类）时，嵌套 defaultdict 可避免多层键判断：

python

运行

复制代码

from collections import defaultdict

# 二级嵌套 defaultdict
nested_dict = defaultdict(lambda: defaultdict(list))

# 直接操作二级键
nested_dict['China']['Beijing'].append('朝阳区')
nested_dict['China']['Beijing'].append('海淀区')
nested_dict['China']['Shanghai'].append('浦东新区')

print(nested_dict['China']['Beijing']) # 输出：['朝阳区', '海淀区']
print(nested_dict['USA']['NewYork'])   # 输出：[]

2.3 defaultdict 与原生 dict 性能对比

defaultdict 底层继承 dict，除了 __missing__ 方法的额外逻辑，查询、插入、删除操作的时间复杂度与 dict 完全一致，均为 O (1)，性能损耗可忽略不计。

对比代码：

python

运行

复制代码

import time
from collections import defaultdict

# 测试原生 dict
start = time.time()
normal_dict = {}
for i in range(1000000):
    if 'key' not in normal_dict:
        normal_dict['key'] = 0
    normal_dict['key'] += 1
end = time.time()
print(f"原生 dict 耗时：{end - start:.4f}s")

# 测试 defaultdict
start = time.time()
def_dict = defaultdict(int)
for i in range(1000000):
    def_dict['key'] += 1
end = time.time()
print(f"defaultdict 耗时：{end - start:.4f}s")

运行结果：

plaintext

复制代码

原生 dict 耗时：0.0872s
defaultdict 耗时：0.0421s

结论：defaultdict 无需手动判断键是否存在，代码更简洁的同时，执行效率更高，大数据量下优势更明显。

2.4 defaultdict 实战场景

场景 1：学生成绩分组统计

需求：将多名学生的多科成绩按姓名分组，计算平均分：

python

运行

复制代码

from collections import defaultdict

# 原始成绩数据
scores = [
    ('小明', '语文', 90),
    ('小明', '数学', 95),
    ('小红', '语文', 88),
    ('小红', '数学', 92),
    ('小刚', '语文', 78),
    ('小刚', '数学', 85)
]

# 按姓名分组存储成绩
score_dict = defaultdict(list)
for name, subject, score in scores:
    score_dict[name].append(score)

# 计算平均分
avg_dict = {}
for name, score_list in score_dict.items():
    avg_dict[name] = sum(score_list) / len(score_list)

print(avg_dict)
# 输出：{'小明': 92.5, '小红': 90.0, '小刚': 81.5}

场景 2：日志关键词分类

需求：将日志按错误类型分类，存储对应日志内容：

python

运行

复制代码

from collections import defaultdict

logs = [
    ('ERROR', '数据库连接失败'),
    ('WARNING', '内存占用过高'),
    ('ERROR', '接口超时'),
    ('INFO', '服务启动成功'),
    ('WARNING', '磁盘空间不足')
]

log_dict = defaultdict(list)
for level, msg in logs:
    log_dict[level].append(msg)

print(log_dict['ERROR'])
# 输出：['数据库连接失败', '接口超时']

2.5 defaultdict 常见坑点与规避

工厂函数必须无参：初始化时不能传入带参数的函数，否则会报错；
避免直接传入可变对象 ：如 defaultdict([]) 会报错，必须传入工厂函数 defaultdict(list)；
默认值共享问题：多级嵌套时，需用 lambda 包裹工厂函数，避免所有键共享同一个默认值；
与原生 dict 转换 ：可通过 dict(defaultdict_obj) 直接转为普通字典。

三、Counter：一行代码实现元素频率统计

3.1 Counter 核心原理

Counter 是 dict 的子类，专门用于可哈希对象的频率统计，底层通过字典存储元素（键）与对应计数（值），自动遍历可迭代对象，完成计数累加。

核心特性：

支持列表、字符串、元组、字典等所有可迭代对象；
访问不存在的元素时，返回 0 而非抛出 KeyError；
内置 TopN 筛选、元素展开、计数合并 / 减法等便捷方法；
支持直接进行数学运算（合并、交集、并集）。

可哈希对象：str、int、float、tuple、frozenset 等不可变类型，list、dict 等可变类型不可作为 Counter 键。

3.2 Counter 基础用法全解

3.2.1 初始化 Counter 对象

（1）通过可迭代对象初始化

python

运行

复制代码

from collections import Counter

# 统计列表元素
lst = ['a', 'b', 'a', 'c', 'b', 'a', 'd']
cnt1 = Counter(lst)
print(cnt1)  # 输出：Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})

# 统计字符串字符
s = 'abracadabra'
cnt2 = Counter(s)
print(cnt2)  # 输出：Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

# 统计元组元素
tpl = (1, 2, 1, 3, 2, 1)
cnt3 = Counter(tpl)
print(cnt3)  # 输出：Counter({1: 3, 2: 2, 3: 1})

（2）通过字典初始化

python

运行

复制代码

from collections import Counter

# 直接传入元素与计数字典
cnt = Counter({'a': 3, 'b': 2, 'c': 1})
print(cnt)  # 输出：Counter({'a': 3, 'b': 2, 'c': 1})

（3）通过关键字参数初始化

python

运行

复制代码

from collections import Counter

cnt = Counter(a=3, b=2, c=1)
print(cnt)  # 输出：Counter({'a': 3, 'b': 2, 'c': 1})

3.2.2 核心方法使用

（1）most_common (n)：获取 TopN 高频元素

返回列表，元素为 (元素，计数) 元组，按计数降序排列，n 为筛选数量，n=None 时返回所有元素：

python

运行

复制代码

from collections import Counter

cnt = Counter(['a', 'b', 'a', 'c', 'b', 'a'])
# Top1 高频元素
print(cnt.most_common(1))  # 输出：[('a', 3)]
# Top2 高频元素
print(cnt.most_common(2))  # 输出：[('a', 3), ('b', 2)]
# 所有元素排序
print(cnt.most_common())   # 输出：[('a', 3), ('b', 2), ('c', 1)]

（2）elements ()：展开计数元素

按计数次数重复生成元素，返回迭代器，可转为列表查看：

python

运行

复制代码

from collections import Counter

cnt = Counter({'a': 2, 'b': 1, 'c': 3})
print(list(cnt.elements()))
# 输出：['a', 'a', 'b', 'c', 'c', 'c']

（3）update ()：合并计数

将另一个可迭代对象的计数累加到当前 Counter：

python

运行

复制代码

from collections import Counter

cnt = Counter(['a', 'b', 'a'])
cnt.update(['a', 'c', 'b', 'b'])
print(cnt)  # 输出：Counter({'a': 3, 'b': 3, 'c': 1})

（4）subtract ()：减去计数

将另一个可迭代对象的计数从当前 Counter 减去，计数可为负数：

python

运行

复制代码

from collections import Counter

cnt = Counter({'a': 3, 'b': 2, 'c': 1})
cnt.subtract(['a', 'b', 'b', 'd'])
print(cnt)  # 输出：Counter({'a': 2, 'c': 1, 'b': 0, 'd': -1})

（5）数学运算操作

支持加法（合并计数）、减法（减去计数）、交集（取最小计数）、并集（取最大计数）：

python

运行

复制代码

from collections import Counter

cnt1 = Counter(a=3, b=1, c=2)
cnt2 = Counter(a=1, b=2, d=3)

# 加法：计数累加
print(cnt1 + cnt2)  # Counter({'a': 4, 'c': 2, 'b': 3, 'd': 3})

# 减法：计数相减（仅保留正数）
print(cnt1 - cnt2)  # Counter({'c': 2, 'a': 2})

# 交集：取最小计数
print(cnt1 & cnt2)  # Counter({'a': 1, 'b': 1})

# 并集：取最大计数
print(cnt1 | cnt2)  # Counter({'a': 3, 'd': 3, 'c': 2, 'b': 2})

3.2.3 特殊操作：清空与删除计数

python

运行

复制代码

from collections import Counter

cnt = Counter(['a', 'b', 'a'])
# 删除单个元素计数
del cnt['a']
print(cnt)  # 输出：Counter({'b': 1})

# 清空所有计数
cnt.clear()
print(cnt)  # 输出：Counter()

3.3 Counter 性能优势

原生统计元素频率需手动循环 + 判断，代码冗余且效率低，Counter 底层用 C 语言优化，大数据量下性能远超手动实现。

对比代码：

python

运行

复制代码

import time
from collections import Counter

# 原生方法统计
lst = [i for i in range(1000000)]
start = time.time()
normal_dict = {}
for num in lst:
    if num in normal_dict:
        normal_dict[num] += 1
    else:
        normal_dict[num] = 1
end = time.time()
print(f"原生方法耗时：{end - start:.4f}s")

# Counter 统计
start = time.time()
cnt = Counter(lst)
end = time.time()
print(f"Counter 耗时：{end - start:.4f}s")

运行结果：

plaintext

复制代码

原生方法耗时：0.1245s
Counter 耗时：0.0312s

结论：Counter 执行效率是原生方法的 4 倍以上，数据量越大，差距越明显。

3.4 Counter 实战场景

场景 1：文章词频统计

需求：统计一段文本中单词的出现频率，筛选 Top3 高频词：

python

运行

复制代码

from collections import Counter
import re

# 原始文本
text = """Python is a powerful language. Python is easy to learn. 
Python is widely used in data analysis and machine learning."""

# 预处理：转小写、去除标点、分割单词
words = re.findall(r'\w+', text.lower())

# 统计词频
word_cnt = Counter(words)

# 筛选 Top3 高频词
print("高频词 Top3：", word_cnt.most_common(3))
# 输出：高频词 Top3： [('python', 3), ('is', 3), ('a', 1)]

场景 2：用户行为统计

需求：统计用户浏览商品的次数，找出浏览量最高的商品：

python

运行

复制代码

from collections import Counter

# 用户浏览记录
browse_log = ['手机', '电脑', '手机', '平板', '电脑', '手机', '耳机', '电脑']

# 统计浏览次数
goods_cnt = Counter(browse_log)

# 找出最热门商品
hot_goods = goods_cnt.most_common(1)[0]
print(f"最热门商品：{hot_goods[0]}，浏览次数：{hot_goods[1]}")
# 输出：最热门商品：手机，浏览次数：3

场景 3：检测字符串是否为字母异位词

需求：判断两个字符串是否由相同字符组成（字符数量一致）：

python

运行

复制代码

from collections import Counter

def is_anagram(s1, s2):
    return Counter(s1) == Counter(s2)

print(is_anagram('listen', 'silent'))  # 输出：True
print(is_anagram('hello', 'world'))    # 输出：False

3.5 Counter 常见坑点

计数可为负数：subtract 操作后计数可能为负，需手动过滤；
不可变元素限制：list、dict 等可变类型不能作为统计对象；
空值处理：空可迭代对象初始化 Counter 后为空，访问元素返回 0；
与 dict 兼容 ：可直接用 dict 方法操作 Counter，如 items()、keys()、values()。

四、deque：高性能双端队列，替代 list 实现高效队列 / 栈

4.1 deque 核心原理

deque 全称 double-ended queue（双端队列） ，底层采用双向链表 结构实现，支持在队列头部和尾部以 O (1) 时间复杂度 完成插入、删除操作，完美解决 list 头部操作 O (n) 的性能瓶颈。

核心特性：

支持 append/pop（右端）、appendleft/popleft（左端）高效操作；
可设置最大长度 maxlen，自动淘汰旧数据；
支持旋转、扩展、反转等便捷操作；
线程安全，支持多线程环境下的并发访问；
兼容 list 大部分方法，如索引访问、切片、遍历。

list 与 deque 底层结构差异：

list：动态数组，内存连续，随机访问快（O (1)），头部插入 / 删除慢（O (n)）；
deque：双向链表，内存不连续，随机访问慢（O (n)），两端操作快（O (1)）。

4.2 deque 基础用法全解

4.2.1 初始化 deque 对象

python

运行

复制代码

from collections import deque

# 空双端队列
dq1 = deque()

# 带初始数据的队列
dq2 = deque([1, 2, 3, 4])

# 设置最大长度，超出后自动淘汰左侧数据
dq3 = deque([1, 2, 3], maxlen=3)

print(dq2)  # 输出：deque([1, 2, 3, 4])
print(dq3)  # 输出：deque([1, 2, 3], maxlen=3)

4.2.2 核心增删操作

（1）右端操作（与 list 一致）

python

运行

复制代码

from collections import deque

dq = deque([1, 2, 3])
# 右端添加元素
dq.append(4)
print(dq)  # 输出：deque([1, 2, 3, 4])

# 右端删除元素
dq.pop()
print(dq)  # 输出：deque([1, 2, 3])

（2）左端操作（list 无高效对应方法）

python

运行

复制代码

from collections import deque

dq = deque([1, 2, 3])
# 左端添加元素
dq.appendleft(0)
print(dq)  # 输出：deque([0, 1, 2, 3])

# 左端删除元素
dq.popleft()
print(dq)  # 输出：deque([1, 2, 3])

（3）批量扩展操作

python

运行

复制代码

from collections import deque

dq = deque([1, 2])
# 右端批量扩展
dq.extend([3, 4, 5])
print(dq)  # 输出：deque([1, 2, 3, 4, 5])

# 左端批量扩展
dq.extendleft([0, -1])
print(dq)  # 输出：deque([-1, 0, 1, 2, 3, 4, 5])

4.2.3 高级操作

（1）rotate (n)：队列旋转

n 为正数时向右旋转，n 为负数时向左旋转：

python

运行

复制代码

from collections import deque

dq = deque([1, 2, 3, 4, 5])
# 右旋转 1 位
dq.rotate(1)
print(dq)  # 输出：deque([5, 1, 2, 3, 4])

# 左旋转 2 位
dq.rotate(-2)
print(dq)  # 输出：deque([2, 3, 4, 5, 1])

（2）maxlen 自动淘汰

设置最大长度后，新元素加入时自动删除旧元素：

python

运行

复制代码

from collections import deque

# 最大长度 3
dq = deque(maxlen=3)
dq.append(1)
dq.append(2)
dq.append(3)
print(dq)  # 输出：deque([1, 2, 3], maxlen=3)

# 追加新元素，自动删除左侧 1
dq.append(4)
print(dq)  # 输出：deque([2, 3, 4], maxlen=3)

（3）反转与清空

python

运行

复制代码

from collections import deque

dq = deque([1, 2, 3])
# 反转队列
dq.reverse()
print(dq)  # 输出：deque([3, 2, 1])

# 清空队列
dq.clear()
print(dq)  # 输出：deque([])

4.2.4 索引访问与遍历

deque 支持索引访问，但时间复杂度为 O (n)，不建议频繁使用：

python

运行

复制代码

from collections import deque

dq = deque([1, 2, 3, 4])
# 索引访问
print(dq[0])  # 输出：1
print(dq[-1]) # 输出：4

# 遍历
for num in dq:
    print(num, end=' ')  # 输出：1 2 3 4

4.3 deque 与 list 性能对比

头部插入 / 删除操作，deque 性能远超 list，数据量越大差距越明显。

对比代码：

python

运行

复制代码

import time
from collections import deque

# 测试 list 头部插入
start = time.time()
lst = []
for i in range(100000):
    lst.insert(0, i)
end = time.time()
print(f"list 头部插入耗时：{end - start:.4f}s")

# 测试 deque 头部插入
start = time.time()
dq = deque()
for i in range(100000):
    dq.appendleft(i)
end = time.time()
print(f"deque 头部插入耗时：{end - start:.4f}s")

运行结果：

plaintext

复制代码

list 头部插入耗时：2.8765s
deque 头部插入耗时：0.0123s

结论：deque 头部插入效率是 list 的 200 倍以上，是队列、栈、滑动窗口场景的最优选择。

4.4 deque 实战场景

场景 1：实现栈（Stack）

栈遵循后进先出（LIFO），用 deque 的 append + pop 实现：

python

运行

复制代码

from collections import deque

stack = deque()
# 入栈
stack.append(1)
stack.append(2)
stack.append(3)
print("栈内容：", stack)  # 输出：栈内容： deque([1, 2, 3])

# 出栈
stack.pop()
print("出栈后：", stack)  # 输出：出栈后： deque([1, 2])

场景 2：实现队列（Queue）

队列遵循先进先出（FIFO），用 deque 的 append + popleft 实现：

python

运行

复制代码

from collections import deque

queue = deque()
# 入队
queue.append('任务1')
queue.append('任务2')
queue.append('任务3')
print("队列内容：", queue)  # 输出：队列内容： deque(['任务1', '任务2', '任务3'])

# 出队
queue.popleft()
print("出队后：", queue)    # 输出：出队后： deque(['任务2', '任务3'])

场景 3：BFS 广度优先搜索（算法核心）

二叉树 BFS 遍历必须用队列，deque 是最优选择：

python

运行

复制代码

from collections import deque

# 二叉树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# BFS 遍历
def bfs(root):
    if not root:
        return []
    res = []
    dq = deque([root])
    while dq:
        node = dq.popleft()
        res.append(node.val)
        if node.left:
            dq.append(node.left)
        if node.right:
            dq.append(node.right)
    return res

# 构建测试树
root = TreeNode(1, TreeNode(2), TreeNode(3))
print("BFS 遍历结果：", bfs(root))  # 输出：BFS 遍历结果：[1, 2, 3]

场景 4：滑动窗口最大值（LeetCode 经典题）

用 deque 维护窗口内元素索引，实现 O (n) 时间复杂度：

python

运行

复制代码

from collections import deque

def max_sliding_window(nums, k):
    dq = deque()
    res = []
    for i, num in enumerate(nums):
        # 移除窗口外元素
        while dq and dq[0] <= i - k:
            dq.popleft()
        # 维护递减队列
        while dq and nums[dq[-1]] <= num:
            dq.pop()
        dq.append(i)
        # 记录窗口最大值
        if i >= k - 1:
            res.append(nums[dq[0]])
    return res

nums = [1,3,-1,-3,5,3,6,7]
k = 3
print(max_sliding_window(nums, k))
# 输出：[3, 3, 5, 5, 6, 7]

4.5 deque 常见坑点

随机访问效率低：避免频繁用索引访问 deque 元素；
maxlen 只读：初始化后不可修改 maxlen，需重新创建对象；
线程安全范围：仅 append、appendleft、pop、popleft 线程安全，复杂操作需加锁；
切片限制：Python 3.5+ 支持 deque 切片，低版本需转为 list 后切片。

五、三大核心组件综合对比与选型指南

5.1 核心特性对比表

表格

组件	底层结构	核心优势	时间复杂度	适用场景
defaultdict	哈希表	避免 KeyError，自动初始化默认值	查插删：O (1)	数据分组、多级字典、默认值赋值
Counter	哈希表	一键统计频率，内置 TopN 与运算	统计：O (n)，查插删：O (1)	词频统计、元素计数、异位词判断
deque	双向链表	两端高效操作，线程安全	两端操作：O (1)，随机访问：O (n)	队列 / 栈、BFS、滑动窗口、消息队列

5.2 选型指南

字典操作需默认值 → 选择 defaultdict，替代 dict + if 判断；
统计元素频率 → 选择 Counter，替代手动循环计数；
队列 / 栈 / 滑动窗口 → 选择 deque，替代 list 实现高效操作；
多级嵌套数据 → defaultdict 嵌套使用；
大数据量高频两端操作 → 必选 deque，拒绝 list；
快速筛选高频数据 → 必选 Counter，一行代码实现。

六、总结与学习建议

6.1 核心知识点复盘

collections 是 Python 标准库，提供高性能高级容器，无需额外安装；
defaultdict 重写 __missing__ 方法，自动生成默认值，彻底解决 KeyError；
Counter 是专用计数工具，内置 TopN、合并、运算等方法，效率远超原生实现；
deque 双向链表结构，两端操作 O (1)，是队列、算法场景的最优选择；
三大组件均兼容原生数据结构，易上手、易迁移，无学习门槛。

6.2 工程化实践建议

代码规范 ：优先使用 from collections import xxx 按需导入，提升代码可读性；
性能优化 ：大数据量场景下，用 deque 替代 list，Counter 替代手动计数，defaultdict 替代普通 dict；
算法刷题：BFS、滑动窗口、哈希计数类题目，直接使用三大组件，简化代码；
避免滥用：随机访问场景优先用 list，普通字典场景无需强行用 defaultdict。

6.3 进阶学习方向

掌握 defaultdict、Counter、deque 后，可继续学习 collections 模块的其他组件：

namedtuple：结构化数据存储，替代简易类；
ChainMap：多字典合并，配置管理场景；
UserDict：自定义字典，扩展字典功能；
结合 itertools 模块，实现更复杂的数据处理逻辑。

collections 模块是 Python 数据结构的精华所在，熟练掌握三大核心组件，不仅能大幅精简代码、提升效率，更能培养优雅的编程思维，是 Python 开发者进阶路上的必备技能。在实际开发中，有意识地用 collections 替代原生结构，可快速实现代码质量与运行效率的双重提升。