python3自定义类：重写eq和hash函数

痛定思痛。 2022-05-21 09:14 174阅读 0赞

# 介绍\_\_eq\_\_和\_\_hash\_\_ #

python3中，在set，frozenset，dict这三种数据结构中，都要求键值key是可hash的，因为要保证key的唯一性。  
而\_\_hash\_\_实际上是返回一个int值，用来唯一标记这个对象。  
用户自定义类中，如果你没有实现\_\_eq\_\_和\_\_hash\_\_函数，那么class会继承到默认的\_\_eq\_\_和\_\_hash\_\_函数。如下：

class Vertex:
        #顶点类
        def __init__(self,vid):
            self.vid = vid
    
    v1=Vertex(1)
    v2=Vertex(2)
    v3=Vertex(3)
    
    print(set([v1,v2,v3]))

![这里写图片描述][20180704131202559]  
虽然没有实现，但加入set中也不会报错，因为继承了默认的\_\_eq\_\_和\_\_hash\_\_函数。  
默认的\_\_eq\_\_和\_\_hash\_\_应该是如下（没找到源码在哪个py文件里，但看了官方文档，就是这个意思）：

def __hash__(self):
            return hash(id(self))
        def __eq__(self, other):
            if isinstance(other, self.__class__):
                return hash(id(self))==hash(id(other))
            else:
                return False

# 深入理解\_\_eq\_\_和\_\_hash\_\_ #

可哈希的集合（hashed collections），需要集合的元素实现了\_\_eq\_\_和\_\_hash\_\_，而这两个方法可以作一个形象的比喻：  
哈希集合就是很多个桶，但每个桶里面只能放一个球。  
\_\_hash\_\_函数的作用就是找到桶的位置，到底是几号桶。  
\_\_eq\_\_函数的作用就是当桶里面已经有一个球了，但又来了一个球，它声称它也应该装进这个桶里面（\_\_hash\_\_函数给它说了桶的位置），双方僵持不下，那就得用\_\_eq\_\_函数来判断这两个球是不是相等的（equal），如果是判断是相等的，那么后来那个球就不应该放进桶里，哈希集合维持现状。

class Foo:
        def __init__(self, item):
            self.item = item
    
        def __eq__(self, other):
            print('使用了equal函数的对象的id',id(self))
            if isinstance(other, self.__class__):
                return self.__dict__ == other.__dict__
            else:
                return False
        def __hash__(self):
            print('f'+str(self.item)+'使用了hash函数')
            return hash(self.item)       
    f1 = Foo(1)
    f2 = Foo(2)
    f3 = Foo(3)
    fset = set([f1, f2, f3])
    print(fset)
    print()
    f = Foo(3)
    fset.add(f)
    print('f3的id:',id(f3))
    print('f的id:',id(f))

![这里写图片描述][20180704133238195]  
可见，在将f1,f2,f3加入到set中时，每次都会调用一次\_\_hash\_\_函数。  
由于我定义的\_\_hash\_\_函数是`return hash(self.item)`，所以f和f3找到的桶的位置是同一个位置，因为它俩的item是相同的。当执行`fset.add(f)`时，f就会调用它自身的`__hash__`函数，以找到f所属于的桶的位置。但此时桶里已经有别的球了，所以这时候就得用上`__eq__`来判断两个对象是否相等，从输出可以看出，是已有对象调用`__eq__`来和后来的对象进行比较（看对象的id）。  
这里如果是删除操作`fset.remove(Foo(3))`，道理也是一样，先用hash找到桶的位置，如果桶里有球，就判断这两个球是否相等，如果相等就把桶里那个球给扔掉。

# 官方文档 #

官方文档地址：[Data Model-python3][]。

> Called by built-in function hash() and for operations on members of hashed collections including set, frozenset, and dict. **hash**() should return an integer. The only required property is that objects which compare equal have the same hash value; it is advised to mix together the hash values of the components of the object that also play a part in comparison of objects by packing them into a tuple and hashing the tuple. Example:  
> def **hash**(self):  
> return hash((self.name, self.nick, self.color))

当可哈希集合（set,frozenset,dict）调用hash函数时，应该返回一个int值。唯一的要求就是，如果判断两个对象相等，那么他们的hash值也应该相等。当比较两个对象相等时是使用对象的成员来比较时，建议要把成员弄进元祖里，再得到这个元祖的hash值来比较。

> If a class does not define an **eq**() method it should not define a **hash**() operation either; if it defines **eq**() but not **hash**(), its instances will not be usable as items in hashable collections. If a class defines mutable objects and implements an **eq**() method, it should not implement **hash**(), since the implementation of hashable collections requires that a key’s hash value is immutable (if the object’s hash value changes, it will be in the wrong hash bucket).

当class没有定义\_\_eq\_\_()方法时，那么它也不应该定义\_\_hash\_\_()方法。如果它定义了\_\_eq\_\_()方法，却没有定义\_\_hash\_\_()方法，那么这个类的实例就不能在可哈希集合使用。如果一个类定义了一个可变对象（这里应该是指class的成员之一为可变对象），且implement了\_\_eq\_\_()方法，那么这个类就不应该implement \_\_hash\_\_()方法，因为可哈希对象的实现（implement ）要求键值key的hash值是不变的（如果一个对象的hash值改变了，那么它会被放在错误的hash桶里）

> User-defined classes have **eq**() and **hash**() methods by default; with them, all objects compare unequal (except with themselves) and x.**hash**() returns an appropriate value such that x == y implies both that x is y and hash(x) == hash(y).

用户定义的类中都有默认的\_\_eq\_\_和\_\_hash\_\_方法；有了它，所有的对象实例都是不等的（除非是自己和自己比较），在做x == y比较时是和这个等价的hash(x) == hash(y)。

# 只实现\_\_eq\_\_（错误示范） #

class Foo:
        def __init__(self, item):
            self.item = item
    
        def __eq__(self, other):
            if isinstance(other, self.__class__):
                return self.__dict__ == other.__dict__
            else:
                return False
    
    f1 = Foo(1)
    f2 = Foo(1)
    f3 = Foo(1)
    print(set([f1, f2, f3]))

![这里写图片描述][20180704135747736]

[20180704131202559]: /images/20220521/480da78cfa9943c495f14f0766f7d153.png
[20180704133238195]: /images/20220521/e2b91cde44fb43a79157cc5c7ba1a51a.png
[Data Model-python3]: https://docs.python.org/3/reference/datamodel.html#object.__hash__
[20180704135747736]: /images/20220521/591dcd1ff9bf40acbff46ce8ee30d40f.png