字典推导式和字典合并是Python里被低估的两组语法能力:一个负责“筛选+变形+重构”,一个负责“多来源覆盖与聚合”。把这两块吃透,处理配置、清洗接口返回、做分组统计时,代码量往往能砍掉一半,可读性反而更好。下面按语法要点、典型写法、版本差异、实战封装和踩坑顺序整理一遍,代码均基于原文示例重新组织。
一、字典推导式的语法骨架
基本形态是 {key_expr: value_expr for item in iterable},可选在末尾追加 if 条件做过滤。它等价于先建空字典、再在循环里逐个赋值,但表达更紧凑:
- squares = {x: x ** 2 for x in range(6)}
- print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
- keys = ['name', 'age', 'city']
- values = ['小明', 25, '北京']
- person = {k: v for k, v in zip(keys, values)}
- print(person) # {'name': '小明', 'age': 25, 'city': '北京'}
复制代码
两个列表拼字典是高频场景,zip 把两个可迭代对象拉成键值对,推导式负责落成 dict,比手写 for 循环少一次临时变量。
二、带条件的过滤:if 放在 for 之后
这里的 if 是筛选,不是三元表达式。对字典调用 items() 后按值或按键过滤都很自然:
- numbers = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
- filtered = {k: v for k, v in numbers.items() if v > 2}
- print(filtered) # {'c': 3, 'd': 4, 'e': 5}
- config = {
- 'DB_HOST': 'localhost',
- 'DB_PORT': 5432,
- 'CACHE_HOST': 'redis://localhost',
- 'CACHE_PORT': 6379,
- 'APP_NAME': 'MyApp',
- }
- db_config = {k: v for k, v in config.items() if k.startswith('DB_')}
- print(db_config) # {'DB_HOST': 'localhost', 'DB_PORT': 5432}
- cache_config = {
- k.replace('CACHE_', '').lower(): v
- for k, v in config.items()
- if k.startswith('CACHE_')
- }
- print(cache_config) # {'host': 'redis://localhost', 'port': 6379}
复制代码
注意第三个例子:键表达式挂在 for 之前、if 之前,键在生成时就已经被改写(去前缀并转小写),过滤条件仍然作用在原始键上。这种“先判断、后改写”的顺序是推导式最容易写反的地方。
三、键值变换与字典反转
只改键、只改值、键值同时改,三种写法共用同一骨架:
- original = {'a': 1, 'b': 2, 'c': 3}
- uppercase_keys = {k.upper(): v for k, v in original.items()}
- prices = {'apple': 10, 'banana': 5, 'orange': 8}
- with_tax = {k: v * 1.1 for k, v in prices.items()}
- original = {'user_name': 'xiaoming', 'user_email': 'xm@test.com'}
- cleaned = {
- k.replace('user_', '').upper(): v.upper()
- for k, v in original.items()
- }
- print(cleaned) # {'NAME': 'XIAOMING', 'EMAIL': 'XM@TEST.COM'}
复制代码
字典反转(键值互换)只需把 k 和 v 的位置对调,但原文特别点出一个坑:值重复时后写的会覆盖先写的。{'a': 1, 'b': 2, 'c': 1} 反转后得到 {1: 'c', 2: 'b'},键 'a' 被 'c' 吃掉了。需要保留全部映射关系时,得改用 setdefault 收集:
- def safe_reverse(d):
- """安全反转——值重复时收集所有键"""
- result = {}
- for k, v in d.items():
- result.setdefault(v, []).append(k)
- return result
- print(safe_reverse({'a': 1, 'b': 2, 'c': 1})) # {1: ['a', 'c'], 2: ['b']}
复制代码
四、分组、嵌套与词频统计
遇到“一对多”的嵌套结构,推导式配合 setdefault 或 defaultdict 比纯循环更清爽:
- students = [
- ('小明', {'math': 85, 'english': 90}),
- ('小红', {'math': 92, 'english': 88}),
- ('小刚', {'math': 78, 'english': 85}),
- ]
- math_above_80 = {
- name: scores
- for name, scores in students
- if scores['math'] > 80
- }
- products = [
- ('电子产品', '手机', 2999),
- ('电子产品', '电脑', 5999),
- ('食品', '苹果', 5),
- ('食品', '香蕉', 3),
- ('服装', 'T恤', 99),
- ]
- catalog = {}
- for category, item, price in products:
- catalog.setdefault(category, {})[item] = price
- from collections import defaultdict
- catalog2 = defaultdict(dict)
- for category, item, price in products:
- catalog2[category][item] = price
复制代码
词频统计是另一个经典对照。普通循环用 dict.get(word, 0) + 1;最省事的是 collections.Counter,dict(Counter(...)) 一步到位;用推导式配合 set 虽然能写出 {word: text.split().count(word) for word in set(text.split())},但每个唯一词都要重新 count 一遍全文,复杂度明显偏高,只适合数据量很小的场景。原文把这个写法列为“能写但不推荐”,值得记住。
首字母建索引的写法同理:
- words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
- index = {
- ch: [w for w in words if w.startswith(ch)]
- for ch in set(w[0] for w in words)
- }
- print(index)
- # {'a': ['apple'], 'b': ['banana'], 'c': ['cherry'], 'd': ['date'], 'e': ['elderberry']}
复制代码
五、字典合并的四种方式与版本差异
1)| 运算符(Python 3.9+):返回新字典,右侧覆盖左侧,支持链式使用。
- defaults = {'host': 'localhost', 'port': 8080, 'debug': False}
- overrides = {'port': 9090, 'debug': True, 'timeout': 30}
- config = defaults | overrides
- print(config)
- # {'host': 'localhost', 'port': 9090, 'debug': True, 'timeout': 30}
- merged = {'a': 1} | {'b': 2} | {'c': 3}
- print(merged) # {'a': 1, 'b': 2, 'c': 3}
复制代码
| 的两个操作数都必须是 dict,右边传键值对列表会直接抛 TypeError。
2)|= 原地合并(Python 3.9+):修改左操作数本身,并且接受任意可迭代的键值对,等价于 update:
- config = {'host': 'localhost', 'port': 8080}
- config |= {'debug': True, 'port': 9090}
- print(config)
- # {'host': 'localhost', 'port': 9090, 'debug': True}
- config |= [('timeout', 30), ('retries', 3)]
复制代码
3)** 解包(Python 3.5+):构造新字典,同样遵循后者覆盖前者,还能在合并过程中插键:
- d1 = {'a': 1, 'b': 2}
- d2 = {'c': 3, 'd': 4}
- d3 = {'a': 100, 'e': 5}
- merged = {**d1, **d2, **d3}
- print(merged) # {'a': 100, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
- merged = {**d1, 'extra': 'value', **d2}
复制代码
原文示例中把非字符串键列为 ** 解包的限制点并给出 TypeError 现象。实践中更稳妥的做法是:只要出现非字符串键或者不确定解释器版本,就改用 | 或 update(),这两个分支不受键类型约束。
4)update():全版本可用,原地修改,参数形式最灵活——字典、关键字参数、键值对可迭代对象都吃:
- d = {'a': 1, 'b': 2}
- d.update({'c': 3})
- d.update(d=4, e=5)
- d.update([('f', 6)])
- print(d) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
复制代码
选型可以按这几条走:要新字典且版本 ≥3.9 用 d1 | d2;要原地改且 ≥3.9 用 d1 |= d2;3.5–3.8 造新字典用 {**d1, **d2};需要兼容更老版本或参数形态复杂,直接用 d1.update(d2)。区别的本质只有两点——是否产生新对象、对键类型有无约束。
六、实战:一个可合并的配置类
把 |= 和推导式组合起来,就能写出一个带过滤逻辑的配置容器:合并时丢弃 None 值、从文件加载时只接受已知键,避免未知配置污染运行环境。
- class Config:
- """多层级配置管理系统"""
- def __init__(self, defaults=None):
- self._config = defaults.copy() if defaults else {}
- def load(self, **overrides):
- valid_overrides = {k: v for k, v in overrides.items() if v is not None}
- self._config |= valid_overrides
- def load_from_file(self, file_config):
- known_keys = self._config.keys()
- filtered = {k: v for k, v in file_config.items() if k in known_keys}
- self._config |= filtered
- def get(self, key, default=None):
- return self._config.get(key, default)
- def to_dict(self):
- return self._config.copy()
- def clone(self):
- return Config(self._config.copy())
复制代码
使用方式直观:先用默认字典建实例,再逐层叠加环境配置和文件配置,重复键自动以新值覆盖,to_dict() 返回副本可防止外部误改。clone() 则用浅拷贝的配置构造新实例,适合传给子组件。
七、三种常见合并模式
默认值+调用方覆盖:函数参数收进 kwargs,直接 defaults | kwargs。层级合并需要递归,因为 | 只做一层覆盖,嵌套字典会被整体替换:
- def merge_deep(base, override):
- """深度合并两个字典(嵌套字典递归合并)"""
- result = base.copy()
- for key, value in override.items():
- if key in result and isinstance(result[key], dict) and isinstance(value, dict):
- result[key] = merge_deep(result[key], value)
- else:
- result[key] = value
- return result
- base = {
- 'database': {'host': 'localhost', 'port': 5432, 'pool': {'min': 1}},
- 'cache': {'host': 'localhost', 'port': 6379},
- }
- override = {'database': {'port': 5433, 'pool': {'max': 20}}}
- print(merge_deep(base, override))
- # {'database': {'host': 'localhost', 'port': 5433, 'pool': {'min': 1, 'max': 20}},
- # 'cache': {'host': 'localhost', 'port': 6379}}
复制代码
多源数据聚合则按顺序叠加,后面的源覆盖前面的源:
- def aggregate_data(*sources):
- result = {}
- for source in sources:
- if source:
- result |= source
- return result
- user_from_db = {'id': 1, 'name': '小明', 'email': 'xm@test.com'}
- user_from_api = {'name': '小明(更新)', 'phone': '13800138000'}
- user_from_cache = {'last_login': '2025-06-01'}
- final_user = aggregate_data(user_from_db, user_from_api, user_from_cache)
复制代码
八、四个必须注意的坑
第一,| 的优先级低于条件表达式。写成 {'a': 1} | {'b': 2} if condition else {} 时,解析结果和直觉不一致,务必加括号:({'a': 1} | {'b': 2}) if condition else {}。
第二,键类型约束。非字符串键场景不要硬套 ** 解包,改用 {1: 'a'} | {2: 'b'} 或 update()。
第三,推导式有独立的局部作用域。Python 3 下 {x: x * 3 for x in 'abc'} 不会把外部变量 x 改掉,循环结束后外层 x 仍是原值,这一点与普通 for 循环不同。
第四,空值与 None。{} | {} 合法,但 None | {} 会抛 TypeError。合并前先兜底:merged = (config or {}) | {}。
九、小结
字典推导式解决“从已有可迭代对象构建或重塑字典”的问题,核心是分清键表达式、值表达式和过滤条件三者的位置;字典合并解决“多来源字典按序覆盖”的问题,核心是分清是否新建对象以及版本约束。前者注意重复值反转和作用域,后者注意优先级和键类型,两者配合 |= 与递归 merge_deep,就足以应付绝大多数配置管理和数据聚合需求。 |