Какой правильный и хороший способ реализовать __hash __ ()?

Какой правильный и хороший способ реализовать __hash__()?

Я говорю о функции, которая возвращает хеш-код, который затем используется для вставки объектов в хеш-таблицы, или словари.

As __hash__()возвращает целое число и используется для «объединения» объектов в хеш-таблицы. Я предполагаю, что значения возвращаемого целого числа должны быть равномерно распределены для общих данных (чтобы минимизировать коллизии). Какая хорошая практика, чтобы получить такие ценности? Являются ли столкновения проблемой? В моем случае у меня есть небольшой класс, который действует как контейнерный класс, содержащий несколько целых, несколько чисел с плавающей запятой и строку.

Простой и правильный способ реализации __hash__()- использование ключевого кортежа. Это будет не так быстро, как специализированный хеш, но если вам это нужно, вам, вероятно, следует реализовать тип в C.

Вот пример использования ключа для хэша и равенства:

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

Кроме того, документация__hash__ содержит больше информации, которая может быть полезна в некоторых конкретных обстоятельствах.

Джон Милликин предложил решение, подобное этому:

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))

Проблема с этим решением заключается в том, что hash(A(a, b, c)) == hash((a, b, c)). Другими словами, хэш сталкивается с хэшем кортежа его ключевых членов. Может быть, это не имеет большого значения на практике?

Обновление: документы Python теперь рекомендуют использовать кортеж, как в примере выше. Обратите внимание, что в документации говорится

Единственным обязательным свойством является то, что объекты, которые сравниваются равными, имеют одинаковое значение хеш

Обратите внимание, что обратное неверно. Объекты, которые не сравниваются равными, могут иметь одинаковое значение хеш-функции. Такое столкновение хэшей не приведет к тому, что один объект заменит другой при использовании в качестве ключа dict или элемента set, если объекты также не будут сравниваться .

Устаревшее / плохое решение

Документация Python__hash__ предлагает объединить хэши подкомпонентов, используя что-то вроде XOR , что дает нам это:

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)))

Обновление: как указывает Blckknght, изменение порядка a, b и c может вызвать проблемы. Я добавил дополнительный, ^ hash((self._a, self._b, self._c))чтобы захватить порядок значений хэширования. Этот финал ^ hash(...)может быть удален, если объединяемые значения нельзя переставить (например, если они имеют разные типы и, следовательно, значение _aникогда не будет присвоено _bили _c, и т. Д.).

Пол Ларсон из Microsoft Research изучил множество хэш-функций. Он мне это сказал

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

работал на удивление хорошо для широкого спектра струн. Я обнаружил, что подобные полиномиальные методы хорошо работают для вычисления хэша разнородных подполей.

Я могу попытаться ответить на вторую часть вашего вопроса.

Коллизии, вероятно, будут вызваны не самим хеш-кодом, а отображением хеш-кода на индекс в коллекции. Так, например, ваша хеш-функция может возвращать случайные значения от 1 до 10000, но если ваша хеш-таблица содержит только 32 записи, вы получите коллизии при вставке.

Кроме того, я думаю, что коллизии будут разрешаться коллекцией внутри, и есть много методов для разрешения коллизий. Простейшим (и худшим) является то, что с учетом записи, вставляемой по индексу i, добавьте 1 к i, пока вы не найдете пустое место и не вставите туда. Поиск затем работает так же. Это приводит к неэффективным поискам для некоторых записей, поскольку у вас может быть запись, для поиска которой требуется пройти всю коллекцию!

Другие методы разрешения коллизий сокращают время поиска, перемещая записи в хэш-таблице, когда элемент вставляется для распределения объектов. Это увеличивает время вставки, но предполагает, что вы читаете больше, чем вставляете. Существуют также методы, которые пытаются разветвлять различные конфликтующие записи, чтобы записи кластеризовались в одном конкретном месте.

Кроме того, если вам нужно изменить размер коллекции, вам потребуется перефразировать все или использовать метод динамического хеширования.

Короче говоря, в зависимости от того, что вы используете для хеш-кода, вам может потребоваться реализовать собственный метод разрешения коллизий. Если вы не храните их в коллекции, вы, вероятно, можете воспользоваться хеш-функцией, которая просто генерирует хеш-коды в очень большом диапазоне. Если это так, вы можете убедиться, что ваш контейнер больше, чем он должен быть (чем больше, тем лучше), в зависимости от ваших проблем с памятью.

Вот несколько ссылок, если вы заинтересованы больше:

объединенное хеширование в Википедии

В Википедии также есть сводка различных методов разрешения коллизий:

Кроме того, « Организация и обработка файлов » Tharp охватывает множество методов разрешения коллизий. ИМО это отличный справочник по алгоритмам хеширования.

Очень хорошее объяснение того, когда и как реализовать эту __hash__функцию, можно найти на сайте программирования :

Просто скриншот, чтобы предоставить обзор: (Получено 2019-12-13)

Что касается личной реализации метода, вышеупомянутый сайт предоставляет пример, который соответствует ответу 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))

Зависит от размера возвращаемого хеш-значения. Это простая логика, что если вам нужно вернуть 32-битное целое число на основе хэша четырех 32-битных целых, вы получите коллизии.

Я бы предпочел битовые операции. Например, следующий псевдокод C:

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

Такая система могла бы работать и для чисел с плавающей запятой, если вы просто взяли их в качестве их битовых значений, а не представляли бы значения с плавающей запятой, возможно, лучше.

Что касается строк, у меня мало / нет идей.