Come implementare una buona funzione __hash__ in python

Question

Quando si implementa una classe con proprietà multiple (come nell'esempio di esempio di seguito), qual è il modo migliore per gestire l'hashing?

Immagino che il __eq__ e il __hash__ debbano essere coerenti, ma come implementare una funzione di hash corretta in grado di gestire tutte le proprietà?

class AClass: 
    def __init__(self): 
     self.a = None 
     self.b = None 

    def __eq__(self, other): 
     return other and self.a == other.a and self.b == other.b 

    def __ne__(self, other): 
    return not self.__eq__(other) 

    def __hash__(self): 
     return hash((self.a, self.b)) 

ho letto su this question che tuple sono hashable, quindi mi chiedevo se qualcosa di simile l'esempio precedente era ragionevole. È?

Answer 1

__hash__ deve restituire lo stesso valore per gli oggetti che sono uguali. Inoltre, non dovrebbe cambiare durante la vita dell'oggetto; generalmente lo si implementa solo per oggetti immutabili.

Un'implementazione banale sarebbe a solo return 0. Questo è sempre corretto, ma si comporta male.

La soluzione, restituendo l'hash di una tupla di proprietà, è buona. Tuttavia, tieni presente che non è necessario elencare tutte le proprietà confrontate in __eq__ nella tupla. Se alcune proprietà di solito hanno lo stesso valore per oggetti ineguali, basta lasciarli fuori. Non rendere il calcolo hash più costoso di quello che deve essere.

Modifica: mi raccomando di non usare xor per mescolare gli hash in generale. Quando due proprietà differenti hanno lo stesso valore, avranno lo stesso hash e con xor queste si annulleranno a vicenda. Le tuple usano un calcolo più complesso per mescolare gli hash, vedere tuplehash in tupleobject.c.

Answer 2

documentazione per object.__hash__(self)

L'unica proprietà richiesta è che gli oggetti che risultano uguali hanno lo stesso valore di hash; si consiglia di mescolare in qualche modo (ad esempio usando esclusivi o) i valori hash per i componenti dell'oggetto che svolgono anche una parte nel confronto degli oggetti.

def __hash__(self): 
    return hash(self.a)^hash(self.b) 

Answer 3

E 'pericoloso scrivere

def __eq__(self, other): 
    return other and self.a == other.a and self.b == other.b 

perché se i tuoi RHS (vale a dire, other) oggetto restituisce Boolean false, non sarà mai confrontare come uguale a niente!

Inoltre, è possibile ricontrollare se other appartiene alla classe o sottoclasse di AClass. In caso contrario, riceverai l'eccezione AttributeError o un falso positivo (se l'altra classe ha gli stessi attributi con i valori corrispondenti). Quindi mi sento di raccomandare a riscrivere __eq__ come:

def __eq__(self, other): 
    return isinstance(other, self.__class__) and self.a == other.a and self.b == other.b 

Se per caso si vuole un confronto insolitamente flessibile, che si confronta attraverso le classi non correlate finché attributi partita per nome, si sarebbe ancora voglia di almeno evitare di AttributeError e controllare che other non abbia attributi aggiuntivi. Il modo in cui lo fai dipende dalla situazione (poiché non esiste un modo standard per trovare tutti gli attributi di un oggetto).