一、基础知识
字典(dict)是 Python 里最常用的数据结构之一,它以"键 → 值"的形式存储数据,并且查找速度非常快。这种快速并非偶然,而是来自一种叫哈希表的机制。
简单理解哈希表:字典内部维护一张表,当你存入 d[key] = value 时,Python 会调用 hash(key) 得到一个数字,再用这个数字算出数据该放在表的哪个位置。查找 d[key] 时重复同样的计算,就能直接定位,而不必从头到尾逐个比较——这就是字典查询快的原因。
由此可以得出两个重要结论。
第一,键必须可哈希。 "可哈希"意味着对象有一个在其生命周期内不变的哈希值,并且能与其他对象比较是否相等。Python 中用 __hash__ 方法返回哈希值,用 __eq__ 方法判断相等。字符串、数字、元组(且内部元素都可哈希)都是可哈希的;列表、字典、集合因为是可变的,内容一变哈希值就该变,这会破坏哈希表的定位逻辑,所以被设计为不可哈希——把它们当键会直接报 TypeError。
需要澄清一个常见误解:哈希值不要求全局唯一。两个不同的对象可以有相同的哈希值,这叫哈希冲突。字典内部会用"开放寻址"等方式妥善处理冲突,只是冲突多了性能会下降。
第二,字典顺序是稳定的。 从 Python 3.7 起,语言层面保证字典会保留插入顺序——先插入的键,遍历时先出现。更早的版本中,CPython 3.6 已按插入顺序存储,但这属于实现细节;3.5 及以前不保证顺序;3.7 起才成为语言规范。需要强调的是,"有顺序"不等于"按大小排序",它只是记住了你放入的先后。
二、实操步骤
第 1 步:验证基本查找与键类型
d = {"name": "小明", "age": 18}
print(d["name"])
print(hash("name")) # 字符串的哈希值
第 2 步:看到不可哈希的错误
d = {}
try:
d[[1, 2]] = "value" # 用列表当键
except TypeError as e:
print("报错:", e) # unhashable type: 'list'
再用元组替换列表,就能正常工作:
d[(1, 2)] = "value" # 元组可哈希(前提是元素都可哈希)
print(d[(1, 2)])
第 3 步:验证插入顺序稳定
d = {}
d["第一"] = 1
d["第二"] = 2
d["第三"] = 3
print(list(d.keys())) # ['第一', '第二', '第三']
注意:如果你需要一个内容按大小排序的字典,那不是普通 dict 的职责,可以用 sorted() 配合处理,或在合适场景使用有序容器(具体选型以官方文档为准)。
第 4 步:验证"内部含可变元素的元组也不可哈希"
key = ("a", [1, 2]) # 元组里含列表
try:
print(hash(key))
except TypeError as e:
print("报错:", e) # unhashable type: 'list'
这说明"元组可哈希"是有条件的:所有元素都必须可哈希。
第 5 步:自定义对象作键
默认情况下,你自己定义的类实例是可哈希的(基于对象身份):
class Point:
def __init__(self, x, y):
self.x, self.y = x, y
p = Point(1, 2)
d = {p: "原点附近"}
print(Point(1, 2) == p) # False —— 两个对象身份不同,默认按身份比较
此时若用新对象作键 d[Point(1, 2)] 会抛 KeyError,因为默认 __hash__ 基于对象身份,两个对象的哈希不同,字典无法定位到原来的条目。
如果想让"值相等的点"视为同一个键,需要同时实现 __eq__ 和 __hash__:
class Point:
def __init__(self, x, y):
self.x, self.y = x, y
def __eq__(self, other):
return isinstance(other, Point) and (self.x, self.y) == (other.x, other.y)
def __hash__(self):
return hash((self.x, self.y))
d = {Point(1, 2): "A"}
print(d[Point(1, 2)]) # A —— 值相等即命中
关键规则:一旦实现了 __eq__,Python 默认会把 __hash__ 设为 None(即变成不可哈希),所以必须显式地把两者一起实现。
第 6 步:观察哈希冲突(示意)
# 自定义类可以让不同对象返回相同哈希,用于理解冲突
class AlwaysSame:
def __hash__(self):
return 1
def __eq__(self, other):
return self is other # 只有同一个对象才相等
a, b = AlwaysSame(), AlwaysSame()
d = {a: "A", b: "B"}
print(len(d)) # 2 —— 哈希同为 1(冲突),但 a、b 不相等,两个键共存
补充说明:若两个对象的哈希相同、且 __eq__ 判定它们相等,字典会视为同一个键,后写入的值会覆盖先前的值(此时 len(d) 就是 1)。这里让 __eq__ 用 self is other,正是为了让 a、b 不相等,从而观察冲突下两个键共存。
三、关键细节
- 哈希值在对象生命周期内不能变:所以参与哈希计算的字段不要随意修改,否则对象在字典里就"找不到了"。
__eq__与__hash__必须配套:相等的对象必须有相等的哈希值,这是哈希表正确工作的前提。- 顺序稳定是语言承诺:从 Python 3.7 起可依赖插入顺序,但不要把它当成"排序功能"来用。
- 可变对象当键的替代方案:若确实需要用列表内容作键,可先转成元组;需要可变映射语义时,考虑用能表达你意图的自定义类型。
- 哈希冲突不可避免:设计时不用追求"零冲突",但应避免让大量对象返回同一个哈希值,否则字典会退化为低效查找。
四、常见错误
| 现象 | 原因 | 修正 |
|---|---|---|
unhashable type: 'list' |
用列表、字典或集合当键 | 转成元组或字符串等可哈希类型 |
| 元组当键仍报不可哈希 | 元组内部含有列表等可变元素 | 确保元组所有元素都可哈希 |
| 自定义对象放进字典后取不出来 | 实现了 __eq__ 却忘了 __hash__ |
同时实现两个方法,且保证相等对象哈希相等 |
| 修改对象字段后查不到它 | 参与哈希的字段被改,哈希值随之改变 | 把作键的对象设计为不可变,或改键前先删除旧条目 |
| 以为字典会按大小排序 | 混淆了"插入顺序"与"排序" | 需要排序时显式使用 sorted() |
| 字典遍历顺序"莫名变化" | 运行在 3.5 及以前(不保证顺序),或误把实现细节当成保证 | CPython 3.6 已按插入顺序存储但属实现细节;3.5 及以前不保证顺序;3.7 起成为语言规范,需要顺序保证请升级到 3.7+ |
五、排查方法
遇到字典相关的诡异问题,按此顺序排查:
- 看报错类型:出现
unhashable type,直接锁定"用了不可哈希的键"。 - 打印键的类型:
print(type(key))与print(hash(key)),确认它是否可哈希。 - 检查嵌套:若键是元组,逐个元素执行
hash(),找出不可哈希的那个元素。 - 检查自定义类:确认是否同时定义了
__eq__和__hash__,且两者逻辑一致。 - 验证相等与哈希的一致性:对两个"应该相等"的对象,检查
a == b为真时hash(a) == hash(b)是否也成立。 - 检查是否被修改:确认对象放入字典后,参与哈希的字段有没有被改动。
- 确认 Python 版本:
python --version,核对顺序相关行为所依赖的版本基线。
六、注意事项
- 顺序保证的版本基线以官方文档为准:本文所述"字典保留插入顺序"从 Python 3.7 起成为语言保证,具体细节请查阅对应版本的官方文档。
- 不要依赖哈希值的具体数字:哈希值在不同运行之间可能变化(出于安全考虑,字符串等类型的哈希会被随机化),只用它做相等性比较,不要持久化保存。
- 性能结论自己测:字典操作的复杂度特性是语言层面的,但具体耗时因数据和运行环境而异,本文不给出具体数字。
- 可变对象作键的"高级玩法"需谨慎:通过让类可变但保持哈希不变来当键,容易引入难以察觉的 bug,初中级阶段不建议。
- 安全提示:处理来自不可信输入的键时,注意字典构造可能造成内存消耗,对超大输入做好长度限制,避免资源被耗尽。
免责声明:本文为个人学习与实操经验总结,仅代表个人观点,不构成任何技术或商业决策建议。不同系统环境与版本可能存在差异,实际操作请以官方文档为准并自行验证。

评论
还没有评论,来说两句吧。