python3自定义类：重写__eq__和__hash__函数

介绍__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]))

虽然没有实现，但加入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))

可见，在将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]))