Objet de type personnalisé comme clé de dictionnaire

Que dois-je faire pour utiliser mes objets d'un type personnalisé comme clés dans un dictionnaire Python (où je ne veux pas que l '"identifiant d'objet" agisse comme clé), par exemple

class MyThing:
    def __init__(self,name,location,length):
            self.name = name
            self.location = location
            self.length = length

Je voudrais utiliser MyThing comme des clés considérées comme identiques si le nom et l'emplacement sont les mêmes. Depuis C # / Java, j'ai l'habitude de devoir remplacer et de fournir une méthode d'égalité et de hashcode, et je promets de ne pas muter quoi que ce soit dont le hashcode dépend.

Que dois-je faire en Python pour accomplir cela? Dois-je même?

(Dans un cas simple, comme ici, il serait peut-être préférable de simplement placer un tuple (nom, emplacement) comme clé - mais considérez que je voudrais que la clé soit un objet)

Vous devez ajouter 2 méthodes , notez __hash__et __eq__:

class MyThing:
    def __init__(self,name,location,length):
        self.name = name
        self.location = location
        self.length = length

    def __hash__(self):
        return hash((self.name, self.location))

    def __eq__(self, other):
        return (self.name, self.location) == (other.name, other.location)

    def __ne__(self, other):
        # Not strictly necessary, but to avoid having both x==y and x!=y
        # True at the same time
        return not(self == other)

La documentation Python dict définit ces exigences sur les objets clés, c'est-à-dire qu'ils doivent être hachables .

Une alternative dans Python 2.6 ou supérieur est d'utiliser collections.namedtuple()- cela vous évite d'écrire des méthodes spéciales:

from collections import namedtuple
MyThingBase = namedtuple("MyThingBase", ["name", "location"])
class MyThing(MyThingBase):
    def __new__(cls, name, location, length):
        obj = MyThingBase.__new__(cls, name, location)
        obj.length = length
        return obj

a = MyThing("a", "here", 10)
b = MyThing("a", "here", 20)
c = MyThing("c", "there", 10)
a == b
# True
hash(a) == hash(b)
# True
a == c
# False

Vous remplacez __hash__si vous voulez une sémantique de hachage spéciale, et / __cmp__ou __eq__afin de rendre votre classe utilisable comme clé. Les objets qui comparent la même valeur doivent avoir la même valeur de hachage.

Python s'attend __hash__à renvoyer un entier, le retour Banana()n'est pas recommandé :)

Les classes définies par l'utilisateur ont __hash__par défaut qui appelle id(self), comme vous l'avez noté.

Il y a quelques conseils supplémentaires dans la documentation .:

Les classes qui héritent d'une __hash__() méthode d'une classe parente mais changent la signification de __cmp__()ou de __eq__() telle sorte que la valeur de hachage retournée n'est plus appropriée (par exemple en passant à un concept d'égalité basé sur une valeur au lieu de l'égalité basée sur l'identité par défaut) peuvent se signaler explicitement comme étant indéchiffrable en définissant __hash__ = None dans la définition de classe. Cela signifie que non seulement les instances de la classe lèveront une TypeError appropriée lorsqu'un programme tente de récupérer leur valeur de hachage, mais qu'elles seront également correctement identifiées comme non hachables lors de la vérification isinstance(obj, collections.Hashable) (contrairement aux classes qui définissent les leurs __hash__()pour déclencher explicitement TypeError).