Objeto do tipo personalizado como chave do dicionário

O que devo fazer para usar meus objetos de um tipo personalizado como chaves em um dicionário Python (onde não quero que o "ID do objeto" atue como chave), por exemplo

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

Eu gostaria de usar o MyThing como chaves que são consideradas iguais se o nome e o local forem iguais. No C # / Java, estou acostumado a substituir e fornecer um método equals e hashcode e prometer não alterar nada do qual o hashcode dependa.

O que devo fazer em Python para fazer isso? Eu deveria mesmo?

(Em um caso simples, como aqui, talvez seja melhor colocar uma tupla (nome, localização) como chave - mas considere que eu gostaria que a chave fosse um objeto)

Você precisa adicionar 2 métodos , observação __hash__e __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)

A documentação do dict do Python define esses requisitos nos objetos principais, ou seja, eles devem ser laváveis .

Uma alternativa no Python 2.6 ou superior é usar collections.namedtuple()- você economiza escrevendo quaisquer métodos especiais:

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

Você substitui __hash__se deseja semântica hash especial e / __cmp__ou __eq__para tornar sua classe utilizável como chave. Objetos que comparam igual precisam ter o mesmo valor de hash.

Python espera __hash__retornar um número inteiro, Banana()não é recomendado retornar :)

As classes definidas __hash__pelo usuário têm como padrão as chamadas id(self), como você observou.

Existem algumas dicas extras na documentação .

Classes que herdam um __hash__() método de uma classe pai, mas alteram o significado de __cmp__()ou para __eq__() que o valor de hash retornado não seja mais apropriado (por exemplo, alternando para um conceito de igualdade baseado em valor em vez da igualdade baseada em identidade padrão) pode explicitamente se sinalizar como sendo lavável, definindo __hash__ = None na definição de classe. Fazer isso significa que não apenas as instâncias da classe gerarão um TypeError apropriado quando um programa tentar recuperar seu valor de hash, mas também serão identificadas corretamente como unhashable ao verificar isinstance(obj, collections.Hashable) (ao contrário das classes que se definem __hash__()para gerar explicitamente TypeError).