🚀 Python 哈希机制详解

哈希（Hash）是 Python 中实现高效数据结构（如字典、集合）的基础。理解哈希机制有助于写出更高效、更正确的代码。

📌 本节要点

hash() vs hashlib：hash() 用于快速查找（dict/set），hashlib 用于安全校验
可哈希 = 不可变：对象生命周期内哈希值固定，且能进行相等性比较
三大场景：字典键、集合元素、缓存机制
自定义类：重写 __eq__ 必须同时处理 __hash__，否则实例不可哈希
大文件哈希：复杂度 O(n)，瓶颈在 I/O，永远使用分块读取 :::

安全警告

绝对禁止用内置 hash() 做密码哈希或文件安全校验！

哈希机制快速体验

什么是哈希值？

哈希值是通过特定算法将任意大小的数据映射成的固定大小的整数，相当于数据的 "数字指纹"。

在 Python 中，哈希有两条完全不同的赛道：

维度	内置 `hash()`	密码学哈希 (`hashlib`)
目的	快速查找 (dict/set)	安全验证、完整性校验
速度	极快 (纳秒级)	较慢 (微秒~毫秒级)
稳定性	❌ 每次启动随机化	✅ 标准化，全球一致
典型用途	字典键、集合、缓存	签名、校验、密码、区块链

安全警告

绝对禁止用内置 hash() 做密码哈希或文件安全校验！

什么是"可哈希" (Hashable)？

可哈希是指一个对象在其生命周期内拥有固定不变的哈希值，且能进行相等性比较。核心公式：可哈希 = 有稳定的"身份证号" + 能判断是否相等。

准入条件

实现 __hash__() 返回整数。
实现 __eq__() 支持比较。
哈希值终身不变（因此可变对象如 list/dict/set 默认不可哈希）。

核心作用：三大场景

Python
# 🔑 1. 作为 dict 的键 (O(1) 查找)
cache = {"user_1": "Alice", (2024, 1): "Jan", frozenset({1,2}): True}

# 🔍 2. 作为 set 的元素 (O(1) 去重)
unique = {1, "hello", (3, 4), frozenset({5, 6})}

# ⚡ 3. 缓存机制 (如 lru_cache)
from functools import lru_cache
@lru_cache()
def compute(tags): pass
compute(frozenset({"a", "b"}))  # ✅ 必须传入可哈希对象

哈希表工作原理

字典（dict）和集合（set）底层使用哈希表实现 O(1) 的查找性能：

自定义类的避坑指南

💡 黄金法则：如果重写了 __eq__，必须同时处理 __hash__（提供一致实现或显式设为 None）。

Python
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    # ✅ 不可变语义：同时定义 eq 和 hash
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    def __hash__(self):
        return hash((self.x, self.y))

可变对象不可哈希

如果一个对象是可变的（如 list、dict、set），它的哈希值可能会改变，因此不能作为字典的键或集合的元素。尝试这样做会抛出 TypeError。

哈希计算为什么快？大文件呢？

为什么快？

固定输出：无论输入多大，输出长度固定（如 SHA-256 恒为 32 字节）。
纯位运算：只有 XOR、移位等 CPU 单周期指令，且有硬件指令集加速。

大文件也快吗？

真相：时间复杂度永远是 O(n)，必须读取每个字节。
瓶颈：通常在 磁盘 I/O 而非 CPU。
最佳实践：永远分块读取，保持内存占用恒定。

Python
import hashlib

def hash_large_file(path):
    h = hashlib.sha256()
    # ✅ 每次只读 1MB，100GB 文件也只需几 MB 内存
    with open(path, 'rb') as f:
        while chunk := f.read(1024 * 1024):
            h.update(chunk)
    return h.hexdigest()

实战：自定义可哈希类

Python
from __future__ import annotations
from typing import Hashable


class UserID(Hashable):
    """用户ID类，支持作为字典键。"""
    
    def __init__(self, id: int, prefix: str = "user"):
        self._id = id
        self._prefix = prefix
    
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, UserID):
            return NotImplemented
        return self._id == other._id and self._prefix == other._prefix
    
    def __hash__(self) -> int:
        return hash((self._prefix, self._id))
    
    def __repr__(self) -> str:
        return f"UserID({self._prefix}:{self._id})"


# 使用示例
cache: dict[UserID, str] = {}
alice = UserID(1)
cache[alice] = "Alice"

# 相同 ID 的对象可以访问同一个缓存项
alice2 = UserID(1)
print(cache[alice2])  # Alice（因为 __eq__ 和 __hash__ 一致）