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

Який правильний і хороший спосіб втілити __hash__()?

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

Оскільки __hash__()повертає ціле число і використовується для "бінінгу" об'єктів у хештелі, я вважаю, що значення повернутого цілого числа повинні бути рівномірно розподілені для загальних даних (щоб мінімізувати зіткнення). Яка хороша практика для отримання таких цінностей? Чи зіткнення є проблемою? У моєму випадку у мене є невеликий клас, який виступає як клас контейнерів, що містить деякі ints, деякі floats та string.

Простий, правильний спосіб реалізації __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 тепер рекомендують використовувати кортеж, як у наведеному вище прикладі. Зауважте, що в документації зазначено

Єдиною необхідною властивістю є те, що об'єкти, які порівнюють рівні, мають однакове хеш-значення

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

Застаріле / погане рішення

Документація 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, поки ви не знайдете порожнє місце і вкладете туди. Потім пошук працює аналогічно. Це призводить до неефективних пошуків для деяких записів, оскільки ви можете мати запис, який вимагає обходу всієї колекції, щоб знайти!

Інші способи вирішення зіткнення скорочують час пошуку, переміщуючи записи в хеш-таблиці, коли елемент вставляється для розповсюдження речей. Це збільшує час вставки, але передбачає, що ви читаєте більше, ніж вставляєте. Існують також методи, які намагаються розгалужувати різні записи, що зіштовхуються, так що записи кластеруються в одному конкретному місці.

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

Якщо коротко, залежно від того, для чого ви використовуєте хеш-код, можливо, вам доведеться реалізувати власний метод вирішення зіткнення. Якщо ви не зберігаєте їх у колекції, ви, ймовірно, можете піти з хеш-функції, яка просто генерує хеш-коди у дуже великому діапазоні. Якщо так, ви можете переконатися, що ваш контейнер більший, ніж потрібно (чим більший, тим краще), залежно від вашої пам'яті.

Ось декілька посилань, якщо вас більше цікавить:

з’єднане хешування на вікіпедії

У Вікіпедії також є коротка інформація про різні методи вирішення колізій:

Також " Організація та обробка файлів " від Тарпа широко висвітлює багато методів вирішення зіткнень. IMO - це чудова посилання для алгоритмів хешування.

Дуже вдале пояснення того, коли і як реалізувати __hash__функцію на веб-сайті programiz :

Просто скріншот для надання огляду: (Отримано 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-бітовий int на основі хеша з чотирьох 32-бітових ints, ви отримаєте зіткнення.

Я віддав би перевагу операціям з бітом. Мовляв, наступний псевдо-код C:

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

Така система може працювати і для поплавків, якби ви просто прийняли їх як їх бітове значення, а не насправді представляли значення з плаваючою комою, можливо, краще.

Щодо струн, у мене мало / ідеї немає.