深入浅出 collections：
Python 标准库里的"数据容器百宝箱"
还在用 dict 手动计数、用 list 自己写队列、为坐标点定义一堆字段头疼？collections 是 Python 标准库里最实用的容器模块，几行代码就能让计数、分组、队列、结构化数据变得优雅又高效。
一、为什么是 collections？
collections 是 Python 自 2.4 起就内置于标准库的高性能专用容器模块。它解决的不是"能不能做"的问题——毕竟你用原生 dict、list、tuple 也能搞定一切——而是"能不能做得更优雅、更快、更少出 bug"的问题。官方对它的一句话定位是："高性能容器数据类型"（high-performance container datatypes）。
它里头的每一个类，都是对某个高频场景的精准抽象：计数要用 Counter、按 key 分组要用 defaultdict、两端进出要用 deque、带字段名的记录要用 namedtuple、需要记住顺序的字典曾经是 OrderedDict……这些需求几乎每个 Python 工程师每周都会撞上，而 collections 已经把最优实现造好了。掌握了它，你会发现很多本来要十几行的样板代码，一行就搞定了。
🔢 Counter — 一行完成计数统计，自带 most_common 排行榜。
📚 defaultdict — 访问不存在的 key 自动给默认值，告别 KeyError。
🔁 deque — 双端队列，头部插入/弹出比 list 快几个数量级。
🏷️ namedtuple - 轻量不可变对象，既能点访问又比 dict 省内存。
二、Counter：一行搞定计数统计
Counter 是 collections 里使用率最高、最让人惊艳的类。它本质是个"带计数的 dict"：把可迭代对象（字符串、列表、文件行……）丢给它，它就自动统计每个元素出现的次数。以前你要写 for x in lst: d[x] = d.get(x, 0) + 1，现在一行就完事。
from collections import Counter
votes = ["苹果", "香蕉", "苹果", "橙子", "香蕉", "苹果"]
c = Counter(votes)
print(c) # Counter({'苹果': 3, '香蕉': 2, '橙子': 1})
print(c["苹果"]) # 3
print(c["葡萄"]) # 0（不存在的 key 不会报错，返回 0）
注意一个贴心细节：Counter 对不存在的 key 返回 0 而不是抛 KeyError，这点和 defaultdict(int) 很像。但它还额外送了你一堆超好用的方法。
most_common：直接出排行榜
most_common(n) 会按出现次数从高到低返回前 n 个 (元素, 计数) 元组。做热词、投票榜、Top-N 分析时简直是量身定制。
text = "abracadabra"
c = Counter(text)
print(c.most_common(3)) # [('a', 5), ('b', 2), ('r', 2)]
print(c.most_common(1)) # [('a', 5)] 最热门的那个
# 实战：统计一篇文章中出现最多的单词
import re
with open("article.txt", encoding="utf-8") as f:
words = re.findall(r"\w+", f.read().lower())
top10 = Counter(words).most_common(10)
Counter 的"数学运算"：加减合并
Counter 重载了 + 和 -，可以直接对两个计数做合并或差额，还会自动剔除结果为 0 或负数的项。做"两天投票变化""A/B 组差异"之类的分析特别顺手。
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2, c=4)
print(c1 + c2) # Counter({'c': 4, 'a': 4, 'b': 3})
print(c1 - c2) # Counter({'a': 2}) 只保留正数部分
print(c2 - c1) # Counter({'c': 4, 'b': 1})
💡 心智模型：把 Counter 想象成一个"会自动数数、还会做加减法的智能货架"——你往里丢东西它就记账，问它"谁最多"它立刻报排行榜，把两个货架合并它自动算总账。
三、defaultdict：再也不用判断 key 是否存在
写原生 dict 时，最烦的一件事就是访问一个还没创建的 key。比如要把一堆数据按城市分组，你得先 if city not in d: d[city] = [] 再 d[city].append(x)。defaultdict 把这套样板彻底消灭：你给它一个"工厂函数"，它就在 key 缺席时自动调用工厂生成默认值。
from collections import defaultdict
# 按首字母把单词分组
groups = defaultdict(list)
for w in ["apple", "ant", "banana", "bag", "cat"]:
groups[w[0]].append(w)
print(groups["a"]) # ['apple', 'ant']
print(groups["z"]) # [] 不存在的 key 自动变成空列表，不报错
工厂函数可以是 list、int、set，甚至你自定义的 callable。int 作工厂时默认值是 0，于是它就摇身一变成了"计数版 dict"，效果和 Counter 异曲同工。
嵌套 defaultdict：自动成长的字典树
最骚的用法是嵌套 defaultdict：让工厂函数返回另一个 defaultdict，于是任意深度的层级结构都能"凭空长出"，完全不用一层层预判。做词频的二维统计、树形菜单、邻接表时极爽。
# 自动成长的二维计数表：行 -> 列 -> 次数
tree = defaultdict(lambda: defaultdict(int))
tree["用户A"]["点击"] += 1
tree["用户A"]["点击"] += 1
tree["用户A"]["购买"] += 1
print(tree["用户A"]) # defaultdict(, {'点击': 2, '购买': 1})
print(tree["用户B"]["点击"]) # 0，全自动补默认值
💡 何时用 defaultdict vs Counter？ 如果只是"数数"，Counter 更语义化、自带 most_common；如果需要"按 key 分组装列表/集合"，defaultdict(list/set) 更合适。两者常常能互相替代，看哪个读起来更顺。
四、deque：双端队列，头部操作快几个数量级
deque（发音 "deck"，double-ended queue 的缩写）是双端队列。它和 list 最大的区别在于：在两端添加/删除元素都是 O(1)，而 list 在头部 insert(0, x) 或 pop(0) 要 O(n)——因为后面所有元素都得搬家。当数据量大、又频繁在头部操作时，deque 能快成百上千倍。
from collections import deque
dq = deque([1, 2, 3])
dq.append(4) # 右侧入队 -> [1, 2, 3, 4]
dq.appendleft(0) # 左侧入队 -> [0, 1, 2, 3, 4]
dq.pop() # 右侧出队 -> 4
dq.popleft() # 左侧出队 -> 0
print(dq) # deque([1, 2, 3])
maxlen：天生的"滑动窗口"
deque 有个独门绝技参数 maxlen：一旦设定，队列永远只保留最近 N 个元素，满了再往里加，最老的那个自动被挤掉。做"最近 10 条日志""股价滑动窗口""限流器"时，比手写 list + 切片优雅太多。
recent = deque(maxlen=3)
for i in range(5):
recent.append(i)
print(list(recent))
# [0]
# [0, 1]
# [0, 1, 2]
# [1, 2, 3] <- 超过 3 个，最老的 0 被挤掉
# [2, 3, 4]
rotate：循环移位小魔术
rotate(n) 把元素整体向右（n>0）或向左（n<0）循环移动，常用于轮询、循环调度。配合 maxlen 还能轻松实现"固定长度环形缓冲"。
dq = deque([1, 2, 3, 4, 5])
dq.rotate(2) # 向右循环 2 位
print(dq) # deque([4, 5, 1, 2, 3])
dq.rotate(-1) # 向左循环 1 位
print(dq) # deque([5, 1, 2, 3, 4])
五、namedtuple：轻量不可变对象，比 dict 省内存还能点访问
namedtuple 用一行就造出一个带字段名的元组子类。你既能像元组一样按索引取、又能像对象一样用 . 点访问字段。它不可变、内存占用极小（比 dict 省好几倍），特别适合表示"坐标、记录、配置项"这类结构化但不需要修改的数据。
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y) # 3 4 点访问
print(p[0]) # 3 也支持下标
print(p) # Point(x=3, y=4) 自动的友好 repr
自带的好用方法：_make / _asdict / _replace / _fields
namedtuple 免费赠送了几个下划线方法，日常极好用：_make 从可迭代对象构造、_asdict 转成 OrderedDict、_replace 生成"改了某字段"的新副本（因为它不可变）、_fields 拿到字段名元组。
Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p._fields) # ('x', 'y')
print(p._replace(x=10)) # Point(x=10, y=2) 返回新对象，原对象不变
print(p._asdict()) # {'x': 1, 'y': 2}
q = Point._make([7, 8]) # Point(x=7, y=8) 从列表构造
💡 namedtuple vs dataclass？ 前面我们讲过 dataclasses——它是"可变的、功能更全的数据类"。区别一句话：不需要修改、追求极省内存、要当元组用 → namedtuple；需要默认值/方法/可变性 → dataclass。两者都是"少写样板"的利器，按需求取舍即可。
六、OrderedDict：记住插入顺序的字典（及 3.7+ 的变迁）
OrderedDict 是一个会记住键值插入顺序的字典。在 Python 3.6 以前，原生 dict 是无序的，想保序只能靠它；但从 Python 3.7 起，原生 dict 也保证插入顺序了，于是 OrderedDict 的存在感下降。不过它仍有独门价值：move_to_end（把某 key 移到首尾）、popitem(last=)（从头部或尾部弹出）、以及相等性比较时区分顺序（两个内容相同但插入顺序不同的 OrderedDict 不相等，而 dict 相等）。
from collections import OrderedDict
od = OrderedDict()
od["b"] = 2
od["a"] = 1
od["c"] = 3
od.move_to_end("a") # 把 a 移到最后
print(list(od)) # ['b', 'c', 'a']
od.popitem(last=False) # 从头部弹出
print(list(od)) # ['c', 'a']
实战里它常出现在LRU 缓存、需要"最近使用移到队尾"的场景——事实上 functools.lru_cache 的内部就是基于类似有序结构的。日常若只需"保序遍历"，用原生 dict 足矣。
七、ChainMap：把多个字典"叠"成一个视图
ChainMap 把多个 dict 逻辑上拼成一个，查找时按传入顺序依次在各级字典里找，找到即返回。它不复制数据、只是视图，因此非常省内存。最经典的应用是"作用域/优先级"：比如命令行参数 > 环境变量 > 默认配置，把三层叠起来，读值时自动取最高优先级的那层。
from collections import ChainMap
defaults = {"color": "红", "size": "M"}
user_cfg = {"size": "L"}
merged = ChainMap(user_cfg, defaults) # 前面的优先级更高
print(merged["size"]) # 'L' 取用户配置
print(merged["color"]) # '红' 用户没配，回退到默认
print(merged.maps) # [{'size': 'L'}, {'color': '红', 'size': 'M'}]
八、UserDict / UserList / UserString：自定义容器的正确姿势
想写自己的 dict/list 子类？千万别直接继承原生 dict——因为有些方法（如 update、__init__）会绕过你重写的 __setitem__，导致你的逻辑悄悄失效。collections 提供了 UserDict、UserList、UserString 作为专门用来被继承的"包装基类"，所有操作都经过你可控的接口，扩展安全又干净。
from collections import UserDict
class UpperDict(UserDict):
# data 是底层真实存储；重写 __setitem__ 自动对所有写入生效
def __setitem__(self, key, value):
self.data[str(key).upper()] = value
d = UpperDict()
d["name"] = "koo"
print(d) # {'NAME': 'koo'} key 被自动转大写
d.update({"age": 18})
print(d) # {'NAME': 'koo', 'AGE': 18} update 也走同一逻辑
九、实战：用 collections 写一个迷你日志分析器
综合前面的工具，写一个真实场景：分析访问日志，统计每个 IP 的访问次数、找出 Top 5、记录每个 IP 最近访问的 3 个路径。这里 Counter + defaultdict(deque) 组合拳，代码短到不可思议：
from collections import Counter, defaultdict, deque
logs = [
("10.0.0.1", "/home"), ("10.0.0.2", "/api"),
("10.0.0.1", "/login"), ("10.0.0.1", "/home"),
("10.0.0.2", "/home"), ("10.0.0.3", "/api"),
]
counts = Counter(ip for ip, _ in logs) # 每个 IP 访问次数
recent = defaultdict(lambda: deque(maxlen=3)) # 每个 IP 最近 3 个路径
for ip, path in logs:
recent[ip].append(path)
print("访问排行:", counts.most_common(5))
# [('10.0.0.1', 3), ('10.0.0.2', 2), ('10.0.0.3', 1)]
print("10.0.0.1 最近访问:", list(recent["10.0.0.1"]))
# ['/home', '/login', '/home']
这一小段把 collections 的三件套串起来了：Counter 出排行、defaultdict 自动分组、deque(maxlen=) 管住最近 N 条。放到真实项目里，这就是日志监控、用户行为分析的"标准姿势"。
十、组合拳：三个常见高阶套路
套路 A：Counter + most_common — 任何"Top-N 排行"需求（热词、热销、热门 IP）一行出榜。
套路 B：defaultdict(deque) - 每个 key 自带一个定长滑动窗口，做"每用户最近 N 条"。
套路 C：ChainMap 做优先级 - 命令行 > 环境 > 默认，三层配置叠成一个，读取自动回退。
十一、新手最常踩的 6 个坑
1. 误以为 Counter 不存在的 key 会报 KeyError：它返回 0，这点和普通 dict 不同，逻辑里别假设会抛异常。
2. defaultdict 遍历时"无中生有"：哪怕只读取 d[key] 也会创建 key，导致遍历中出现本不存在的空值，注意别污染数据。
3. 把 deque 当 list 用全功能：deque 不支持切片、没有 list 的 insert(i) 任意位置插入，需要中间操作时还是用 list。
4. namedtuple 不可变却想改字段：直接用 p.x = 5 会报 AttributeError，记得用 _replace 生成新对象。
5. 直接继承原生 dict 扩展行为：update/__init__ 会绕过重写逻辑，改用 UserDict。
6. OrderedDict 与 dict 相等性混淆：内容相同顺序不同的 OrderedDict 不相等，而 3.7+ 的 dict 只看内容，比较前先想清楚要不要保序。
十二、collections 速查表
| 场景 |
collections 写法 |
| 计数 / Top-N 排行 |
Counter + most_common() |
| 按 key 分组装列表 |
defaultdict(list) |
| 两端频繁进出 / 滑动窗口 |
deque（可选 maxlen） |
| 轻量结构化记录 |
namedtuple |
| 需要移动/弹出顺序的字典 |
OrderedDict |
| 多层配置优先级 |
ChainMap |
| 安全地自定义 dict 子类 |
UserDict / UserList |
一句话总结：collections 是 Python 工程师的"数据容器百宝箱"。Counter 让它秒出排行，defaultdict 让它告别判空，deque 让它两端飞快，namedtuple 让它又轻又清爽。和前面讲过的 functools、Pathlib、Typer 一样，它也是现代 Python "基础肌肉记忆"的一部分。下次写计数、分组、队列前，先问一句：这事，collections 一行能不能搞定？
🚀 立即行动
from collections import Counter, defaultdict, deque, namedtuple → 计数用 Counter.most_common → 分组用 defaultdict(list) → 滑动窗口用 deque(maxlen=N)。
collections 官方文档：https://docs.python.org/3/library/collections.html（含完整 API 与示例）
— END —
关注我们，每周一个 Python 热门技术实战教程
