Objeto de tipo personalizado como clave de diccionario

¿Qué debo hacer para usar mis objetos de un tipo personalizado como claves en un diccionario de Python (donde no quiero que el "ID del objeto" actúe como la clave), por ejemplo?

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

Me gustaría usar MyThing como claves que se consideran iguales si el nombre y la ubicación son los mismos. Desde C # / Java estoy acostumbrado a tener que anular y proporcionar un método igual y de código hash, y prometo no mutar nada de lo que depende el código hash.

¿Qué debo hacer en Python para lograr esto? ¿Debo incluso?

(En un caso simple, como aquí, tal vez sería mejor simplemente colocar una tupla (nombre, ubicación) como clave, pero tenga en cuenta que me gustaría que la clave sea un objeto)

Necesita agregar 2 métodos , nota __hash__y __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 documentación de dict de Python define estos requisitos en los objetos clave, es decir, deben ser hashaable .

Se debe utilizar una alternativa en Python 2.6 o superior collections.namedtuple(): le ahorra escribir cualquier método especial:

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

Se anula __hash__si desea una semántica hash especial, __cmp__o __eq__para que su clase sea utilizable como clave. Los objetos que comparan igual deben tener el mismo valor hash.

Python espera __hash__devolver un número entero, Banana()no se recomienda regresar :)

Las clases definidas por el usuario tienen __hash__por defecto que las llamadas id(self), como usted notó.

Hay algunos consejos adicionales de la documentación :

Las clases que heredan un __hash__() método de una clase padre pero cambian el significado de __cmp__()o __eq__() tal que el valor hash devuelto ya no es apropiado (por ejemplo, al cambiar a un concepto de igualdad basado en el valor en lugar de la igualdad basada en la identidad predeterminada) pueden marcarse explícitamente como ser inconfundible estableciendo __hash__ = None en la definición de clase. Hacerlo significa que no solo las instancias de la clase generarán un TypeError apropiado cuando un programa intente recuperar su valor hash, sino que también se identificarán correctamente como no compartibles cuando se verifiquen isinstance(obj, collections.Hashable) (a diferencia de las clases que definen las suyas __hash__()para aumentar explícitamente TypeError).