真的有必要對相同的類進行哈希處理嗎？

Question

閱讀this answer看來，如果__eq__是在自定義類中定義的，則還需要定義__hash__。這是可以理解的。
但是目前尚不清楚，爲什麼 - 有效 - __eq__應該是相同self.__hash__()==other.__hash__

想象這樣一個類：

class Foo: 
    ... 
    self.Name 
    self.Value 
    ... 
    def __eq__(self,other): 
     return self.Value==other.Value 
    ... 
    def __hash__(self): 
     return id(self.Name) 

這樣的類實例可以通過值進行比較，這可能是唯一的合理使用，但被認爲是相同的名稱。
這種方式set不能包含名稱相同的多個實例，但比較仍然有效。

這樣的定義有什麼問題？

原因由Value定義__eq__，__lt__等是能夠通過Value以實例進行排序，並能夠使用功能，如最大值。例如，他的班級應代表設備的物理輸出（如加熱元件）。每個輸出都有唯一的名稱。值是輸出設備的功率。爲了找到加熱元件的最佳組合以便開啓，能夠通過功率（值）比較它們是有用的。但是，在一個集合或字典中，不應該有多個名稱相同的輸出。當然，不同名字的不同產出可能很容易擁有同等權力。

Answer 1

問題在於它沒有意義，散列用於執行對象的有效分區。因此，當你有一個散列表實現的集合時，每個散列指向一個存儲區，通常是一個元素列表。爲了檢查一個元素是否在集合（或其他基於散列的容器）中，您轉到由散列指向的桶，然後遍歷列表中的所有元素，逐個比較它們。

換句話說 - 哈希不應該是一個比較器（因爲它可以，並應該給你有時誤報）。特別是，在你的例子中，你的設置不起作用 - 它不會識別重複，因爲它們不會相互比較。

class Foo: 

    def __eq__(self,other): 
     return self.Value==other.Value 

    def __hash__(self): 
     return id(self.Name) 


a = set() 
el = Foo() 
el.Name = 'x' 
el.Value = 1 

el2 = Foo() 
el2.Name = 'x' 
el2.Value = 2 

a.add(el) 
a.add(el2) 
print len(a) # should be 1, right? Well it is 2 

實際上它是更糟糕的則是，如果你有2個對象具有相同的值，但不同的名稱，他們不認爲是相同的或者

class Foo: 

    def __eq__(self,other): 
     return self.Value==other.Value 

    def __hash__(self): 
     return id(self.Name) 


a = set() 
el = Foo() 
el.Name = 'x' 
el.Value = 2 

el2 = Foo() 
el2.Name = 'a' 
el2.Value = 2 

a.add(el) 
a.add(el2) 
print len(a) # should be 1, right? Well it is 2 again 

同時適當做（這樣「如果== b，則散列的（a）==散列（b）」）給出：

class Foo: 

    def __eq__(self,other): 
     return self.Name==other.Name 

    def __hash__(self): 
     return id(self.Name) 


a = set() 
el = Foo() 
el.Name = 'x' 
el.Value = 1 

el2 = Foo() 
el2.Name = 'x' 
el2.Value = 2 

a.add(el) 
a.add(el2) 
print len(a) # is really 1 

更新

有一個也是一個非確定性的部分，這是很難輕易再現，但基本上哈希並不唯一定義一個桶。通常它就像

bucket_id = hash(object) % size_of_allocated_memory 

因此，具有不同哈希的東西仍然可能在同一個桶中結束。因此，即使名稱是不同的，也可以通過其他方式取決於實際的內部實現，內存約束等，因此可以獲得與每個值（內部集合）相等的兩個元素。

一般有更多的例子，事情可以去錯了，因爲哈希是定義爲功能h : X -> Z這樣x == y => h(x) == h(y)，這樣的人實現自己的容器，授權協議和其他工具都是免費的，以承擔這屬性。如果你破壞它 - 每一個使用哈希的工具都可能中斷。此外，它可以在時間打破，這意味着你更新一些庫，你的代碼將停止工作，作爲一個有效的更新底層庫（使用上述的前提下），可能會導致利用你違反這個假設。

更新2

最後，爲了解決您的問題 - 你根本不應該定義你EQ，LT運營商來處理排序。它大約是元素的實際比較，它應該與其餘行爲兼容。所有你需要做的就是定義一個單獨的比較並在排序程序使用它（在Python分揀接受任何比較，你並不需要依靠<，>等）。另一種方法是改爲有效的<，>，=定義在值上，但爲了保持名稱的唯一性 - 保留一個集合，包括......好的名稱，而不是對象本身。無論你選擇哪條路徑 - 這裏的關鍵要素是： 等號和散列必須兼容，就是這樣。

Answer 2

這是可以實現這樣和不有任何問題，你的類。但是，您必須100％確定沒有兩個不同的對象會生成相同的散列。請看下面的例子：

class Foo: 
    def __init__(self, name, value): 
     self.name= name 
     self.value= value 

    def __eq__(self, other): 
     return self.value == other.value 

    def __hash__(self): 
     return hash(self.name[0]) 

s= set() 
s.add(Foo('a', 1)) 
s.add(Foo('b', 1)) 
print(len(s)) # output: 2 

但如果發生哈希衝突，你有一個問題：

s.add(Foo('abc', 1)) 
print(len(s)) # output: 2 

爲了防止這一點，你必須知道準確哈希值是如何生成的（其中，如果依靠像id或hash功能，可能會在實現之間有所不同！）以及用於生成散列（name在這個例子中）的屬性（S）也值。這就是爲什麼排除哈希碰撞的可能性非常困難，即使不是不可能的原因。這基本上像乞求意想不到的事情發生。