好的，咱们今天就来聊聊Python里自定义哈希函数这回事儿，也就是 __hash__ 这个魔法方法，以及它跟字典性能优化之间那些不得不说的故事。
开场白：哈希是个啥？字典为啥这么快？
各位观众，咱们先来热热身，搞清楚一个最基本的问题：哈希是啥玩意儿？ 简单来说，哈希就是把一个东西（在Python里，这“东西”就是对象）变成一个数字。 这个数字叫做哈希值。 重点是，同样的“东西”，无论什么时候算，算出来的哈希值都得一样。
那字典为啥这么快？ 想象一下，你有一本电话簿，你想找“张三”的电话号码， 如果电话簿是按姓名首字母排序的，你是不是就能很快找到？ 字典其实也差不多，它就是靠哈希值来快速定位的。 字典内部维护着一个哈希表，把键（key）的哈希值作为索引，直接指向对应的值（value）的内存地址。 这样，查找、插入、删除操作的时间复杂度基本上就是 O(1) 了，非常高效。
__hash__：掌控哈希值的钥匙
在Python里，每个对象都有一个哈希值，可以通过 hash() 函数来获取。 默认情况下，Python会根据对象的内存地址来生成哈希值。 但是，对于自定义的类，如果你想让它的实例能够作为字典的键（或者集合的元素），你就需要自己定义 __hash__ 方法。
为什么呢？ 因为字典要求键是不可变的（immutable）。 默认情况下，自定义类的实例是可变的，这意味着它们的哈希值可能会改变，这会导致字典的查找出现问题。 所以，我们需要自己告诉Python，这个类的实例的哈希值应该怎么算，并且保证在对象的生命周期内，这个哈希值是不变的。
代码示例：一个简单的自定义类
咱们先来看一个最简单的例子：
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2) # 输出 True，因为默认情况下，== 比较的是对象的内存地址
print(hash(p1)) # 报错：TypeError: unhashable type: 'Point'这段代码会报错，因为 Point 类没有定义 __hash__ 方法，所以它的实例是不可哈希的。
定义 __hash__ 和 __eq__：缺一不可的黄金搭档
如果你要自定义 __hash__ 方法，你必须同时自定义 __eq__ 方法。 这是因为，如果两个对象相等（p1 == p2 为 True），那么它们的哈希值必须相等。 反之，如果两个对象的哈希值不相等，那么它们一定不相等。
所以，咱们来完善一下 Point 类：
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __eq__(self, other):
if not isinstance(other, Point):
return False
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)) # 输出一个哈希值，例如 8706120305987641724
print(hash(p2)) # 输出相同的哈希值，例如 8706120305987641724
# 现在可以用 Point 实例作为字典的键了
my_dict = {p1: "point1", p2: "point2"}
print(my_dict[p1]) # 输出 point1
print(my_dict[p2]) # 输出 point1, 因为 p1 和 p2 相等，所以它们指向同一个键这段代码的关键在于 __hash__ 方法。 我们使用了一个元组 (self.x, self.y) 来生成哈希值。 元组是不可变的，所以它的哈希值也是不变的。 这样就保证了 Point 实例的哈希值在对象的生命周期内是不变的。
哈希冲突：甜蜜的烦恼
即使你定义了 __hash__ 方法，仍然有可能出现哈希冲突。 哈希冲突是指不同的对象生成了相同的哈希值。 当哈希冲突发生时，字典会使用一些解决冲突的策略，例如开放寻址法或链地址法。
哈希冲突会降低字典的性能，因为字典需要花更多的时间来查找键。 所以，一个好的哈希函数应该尽可能地减少哈希冲突。
代码示例：一个更复杂的例子
咱们再来看一个更复杂的例子：
class Student:
def __init__(self, name, age, courses):
self.name = name
self.age = age
self.courses = tuple(sorted(courses)) # 确保课程列表的顺序不变
def __eq__(self, other):
if not isinstance(other, Student):
return False
return (self.name == other.name and
self.age == other.age and
self.courses == other.courses)
def __hash__(self):
return hash((self.name, self.age, self.courses))
student1 = Student("Alice", 20, ["Math", "Physics", "Chemistry"])
student2 = Student("Alice", 20, ["Chemistry", "Physics", "Math"]) # 课程顺序不同，但应该相等
print(student1 == student2) # 输出 True
print(hash(student1))
print(hash(student2)) #相同的哈希值
student_dict = {student1: "Student 1", student2: "Student 2"} #实际上会被覆盖
print(student_dict[student1])在这个例子中，Student 类有三个属性：name、age 和 courses。 courses 是一个列表，但是为了保证哈希值的不变性，我们把它转换成了一个排序后的元组。 这样，即使课程的顺序不同，只要课程的内容相同，Student 实例的哈希值也是一样的。
性能优化：让哈希函数更快更高效
一个好的哈希函数应该具备以下几个特点：
- 一致性（Consistency）: 相同的对象必须生成相同的哈希值。
- 均匀性（Uniformity）: 哈希值应该均匀分布，避免大量的哈希冲突。
- 高效性（Efficiency）: 哈希函数的计算速度要快，不能成为性能瓶颈。
以下是一些优化哈希函数的技巧：
- 使用内置的哈希函数: Python内置的
hash()函数已经做了很多优化，尽量利用它。 - 避免使用可变对象: 尽量使用不可变对象来生成哈希值，例如元组、字符串、数字等。
- 使用位运算: 位运算通常比算术运算更快，可以用来混合哈希值。
- 使用缓存: 如果哈希函数的计算成本很高，可以考虑使用缓存来存储已经计算过的哈希值。
代码示例：使用位运算优化哈希函数
class MyObject:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def __eq__(self, other):
if not isinstance(other, MyObject):
return False
return (self.a == other.a and
self.b == other.b and
self.c == other.c)
def __hash__(self):
# 使用位运算混合哈希值
h = hash(self.a)
h = h ^ (hash(self.b) << 1) # 左移一位
h = h ^ (hash(self.c) >> 1) # 右移一位
return h在这个例子中，我们使用位运算 ^（异或）、<<（左移）和 >>（右移）来混合三个属性的哈希值。 这样可以使哈希值更加均匀，减少哈希冲突。
表格总结：哈希函数设计的要点
| 特性 | 描述 |
|---|
__slots__：节省内存的独门秘籍
__slots__ 是Python类中的一个特殊属性，它可以用来限制类实例动态添加属性，从而节省内存空间。 当你定义了 __slots__，Python就不会使用字典来存储实例的属性，而是使用一种更紧凑的内部表示。 这可以显著减少内存占用，特别是当你有大量实例时。
class MyClass:
__slots__ = ['name', 'age', 'city']
def __init__(self, name, age, city):
self.name = name
self.age = age
self.city = city
obj = MyClass("Bob", 30, "New York")
#obj.country = "USA" # 报错：AttributeError: 'MyClass' object has no attribute 'country'使用 __slots__ 的一些注意事项：
- 不能动态添加属性: 一旦定义了
__slots__，你就不能再动态地给实例添加新的属性了。 - 多重继承: 如果一个类继承自多个类，并且这些类都定义了
__slots__，那么需要小心处理，以免出现命名冲突。 - 类级别的属性:
__slots__只影响实例的属性，不影响类级别的属性。
总结：自定义哈希函数的最佳实践
- 同时定义
__eq__和__hash__: 这是铁律！ - 保证一致性: 如果两个对象相等，它们的哈希值必须相等。
- 尽量使用不可变对象: 避免使用可变对象来生成哈希值。
- 优化哈希函数: 使哈希函数尽可能高效，并减少哈希冲突。
- 考虑使用
__slots__: 如果你的类有很多实例，并且不需要动态添加属性，可以考虑使用__slots__来节省内存。
结束语：哈希虽小，影响很大
各位，今天咱们聊了Python自定义哈希函数 __hash__，以及它对字典性能的影响。 虽然哈希函数看起来很小，但它在Python的底层起着至关重要的作用。 一个好的哈希函数可以提高字典的性能，节省内存，让你的代码更加高效。 希望今天的分享对你有所帮助！
记住，编程就像烹饪，需要用心调味，才能做出美味佳肴。 哈希函数就是那关键的调味品，用好了，你的代码也能香气四溢！