Коли хеш (n) == n у Python?

Я грав з хеш-функцією Python . Для малих цілих чисел воно з’являється hash(n) == nзавжди. Однак це не поширюється на велику кількість:

>>> hash(2**100) == 2**100
False

Я не здивований, я розумію, що хеш приймає обмежений діапазон значень. Що це за діапазон?

Я намагався використовувати двійковий пошук, щоб знайти найменше числоhash(n) != n

>>> import codejamhelpers # pip install codejamhelpers
>>> help(codejamhelpers.binary_search)
Help on function binary_search in module codejamhelpers.binary_search:

binary_search(f, t)
    Given an increasing function :math:`f`, find the greatest non-negative integer :math:`n` such that :math:`f(n) \le t`. If :math:`f(n) > t` for all :math:`n \ge 0`, return None.

>>> f = lambda n: int(hash(n) != n)
>>> n = codejamhelpers.binary_search(f, 0)
>>> hash(n)
2305843009213693950
>>> hash(n+1)
0

Що особливого у 2305843009213693951? Зауважу, це менше, ніжsys.maxsize == 9223372036854775807

Редагувати: я використовую Python 3. Я запустив той самий двійковий пошук на Python 2 і отримав інший результат 2147483648, який я зазначаю: sys.maxint+1

Я також грав з [hash(random.random()) for i in range(10**6)]оцінкою діапазону хеш-функції. Макс послідовно нижче n вище. Порівнюючи мінус, здається, хеш Python 3 завжди оцінюється позитивно, тоді як хеш Python 2 може приймати негативні значення.

На основі документації python у pyhash.cфайлі:

Для числових типів хеш числа x заснований на зменшенні x модуля простим P = 2**_PyHASH_BITS - 1. Він розроблений так, що hash(x) == hash(y)коли x і y чисельно рівні, навіть якщо x і y мають різні типи.

Отже, для 64/32-бітної машини скорочення було б 2 ^_PyHASH_BITS - 1, але що таке _PyHASH_BITS?

Ви можете знайти його у pyhash.hзаголовковому файлі, який для 64-бітної машини був визначений як 61 (ви можете прочитати більше пояснень у pyconfig.hфайлі).

#if SIZEOF_VOID_P >= 8
#  define _PyHASH_BITS 61
#else
#  define _PyHASH_BITS 31
#endif

Тож спочатку все, що базується на вашій платформі, наприклад, на моїй 64-бітній платформі Linux зменшення становить 2 ⁶¹ -1, а саме 2305843009213693951:

>>> 2**61 - 1
2305843009213693951

Також ви можете використовувати math.frexpдля того, щоб отримати мантісу та показник sys.maxintякої для 64-бітної машини показує, що max int становить 2 ⁶³ :

>>> import math
>>> math.frexp(sys.maxint)
(0.5, 64)

І ви можете побачити різницю за допомогою простого тесту:

>>> hash(2**62) == 2**62
True
>>> hash(2**63) == 2**63
False

Прочитайте повну документацію про алгоритм хешування пітонів https://github.com/python/cpython/blob/master/Python/pyhash.c#L34

Як зазначено в коментарі, ви можете використовувати sys.hash_info(у python 3.X), що дасть вам структурну послідовність параметрів, що використовуються для обчислення хешей.

>>> sys.hash_info
sys.hash_info(width=64, modulus=2305843009213693951, inf=314159, nan=0, imag=1000003, algorithm='siphash24', hash_bits=64, seed_bits=128, cutoff=0)
>>> 

Поряд з модулем, який я описав у попередніх рядках, ви також можете отримати infзначення наступним чином:

>>> hash(float('inf'))
314159
>>> sys.hash_info.inf
314159

2305843009213693951є 2^61 - 1. Це найбільший прем'єр Mersenne, який входить у 64 біти.

Якщо вам доведеться зробити хеш, просто взявши значення mod деяке число, то великий прайм Mersenne - хороший вибір - його легко обчислити і забезпечити рівномірний розподіл можливостей. (Хоча я особисто ніколи б не робив хеш таким чином)

Особливо зручно обчислювати модуль для чисел з плаваючою точкою. Вони мають експоненціальну складову, яка множує ціле число на 2^x. Оскільки 2^61 = 1 mod 2^61-1вам потрібно лише врахувати (exponent) mod 61.

Дивіться: https://en.wikipedia.org/wiki/Mersenne_prime

Функція хеша повертає звичайний int, що означає, що повернене значення більше -sys.maxintі нижче sys.maxint, а значить, якщо ви перейдете sys.maxint + xдо нього, результатом буде -sys.maxint + (x - 2).

hash(sys.maxint + 1) == sys.maxint + 1 # False
hash(sys.maxint + 1) == - sys.maxint -1 # True
hash(sys.maxint + sys.maxint) == -sys.maxint + sys.maxint - 2 # True

Тим часом 2**200в nрази більше, sys.maxint- я гадаю, що хеш перейшов би діапазон -sys.maxint..+sys.maxintn разів, поки він не зупиниться на простому цілому числу в цьому діапазоні, як у фрагментах коду вище.

Тож загалом для будь-якого n <= sys.maxint :

hash(sys.maxint*n) == -sys.maxint*(n%2) +  2*(n%2)*sys.maxint - n/2 - (n + 1)%2 ## True

Примітка: це справедливо для python 2.

Реалізацію для типу INT в CPython можна знайти тут.

Він просто повертає значення, крім -1, ніж воно повертає -2:

static long
int_hash(PyIntObject *v)
{
    /* XXX If this is changed, you also need to change the way
       Python's long, float and complex types are hashed. */
    long x = v -> ob_ival;
    if (x == -1)
        x = -2;
    return x;
}