¿Qué hace que una clase definida por el usuario sea indestructible?

Question

El docs dice que una clase es manejable siempre que defina el método __hash__ y el método __eq__. Sin embargo:

class X(list): 
    # read-only interface of `tuple` and `list` should be the same, so reuse tuple.__hash__ 
    __hash__ = tuple.__hash__ 

x1 = X() 
s = {x1} # TypeError: unhashable type: 'X' 

¿Qué hace que X unhashable?

Tenga en cuenta que debo tener listas idénticas (en términos de igualdad regular) para ser hash con el mismo valor; de lo contrario, lo haré violate this requirement en funciones hash:

La única propiedad requerida es que los objetos que se comparan tienen la misma el mismo valor hash

Los documentos advierten de que un objeto hashable no debe ser modificado durante su vida útil y, por supuesto, no modifico las instancias de X después de la creación. Por supuesto, el intérprete no lo comprobará de todos modos.

Answer 1

Simplemente configurando el método __hash__ al de la clase tuple no es suficiente. En realidad, no le has dicho cómo hash de manera diferente. las tuplas son lavables porque son inmutables. Si realmente quería hacer que el trabajo ejemplo específico, podría ser así:

class X2(list): 
    def __hash__(self): 
     return hash(tuple(self)) 

En este caso, en realidad se está definiendo la forma en Hash su lista personalizada subclase. Solo tienes que definir exactamente cómo puede generar un hash. Puede hachís en lo que quieras, en lugar de utilizar el método de codificación de la tupla:

def __hash__(self): 
    return hash("foobar"*len(self)) 

Answer 2

Si usted no modifica las instancias de X después de la creación, ¿por qué no te subclassing par de valores?

Pero señalaré que esto realmente no arroja un error, al menos en Python 2.6.

>>> class X(list): 
...  __hash__ = tuple.__hash__ 
...  __eq__ = tuple.__eq__ 
... 
>>> x = X() 
>>> s = set((x,)) 
>>> s 
set([[]]) 

Vacilo en decir "funciona" porque esto no hace lo que usted piensa que hace.

>>> a = X() 
>>> b = X((5,)) 
>>> hash(a) 
4299954584 
>>> hash(b) 
4299954672 
>>> id(a) 
4299954584 
>>> id(b) 
4299954672 

Solo está utilizando la identificación del objeto como hash. Cuando realmente llama al __hash__, sigue recibiendo un error; del mismo modo para __eq__.

>>> a.__hash__() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: descriptor '__hash__' for 'tuple' objects doesn't apply to 'X' object 
>>> X().__eq__(X()) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: descriptor '__eq__' for 'tuple' objects doesn't apply to 'X' object 

deduzco que las partes internas de pitón, por alguna razón, están detectando que X tiene un __hash__ y un método __eq__, pero no están llamando a ellos.

La moraleja de todo esto es: simplemente escriba una función hash real. Como este es un objeto de secuencia, convertirlo en una tupla y hash es el enfoque más obvio.

def __hash__(self): 
    return hash(tuple(self)) 

Answer 3

Lo que podría y debería hacer, en base a su otra pregunta, es: no subclase nada, sólo encapsular una tupla. Está perfectamente bien hacerlo en el init.

class X(object): 
    def __init__(self, *args): 
     self.tpl = args 
    def __hash__(self): 
     return hash(self.tpl) 
    def __eq__(self, other): 
     return self.tpl == other 
    def __repr__(self): 
     return repr(self.tpl) 

x1 = X() 
s = {x1} 

que produce:

>>> s 
set([()]) 
>>> x1 
() 

Answer 4

A partir de los documentos python3:

Si una clase no define un método __eq __() no debe definir una operación de __hash __() ya sea ; si define __eq __() pero no __hash __(), sus instancias no serán utilizables como elementos en las colecciones hashable. Si una clase define objetos mutables e implementa un método __eq __(), no debería implementar __hash __(), ya que la implementación de colecciones hashable requiere que el valor hash de una clave sea inmutable (si el valor hash del objeto cambia, estará en el cubo de hash incorrecto).

Ref: object.__hash__(self)

Código de ejemplo:

class Hashable: 
    pass 

class Unhashable: 
    def __eq__(self, other): 
     return (self == other) 

class HashableAgain: 
    def __eq__(self, other): 
     return (self == other) 

    def __hash__(self): 
     return id(self) 

def main(): 
    # OK 
    print(hash(Hashable())) 
    # Throws: TypeError("unhashable type: 'X'",) 
    print(hash(Unhashable())) 
    # OK 
    print(hash(HashableAgain()))