Khi nào thì hash (n) == n trong Python?

Tôi đã chơi với hàm băm của Python . Đối với các số nguyên nhỏ, nó hash(n) == nluôn xuất hiện . Tuy nhiên, điều này không mở rộng đến số lượng lớn:

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

Tôi không ngạc nhiên, tôi hiểu hàm băm có một phạm vi giá trị hữu hạn. Phạm vi đó là gì?

Tôi đã thử sử dụng tìm kiếm nhị phân để tìm số nhỏ nhấthash(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 có gì đặc biệt? Tôi lưu ý rằng nó ít hơnsys.maxsize == 9223372036854775807

Chỉnh sửa: Tôi đang sử dụng Python 3. Tôi đã chạy cùng một tìm kiếm nhị phân trên Python 2 và nhận được một kết quả khác 2147483648, tôi lưu ý là sys.maxint+1

Tôi cũng đã chơi với [hash(random.random()) for i in range(10**6)]để ước tính phạm vi của hàm băm. Giá trị lớn nhất luôn ở dưới n ở trên. So sánh tối thiểu, có vẻ như hàm băm của Python 3 luôn có giá trị dương, trong khi hàm băm của Python 2 có thể nhận các giá trị âm.

Dựa trên tài liệu python trong pyhash.ctệp:

Đối với kiểu số, hàm băm của một số x dựa trên việc rút gọn x modul thành số nguyên tố P = 2**_PyHASH_BITS - 1. Nó được thiết kế để hash(x) == hash(y)bất cứ khi nào x và y bằng nhau về số, ngay cả khi x và y có các kiểu khác nhau.

Vì vậy, đối với máy 64/32 bit, mức giảm sẽ là 2 ^_PyHASH_BITS - 1, nhưng là _PyHASH_BITSgì?

Bạn có thể tìm thấy nó trong pyhash.htệp tiêu đề dành cho máy 64 bit đã được định nghĩa là 61 (bạn có thể đọc thêm giải thích trong pyconfig.htệp).

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

Vì vậy, trước hết nó dựa trên nền tảng của bạn, ví dụ trong nền tảng Linux 64bit của tôi, mức giảm là 2 ⁶¹ -1, đó là 2305843009213693951:

>>> 2**61 - 1
2305843009213693951

Ngoài ra, Bạn có thể sử dụng math.frexpđể lấy phần định trị và số mũ sys.maxintđối với máy 64 bit cho thấy rằng số nguyên tối đa là 2 ⁶³ :

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

Và bạn có thể thấy sự khác biệt bằng một bài kiểm tra đơn giản:

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

Đọc tài liệu đầy đủ về thuật toán băm python https://github.com/python/cpython/blob/master/Python/pyhash.c#L34

Như đã đề cập trong nhận xét, bạn có thể sử dụng sys.hash_info(trong python 3.X), nó sẽ cung cấp cho bạn một chuỗi cấu trúc các tham số được sử dụng để tính toán hàm băm.

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

Cùng với mô-đun mà tôi đã mô tả trong các dòng trước, bạn cũng có thể nhận được infgiá trị như sau:

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

2305843009213693951là 2^61 - 1. Đó là số nguyên tố Mersenne lớn nhất vừa với 64 bit.

Nếu bạn phải tạo một băm chỉ bằng cách lấy giá trị mod một số nào đó, thì một số nguyên tố Mersenne lớn là một lựa chọn tốt - nó dễ dàng tính toán và đảm bảo phân phối đều các khả năng. (Mặc dù cá nhân tôi sẽ không bao giờ thực hiện băm theo cách này)

Nó đặc biệt thuận tiện để tính toán mô-đun cho các số dấu phẩy động. Chúng có một thành phần cấp số nhân nhân số nguyên với 2^x. Vì 2^61 = 1 mod 2^61-1, bạn chỉ cần xem xét (exponent) mod 61.

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

Hàm băm trả về giá trị int đơn giản có nghĩa là giá trị trả về lớn hơn -sys.maxintvà thấp hơn sys.maxint, có nghĩa là nếu bạn chuyển sys.maxint + xđến nó thì kết quả sẽ là -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

Trong khi đó lớn hơn 2**200một nlần sys.maxint- tôi đoán là băm sẽ vượt quá phạm vi -sys.maxint..+sys.maxintn lần cho đến khi nó dừng lại trên số nguyên thuần túy trong phạm vi đó, như trong các đoạn mã ở trên ..

Vì vậy, nói chung, với bất kỳ n <= sys.maxint :

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

Lưu ý: điều này đúng với python 2.

Việc triển khai kiểu int trong cpython có thể được tìm thấy tại đây.

Nó chỉ trả về giá trị, ngoại trừ -1, hơn nó trả về -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;
}