接触Python这么久，我越来越觉得字典（Dictionaries）是这个语言里最被低估的数据结构。列表负责有序地装东西，元组负责不可变地保护东西，而字典负责高效地“按名字找人”。如果列表是一个一个排好队的柜子，字典就是一本通讯录，根据名字直接翻到对应那一页。这种设计思路渗透到Python的方方面面，函数参数传递、配置管理、JSON数据处理、爬虫解析响应，到处都能看到dict的身影。这篇就以我实际写代码的经验为线索，把字典从基础操作到实战场景完整拆一遍。整体阅读时间会比较长，建议读完顺手做两个练习，比光看有用得多。
1. 字典到底是什么：先建立正确的认知模型
1.1 哈希表：字典的地基
字典底层是哈希表（hash table）。每个键先被哈希函数映射成一个数字位置，值存在这个位置上。读取的时候也是先算键的哈希值，然后再去找对应位置。这个过程的时间复杂度平均是O(1)，不管字典里是10个键还是10万个键，读取单个值几乎不随数据量变慢。这也是字典和列表最本质的区别之一：列表查找要逐个比较，复杂度是O(n)，数据一多差距就非常明显。
理解这个底层逻辑对日常编码很有帮助。比如为什么字典的键必须是不可变类型？因为哈希值是一个键的“身份证”，如果键本身的哈希值中途变了，字典就再也找不到原来的条目了。列表、字典这类可变容器没有稳定的哈希值，强行用会直接报TypeError: unhashable type。而元组、字符串、数字这些不可变类型，哈希值稳定，自然就能当键。
1.2 字典是引用关系的集合
很多新手会把字典理解成“像列表一样的东西”，这个类比容易误导。列表强调的是元素之间的顺序关系，字典强调的是键与值的映射关系。键就是索引，值就是内容，中间那条映射线才是真正的核心。
实际工程中，字典经常承担“索引表”的角色。比如处理一批用户数据，需要根据用户ID快速找出其订单列表，那就可以用user_id作为键，订单列表作为值。一次遍历建好索引，后面一千次查询都只是O(1)操作。这种“用空间换时间”的思路，在数据处理脚本里可以说是每天都会用到。
1.3 键的唯一性与值的高容错
字典里的键必须唯一，重复赋值会覆盖旧值。这个特性看起来简单，却是一个非常趁手的去重工具。值则可以是什么都行：整数、字符串、列表、另一个字典、函数、类对象，都可以存。这种灵活性让字典几乎成了Python里的“万能容器”。写脚本时遇到“需要把一组数据按某种规则归组”的需求，第一反应基本就是建字典，键是分组规则，值是对应的数据集合。
2. 字典的日常操作：增删改查的完整细节
2.1 创建字典的五种常见姿势
最直观的方式当然是大括号直接写键值对：
user = {"name": "张三", "age": 25, "city": "上海"}空字典用{}，用dict()也能创建，但注意dict()接受的关键字参数会把键隐式转成字符串：
a = dict(name="李四", age=30) # {'name': '李四', 'age': 30}另外几种可能少用但关键时刻能救场的创建方式。用fromkeys批量创建统一初始值的字典：
keys = ["apple", "banana", "cherry"] d = dict.fromkeys(keys, 0) # {'apple': 0, 'banana': 0, 'cherry': 0}或者从成对的可迭代对象构建，比如两个列表zip起来：
names = ["甲", "乙", "丙"] scores = [88, 92, 79] d = dict(zip(names, scores))还有一种场景非常常见：从列表推导式直接生成字典。在处理配置文件或者批量解析参数时会特别高效，后面我会单独展开。
2.2 读取值：[]、get()与setdefault()的区别
读取字典有三种思路，效果差别很大。
直接用小括号中括号d[key]读，键不存在会抛KeyError。我刚开始写代码的时候经常被这个坑，程序动不动就崩。后来慢慢养成习惯：只要是外部传入的数据，读取时都要考虑“键可能不存在”的情况。最稳妥的做法是用.get(key, default)，键不存在时返回默认值而不报错。这个方法用得非常频繁，几乎是字典读取的首选。
setdefault(key, default)就更高级一点：如果键存在，返回原值；如果键不存在，先把键设置为默认值，再返回默认值。简单说就是“有就用，没有就补上”。每次遍历数据想累加统计时，这个方法能省去一堆if key in d的判断。比如统计每个单词出现次数：
counts = {} for word in words: counts[word] = counts.setdefault(word, 0) + 1一行完成初始化加累加。不过这种场景后来我更习惯用collections.defaultdict，代码还能再省一点，后文会讲到。
2.3 遍历字典：别只盯着items()一个招
遍历字典有三种常见需求。只遍历键，直接for k in d:即可，不用写d.keys()。只遍历值，用for v in d.values():。键值同时遍历，用for k, v in d.items():。
顺序在Python 3.7之后是有保证的，插入顺序就是遍历顺序。这一点在实际场景中很重要，比如要从接口返回的字典里按字段顺序组装报文，不用再额外维护一个顺序列表。
还有一个容易被忽略的点：遍历时如果想根据条件删除部分条目，不能边遍历边直接del d[k]，会报RuntimeError: dictionary changed size during iteration。正确的做法是先把满足条件的键收集到一个列表里，遍历结束后再统一删除。或者更现代一点，用字典推导式建一个新字典实现过滤。
2.4 修改与删除的注意事项
修改值直接d[key] = new_value，如果键不存在就变成新增。删除用del d[key]（键不存在会报错）或者d.pop(key, default)（键不存在返回默认值不报错）。我实际编码时更偏向pop，因为它同时完成了“删除”和“取值”两步，经常在临时处理数据时用。
清空整个字典用d.clear()，注意这个方法和重新赋值d = {}不一样：clear是原地清空，原来指向这个字典的所有变量都会看到空字典；重新赋值则是把当前变量指向一个新的空对象，其他引用旧字典的变量不受影响。涉及多个变量共享同一个字典的场景，这里容易出隐蔽的bug。
3. 写出干净代码：字典的进阶用法
3.1 字典推导式与常用构造技巧
字典推导式是构建字典最Pythonic的方式之一。它的语法格式和列表推导式很接近，只是外面用大括号，带键值对：
# 生成1到10的平方映射 squares = {x: x*x for x in range(1, 11)} # 翻转键值（注意值必须是可哈希的） inverted = {v: k for k, v in original.items()}我在实际中用到最多的场景是批量转换数据格式，比如把一批数据库查询结果从行列表转换成以主键为索引的字典：
user_map = {row["id"]: row for row in db_result}这样后续每次按ID查用户，就变成了一次字典查找，不用再遍历整个结果集。如果数据量是几万行，这个性能差距会非常明显。
3.2 用**解包字典
函数调用时常常需要把字典解包成关键字参数，这是字典和函数之间的桥梁。假设我有个函数：
def create_user(name, age, city="未知"): ...可以直接用字典传参：
params = {"name": "王五", "age": 28} create_user(**params)字典解包不只是调用函数时用。合并两个字典也经常用{**d1, **d2}这种写法，后出现的字典会覆盖前面的同名键。这个写法在Python 3.5引入，非常简洁。不过Python 3.9之后还有更直观的联合运算符|，代码风格上更接近自然语言。
3.3 字典合并：两代写法对比
Python 3.9引入的|运算符让字典合并变得更直观。以前写合并要么用update，要么用解包：
merged = dict(d1) merged.update(d2) # 或者 merged = {**d1, **d2}现在可以直接写：
merged = d1 | d2注意|不是原地修改，而是生成一个新字典。|=才是原地更新，等价于update。我在实际项目里还是习惯优先用{**d1, **d2}，因为兼容性最好，毕竟线上环境不是所有机器都立刻升到3.9以上。但这两种方式有一个共同的坑：嵌套字典不会做深合并，只是把内层字典的引用整体替换掉。如果希望内层键也合并，需要自己写递归逻辑。
3.4 字典排序与View对象
字典本身是无序的（顺序指插入顺序，不是排序顺序），但实际工作中经常会要求“按值排序”。常见做法是用sorted+items()，再配合key参数指定排序依据：
d = {"apple": 5, "banana": 2, "cherry": 8} sorted_d = dict(sorted(d.items(), key=lambda x: x[1], reverse=True))这里有两层细节值得说明。第一，sorted(d.items(), key=lambda x: x[1])返回的是元组列表，需要再用dict()包回字典，才能保持类型。第二，排序的复杂度是O(n log n)，如果数据量到了百万级别，要想想是不是真的需要排序，还是可以用heapq取前几个就够。
还有一个容易误解的概念：d.items()、d.keys()、d.values()返回的是视图对象，并不是列表。视图会随着原字典变化而变化，这在某些场景下是个很好的特性，但如果你想在遍历期间修改原字典，视图反而会带来麻烦（前面提到的修改尺寸问题）。
4. 实战场景拆解：词频统计、邻接矩阵与配置管理
4.1 用defaultdict做词频统计
统计一段文本中各单词的出现次数，是字典最经典的练习题。大家可能都写过这样一段：
text = "the quick brown fox jumps over the lazy dog" counts = {} for word in text.split(): counts[word] = counts.get(word, 0) + 1没问题，能跑。但如果用collections.defaultdict(int)，代码会更有表达力，因为这个类型把“初始化默认值”这个行为封装掉了。访问不存在的键时，defaultdict会调用传入的工厂函数自动创建默认值，因此主逻辑只剩一行：
from collections import defaultdict counts = defaultdict(int) for word in text.split(): counts[word] += 1注意，defaultdict(int)里传入的是类型本身，不是int()调用。常见工厂函数还有defaultdict(list)生成键到列表的映射、defaultdict(set)生成键到集合的映射。比如把一组订单按用户分组，写成orders_by_user[uid].append(order)，完全不需要手动创建空列表。
4.2 构建邻接矩阵：字典本身就是稀疏矩阵的最优解
搜索引擎热词里出现了“python构建邻接矩阵”，这类题目在算法和数据分析里很常见。邻接矩阵表示的是“节点之间的连接关系”，常见实现是用二维列表，但对于稀疏图，二维列表会浪费大量空间。比如一万个节点、只有一万条边，一个10000x10000的二维列表就已经是1亿个元素，内存直接爆掉。
更优雅的方案是用字典嵌套字典表示稀疏邻接矩阵。外层字典键是起点节点，内层字典键是终点节点，值是权重或边是否存在的标志：
graph = { 0: {1: 1, 2: 1}, 1: {2: 1, 3: 1}, 2: {3: 1} }这样有没有边，一查就知道。加一条边也很直观：
graph.setdefault(src, {})[dst] = weight # 或者配合defaultdict from collections import defaultdict graph = defaultdict(dict) graph[src][dst] = weight遍历某个节点的所有邻居时，直接for neighbor, w in graph[node].items()即可。这种方式在图的规模很大但边很少时，内存开销几乎接近最简表达。我也在带团队开发推荐系统相关的数据处理流程时，用这种结构存储用户之间共同浏览过的商品关系，效果比稠密矩阵好太多。
4.3 用字典管理配置文件与状态
字典在业务代码里的一个高频场景是“配置管理”。典型的做法是读JSON或YAML之后，结果就是一个嵌套字典，然后用字典取值方式逐层解析。这类代码最容易出的问题就是某个层级键缺失，比如接口返回的数据少了个字段或者结构变了。
我习惯写一个简单的小工具函数来安全地读取嵌套字典，避免每层都做一次try except：
def deep_get(d, path, default=None): for key in path.split("."): if isinstance(d, dict): d = d.get(key) else: return default if d is None: return default return d用法：
# 原来是 data["user"]["profile"]["nickname"] nickname = deep_get(data, "user.profile.nickname", "匿名")这个工具函数帮我少写了很多防御代码。本质上它就是把“每次健在判断”封装成了链式查询。真实项目里接口返回结构经常是很深的嵌套关系，类似小工具非常实用。
4.4 Counter：字典的子类
collections.Counter是字典的子类，专门用于计数。它的用法比defaultdict还简洁，直接构造时就能统计：
from collections import Counter cnt = Counter(text.split()) most_common = cnt.most_common(3) # [(word, count), ...]Counter还有一个非常好用的特性：支持加减和交集并集运算。比如统计两个时间段各自的词频后，想得到总词频，直接cnt1 + cnt2。想找新增词，用cnt2 - cnt1。这些操作在数据分析场景里能省掉大量手工循环。Counter本质还是字典，所以它继承的所有字典方法都可以继续用，只是额外增加了统计语义。
4.5 字典配合json模块：数据的出入口
Python的字典和JSON几乎是天生一对。用json.dumps(dict)可以把字典序列化成JSON字符串，用json.loads(s)可以把JSON字符串解析回字典。实际爬虫和接口测试中，日均都在这样交互。但是有几个坑我得提醒一下。字典的键只要是字符串、数字、布尔值等基本类型都可以序列化，但元组作为键会被JSON序列化时转换成数组，反序列化回来就变成列表，不能直接当键用了。所以如果字典的键是元组，且要和JSON互相转换，务必先处理好键的类型。
另一个更隐蔽的问题是中文。json.dumps(d, ensure_ascii=False)才能保证不把中文转成\uXXXX转义序列。默认情况下ensure_ascii=True，输出的是转义后的ASCII码，可读性很差。处理日志和接口调试时，这个小细节很影响体验。
5. 新手最容易踩的坑：我踩过你也别踩
5.1 可变默认值的“著名陷阱”
写函数时参数默认值如果是可变类型，比如def f(a, d={})，会有一个大坑：默认值只在函数定义时创建一次，后续所有调用共享同一个字典对象。第一次调用往里加数据，第二次调用进来，看到的就是第一次调用改过之后的默认字典。
正确的写法是默认值写None，函数内部自行判断初始化：
def f(a, d=None): if d is None: d = {} ...这种写法也是我在简历写代码风格评审时必查的一项。别以为只是面试题，实际项目里真的会出现这种bug，而且特别难查，因为不是每次都炸，而是状态在调用之间累积。
5.2 遍历时修改字典
遍历字典的同时做增删操作，几乎都会触发RuntimeError。比如我想删掉值小于10的所有键：
for k, v in d.items(): if v < 10: del d[k] # 报错正确做法分两种。收集要删除的键，遍历结束后统一删除：
to_delete = [k for k, v in d.items() if v < 10] for k in to_delete: del d[k]或者用字典推导式直接生成新字典：
d = {k: v for k, v in d.items() if v >= 10}这里有个经验点：如果数据量很大，用推导式生成新字典更省事；如果还需要保留原对象的引用（比如其他变量也指向这个字典），就得选第一条路原地删除。
5.3 键不可哈希：list不能当键
这个问题前面提到过，再具体解释一下。字典查找依赖哈希值，而哈希值必须稳定。list、dict、set这些可变类型没有稳定的哈希值，Python直接拒绝。如果你真的需要“用一个序列当键”，可以改成元组：
d = {} key = (1, 2) d[key] = "value"注意，元组本身也不保证一定可哈希，如果元组内部包含list，这元组依然不可哈希。比如(1, [2, 3])就不能当键。这是新手比较容易忽略的深层细节。
5.4 浅拷贝和深拷贝
用d.copy()或者dict(d)做的是浅拷贝。浅拷贝只拷贝一层：外层是新字典，但值对象是共享的。如果值是list或dict，修改内层内容，原字典也会跟着变。
original = {"items": [1, 2, 3]} copied = original.copy() copied["items"].append(4) # original 里的 items 也变成了 [1, 2, 3, 4]如果需要完整隔离，用copy.deepcopy(d)。但deepcopy性能差，能不用尽量不用。我在工程里通常优先考虑：能不能通过重构，让每个值都用不可变类型？比如把list换成tuple，浅拷贝就足够用了。性能和数据安全有时候就是用这种简单的设计换来的。
5.5 合并时想保留原字典
一个隐藏的小坑：d2.update(d1)会修改d2，如果不想修改原字典，要写成new = d2.copy(); new.update(d1)。或者用{**d2, **d1}。很多人习惯性用update，结果把原始的配置字典改了，后面比较的时候发现怎么也对不上。
5.6 性能：别在循环里做多余操作
字典读取是O(1)，但也不是完全没有开销。在超大循环里，如果每次循环都去访问一个很长字典中的元素，虽然单次很快，但累计起来还是有差别。更关键的是，别在循环里反复调用d.keys()或者把d.items()转换成列表。items()返回的是视图，迭代它没问题，但如果每轮循环都转一次list，妥妥的浪费。
# 蠢写法：每次循环都生成列表 for item in list(d.items()): ... # 聪明写法：直接用视图迭代 for item in d.items(): ...当然，如果边遍历边修改，确实需要先转成列表副本，这是用例决定的。
6. 最后分享一点我的实际体会
写了这么多年Python，字典在我脑子里的定位早就不是“一种数据类型”那么简单，它更像是一种以映射思维组织数据的方式。遇到问题先想“能不能用键值对建模”，这个思路能解决很多看似复杂的逻辑。比如多条件查询，可以把查询条件构造成字典，再统一生成SQL参数；比如缓存计算结果，可以用参数组合作为键。几乎所有能用“索引”解决的问题，字典都是最趁手的工具。
另外，字典相关的模块和方法非常多，但刚开始学不用急着全记住。优先掌握创建、读取、遍历、推导式、解包、合并这几个核心操作，就足以覆盖绝大多数日常开发。随着代码量增大，defaultdict、Counter、dict.fromkeys、pop、setdefault这些自然会越用越熟。工具是给想用的人准备的，用的过程中理解它的底层逻辑，比硬背文档有效太多。
如果看完这篇想马上练手，我建议做三个小练习：第一，用一行字典推导式实现两个列表的键值配对；第二，用defaultdict把一组嵌套数据按某字段分组；第三，把一个字典按值从大到小排序，并输出前三个键。三个练习做完，你对字典的掌握绝对够用了。
