Quando o hash (n) == n está em Python?

Tenho brincado com a função hash do Python . Para números inteiros pequenos, aparece hash(n) == nsempre. No entanto, isso não se estende a grandes números:

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

Não estou surpreso, entendo que o hash assume uma faixa finita de valores. Qual é esse alcance?

Tentei usar a pesquisa binária para encontrar o menor númerohash(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

O que há de especial em 2305843009213693951? Eu noto que é menos quesys.maxsize == 9223372036854775807

Edit: Estou usando Python 3. Eu executei a mesma pesquisa binária no Python 2 e obtive um resultado diferente 2147483648, que observo é sys.maxint+1

Eu também brinquei com [hash(random.random()) for i in range(10**6)]para estimar o intervalo da função hash. O máximo está consistentemente abaixo de n acima. Comparando o min, parece que o hash do Python 3 é sempre valorizado positivamente, enquanto o hash do Python 2 pode assumir valores negativos.

Com base na documentação do Python no pyhash.carquivo:

Para tipos numéricos, o hash de um número x é baseado na redução de x módulo do primo P = 2**_PyHASH_BITS - 1. Ele é projetado para que hash(x) == hash(y)sempre que x e y sejam numericamente iguais, mesmo que x e y tenham tipos diferentes.

Portanto, para uma máquina de 64/32 bits, a redução seria 2 ^_PyHASH_BITS - 1, mas o que é _PyHASH_BITS?

Você pode encontrá-lo no pyhash.harquivo de cabeçalho, que para uma máquina de 64 bits foi definido como 61 (você pode ler mais explicações no pyconfig.harquivo).

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

Então, em primeiro lugar, é baseado na sua plataforma, por exemplo, na minha plataforma Linux de 64 bits, a redução é 2 ⁶¹ -1, que é 2305843009213693951:

>>> 2**61 - 1
2305843009213693951

Você também pode usar math.frexppara obter a mantissa e o expoente da sys.maxintqual, para uma máquina de 64 bits, mostra que o int máximo é 2 ⁶³ :

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

E você pode ver a diferença por um teste simples:

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

Leia a documentação completa sobre o algoritmo de hash Python https://github.com/python/cpython/blob/master/Python/pyhash.c#L34

Conforme mencionado no comentário, você pode usar sys.hash_info(em python 3.X), que fornecerá uma sequência de estrutura de parâmetros usados ​​para calcular hashes.

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

Juntamente com o módulo que descrevi nas linhas anteriores, você também pode obter o infvalor da seguinte maneira:

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

2305843009213693951 é 2^61 - 1 . É o maior número primo de Mersenne que cabe em 64 bits.

Se você tiver que fazer um hash apenas tomando o valor mod algum número, então um grande número primo de Mersenne é uma boa escolha - é fácil de calcular e garante uma distribuição uniforme de possibilidades. (Embora eu pessoalmente nunca fizesse um hash dessa forma)

É especialmente conveniente calcular o módulo para números de ponto flutuante. Eles têm um componente exponencial que multiplica o número inteiro por 2^x. Uma vez que 2^61 = 1 mod 2^61-1você só precisa considerar o(exponent) mod 61 .

Veja: https://en.wikipedia.org/wiki/Mersenne_prime

A função hash retorna um int simples, o que significa que o valor retornado é maior -sys.maxinte menor que sys.maxint, o que significa que se você passar sys.maxint + xpara ele o resultado será -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

Enquanto isso, 2**200é um nvezes maior do que sys.maxint- meu palpite é que o hash ultrapassaria o intervalo-sys.maxint..+sys.maxint n vezes até que parasse em um inteiro simples nesse intervalo, como nos trechos de código acima.

Então, geralmente, para qualquer n <= sys.maxint :

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

Observação: isso é verdade para o python 2.

A implementação para o tipo int em cpython pode ser encontrada aqui.

Ele apenas retorna o valor, exceto por -1, que retorna -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;
}