¿Cuál es una forma correcta y buena de implementar __hash __ ()?

¿Cuál es una forma correcta y buena de implementar __hash__()?

Estoy hablando de la función que devuelve un código hash que luego se usa para insertar objetos en tablas hash, también conocidos como diccionarios.

Como __hash__()devuelve un entero y se usa para "agrupar" objetos en tablas hash, supongo que los valores del entero devuelto deben distribuirse uniformemente para los datos comunes (para minimizar las colisiones). ¿Qué es una buena práctica para obtener esos valores? ¿Las colisiones son un problema? En mi caso, tengo una clase pequeña que actúa como una clase contenedor que contiene algunas entradas, algunos flotadores y una cadena.

Una manera fácil y correcta de implementar __hash__()es usar una tupla clave. No será tan rápido como un hash especializado, pero si lo necesita, probablemente debería implementar el tipo en C.

Aquí hay un ejemplo del uso de una clave para hash e igualdad:

class A:
    def __key(self):
        return (self.attr_a, self.attr_b, self.attr_c)

    def __hash__(self):
        return hash(self.__key())

    def __eq__(self, other):
        if isinstance(other, A):
            return self.__key() == other.__key()
        return NotImplemented

Además, la documentación de__hash__ tiene más información, que puede ser valiosa en algunas circunstancias particulares.

John Millikin propuso una solución similar a esta:

class A(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        return (isinstance(othr, type(self))
                and (self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))

    def __hash__(self):
        return hash((self._a, self._b, self._c))

El problema con esta solución es que el hash(A(a, b, c)) == hash((a, b, c)). En otras palabras, el hash choca con el de la tupla de sus miembros clave. Tal vez esto no importa muy a menudo en la práctica?

Actualización: los documentos de Python ahora recomiendan usar una tupla como en el ejemplo anterior. Tenga en cuenta que la documentación indica

La única propiedad requerida es que los objetos que comparan igual tienen el mismo valor hash

Tenga en cuenta que lo contrario no es cierto. Los objetos que no se comparan igual pueden tener el mismo valor hash. Tal colisión de hash no hará que un objeto reemplace a otro cuando se use como una clave dict o elemento de ajuste , siempre que los objetos no se comparen igual .

Solución desactualizada / mala

La documentación de Python__hash__ sugiere combinar los hashes de los subcomponentes usando algo como XOR , lo que nos da esto:

class B(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        if isinstance(othr, type(self)):
            return ((self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))
        return NotImplemented

    def __hash__(self):
        return (hash(self._a) ^ hash(self._b) ^ hash(self._c) ^
                hash((self._a, self._b, self._c)))

Actualización: como señala Blckknght, cambiar el orden de a, byc podría causar problemas. Agregué un adicional ^ hash((self._a, self._b, self._c))para capturar el orden de los valores que se están dividiendo. Este final ^ hash(...)se puede eliminar si los valores que se combinan no se pueden reorganizar (por ejemplo, si tienen diferentes tipos y, por lo tanto, el valor de _anunca se asignará a _bo _c, etc.).

Paul Larson de Microsoft Research estudió una amplia variedad de funciones hash. Él me dijo eso

for c in some_string:
    hash = 101 * hash  +  ord(c)

funcionó sorprendentemente bien para una amplia variedad de cuerdas. Descubrí que técnicas polinómicas similares funcionan bien para calcular un hash de subcampos dispares.

Puedo intentar responder la segunda parte de tu pregunta.

Las colisiones probablemente serán el resultado del código hash en sí mismo, sino de la asignación del código hash a un índice en una colección. Entonces, por ejemplo, su función hash podría devolver valores aleatorios de 1 a 10000, pero si su tabla hash solo tiene 32 entradas, obtendrá colisiones al insertarlas.

Además, pensaría que las colisiones serían resueltas internamente por la colección, y existen muchos métodos para resolver las colisiones. Lo más simple (y lo peor) es, dada una entrada para insertar en el índice i, agregar 1 a i hasta que encuentre un lugar vacío e insertar allí. La recuperación entonces funciona de la misma manera. Esto da como resultado recuperaciones ineficientes para algunas entradas, ya que podría tener una entrada que requiera recorrer toda la colección para encontrarla.

Otros métodos de resolución de colisiones reducen el tiempo de recuperación al mover las entradas en la tabla hash cuando se inserta un elemento para distribuir las cosas. Esto aumenta el tiempo de inserción pero supone que lee más de lo que inserta. También hay métodos que intentan ramificar diferentes entradas en colisión para que las entradas se agrupen en un lugar en particular.

Además, si necesita cambiar el tamaño de la colección, deberá volver a mostrar todo o usar un método de hashing dinámico.

En resumen, dependiendo de lo que esté usando el código hash, es posible que deba implementar su propio método de resolución de colisiones. Si no los está almacenando en una colección, probablemente pueda salirse con la suya con una función hash que solo genera códigos hash en un rango muy amplio. Si es así, puede asegurarse de que su contenedor sea más grande de lo que debe ser (cuanto más grande mejor, por supuesto) dependiendo de sus problemas de memoria.

Aquí hay algunos enlaces si le interesa más:

hashing combinado en wikipedia

Wikipedia también tiene un resumen de varios métodos de resolución de colisiones:

Además, " Organización y procesamiento de archivos " de Tharp cubre una gran cantidad de métodos de resolución de colisiones. OMI es una gran referencia para algoritmos de hash.

Una muy buena explicación sobre cuándo y cómo implementar la __hash__función en el sitio web programiz :

Solo una captura de pantalla para proporcionar una descripción general: (Consultado el 13/12/2019)

En cuanto a una implementación personal del método, el sitio mencionado anteriormente proporciona un ejemplo que coincide con la respuesta de millerdev .

class Person:
def __init__(self, age, name):
    self.age = age
    self.name = name

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

def __hash__(self):
    print('The hash is:')
    return hash((self.age, self.name))

person = Person(23, 'Adam')
print(hash(person))

Depende del tamaño del valor hash que devuelva. Es una lógica simple que si necesita devolver un 32bit int basado en el hash de cuatro entradas de 32bit, obtendrá colisiones.

Yo favorecería las operaciones bit. Como el siguiente pseudocódigo C:

int a;
int b;
int c;
int d;
int hash = (a & 0xF000F000) | (b & 0x0F000F00) | (c & 0x00F000F0 | (d & 0x000F000F);

Tal sistema también podría funcionar para flotantes, si simplemente los toma como su valor de bit en lugar de representar realmente un valor de punto flotante, tal vez sea mejor.

Para las cadenas, tengo poca / ninguna idea.