编码细节。。。。。。

代码演示：在 Python 中人为制造哈希冲突

我们可以通过重写 __hash__ 方法，故意让不同的对象返回相同的哈希值，来看看会发生什么：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 故意让所有人的哈希值都是 1（制造极端的哈希冲突）
    def __hash__(self):
        return 1 

    # 只有名字和年龄都一样，才认为是同一个人
    def __eq__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return self.name == other.name and self.age == other.age

# 创建两个完全不同的人
p1 = Person("张三", 20)
p2 = Person("李四", 30)

print(f"p1 的哈希值: {hash(p1)}")  # 输出: 1
print(f"p2 的哈希值: {hash(p2)}")  # 输出: 1
print(f"哈希值相等吗？ {hash(p1) == hash(p2)}")  # 输出: True (哈希冲突！)

print(f"p1 和 p2 是同一个人吗？ {p1 == p2}")    # 输出: False (对象不相等！)

在这个例子中，p1 和 p2 的哈希值都是 1，但它们显然不是同一个人（p1 == p2 为 False）。这就是典型的哈希值相等，但对象不相等。

四、 核心解惑：发生冲突了，字典/集合怎么区分它们？

这才是理解 __hash__ 和 __eq__ 必须绑定的终极原因！

当 Python 的字典（dict）或集合（set）在底层存储数据时，如果遇到哈希冲突（即两个不同的对象算出了相同的哈希值，被分到了同一个“桶”里），它会按照以下流程处理：

1. 第一步：看哈希值（找桶） 字典通过 hash(obj) 算出哈希值，找到对应的“桶”（内存位置）。
2. 第二步：发现桶里已经有东西了（发现冲突） 字典发现这个位置已经被占用了。
3. 第三步：调用 __eq__ 进行“身份核实”（解决冲突） 字典会拿新来的对象，和桶里已有的对象进行 == 比较（底层调用 __eq__）。
   • 情况 A（__eq__ 返回 True）：字典认为“哦，这是同一个对象，只是来更新数据的”，于是覆盖旧值。
   • 情况 B（__eq__ 返回 False）：字典确认“这是哈希冲突！它们只是碰巧哈希值一样，其实是两个不同的对象”。于是，字典会在底层寻找下一个空闲的位置（这在底层算法中叫“开放寻址法”），把新对象存进去。

如果没有 __eq__ 会怎样？

如果你只写了 __hash__ 没写 __eq__，当发生哈希冲突时，字典就无法核实这两个对象到底是不是同一个。它可能会错误地把两个不同的对象当成同一个对象给覆盖掉，导致数据丢失！

1. __hash__ 是“粗筛”：它负责快速把对象分配到一个“大类”或“桶”里。哈希值相等，只说明它们可能是同一个对象，或者它们碰巧被分到了同一个桶里（哈希冲突）。
2. __eq__ 是“精查”：当“粗筛”发现冲突时，必须通过 __eq__ 进行精确比对。只有 __eq__ 返回 True，才代表对象真正相等。

这就是为什么我们常说：“对象相等（__eq__ 为 True），哈希值必须相等；但哈希值相等，对象不一定相等（可能是哈希冲突）。”在 Python 中，只有“不可变对象（Immutable）”才能被哈希，而元组（tuple）是 Python 内置的、最常用的、能容纳多个元素的不可变序列，

在 Python 中，一个对象要想能计算出哈希值（即能作为字典的 key 或放入 set 中），必须满足一个绝对前提：它的哈希值在生命周期内绝对不能改变。

• 可变对象（如 list, dict, set）：内容可以随时修改。如果允许它们计算哈希，一旦内容改变，哈希值就会变。这会导致它在字典中“丢失”（正如我们前面讨论过的）。因此，Python 直接禁止对它们求哈希。
• 不可变对象（如 int, str, tuple, frozenset）：创建后内容无法修改。因此它们的哈希值是稳定的，可以安全地被哈希。

当你有多个属性（比如 self.x 和 self.y）需要组合起来计算哈希时，你必须把它们放进一个“容器”里。这个容器本身必须是不可变的，元组（tuple）正是完美符合这一要求的内置容器。

x, y = 1, 2

# ✅ 成功：元组是不可变的，可哈希
print(hash((x, y)))

# ❌ 报错：列表是可变的，不可哈希
print(hash([x, y])) # TypeError: unhashable type: 'list'

# ❌ 报错：字典是可变的，不可哈希
print(hash({'x': x, 'y': y})) # TypeError: unhashable type: 'dict'

编写 __hash__ 的最佳实践：将参与 __eq__ 比较的属性打包成一个元组（tuple），然后对元组求哈希。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        # 规范写法：类型不匹配时返回 NotImplemented，而不是 False
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __hash__(self):
        # 将参与比较的属性组成元组，利用元组自带的哈希机制
        return hash((self.x, self.y))

p1 = Point(1, 2)
p2 = Point(1, 2)

print(p1 == p2)       # True
print(hash(p1) == hash(p2)) # True

# 现在可以完美放入集合和字典中
my_set = {p1, p2}
print(len(my_set))    # 输出: 1 (因为 p1 和 p2 相等且哈希相同，被去重了)