如何在 python 中生成 8 个字节的唯一随机数？

Question

有没有什么方法可以在 python 语言中生成一个 8 字节 大小的唯一随机数？我使用了 UUID 库，但它有 16 个字节，这与我的要求不一致。

任何帮助将不胜感激。

提前致谢

Answer 1

好吧，您可以使用Linear Congruential Generator，通过正确选择参数，生成从 u64 到 u64 的完美映射。换句话说，如果您可以访问之前的 8 字节 UUID，您可以生成合理的随机下一个 8 字节 UUID，无需重复，直到整个 2⁶⁴ 空间 ix 用完。它也可以在 O(log(N)) 中前后 N 步。

使用 NumPy、Python 3.7、Anaconda、Win 10 x64 的代码

#%%
import numpy as np

#%%
class LCG(object):

    UZERO: np.uint64 = np.uint64(0)
    UONE : np.uint64 = np.uint64(1)

    def __init__(self, seed: np.uint64, a: np.uint64, c: np.uint64) -> None:
        self._seed: np.uint64 = np.uint64(seed)
        self._a   : np.uint64 = np.uint64(a)
        self._c   : np.uint64 = np.uint64(c)

    def next(self) -> np.uint64:
        self._seed = self._a * self._seed + self._c
        return self._seed

    def seed(self) -> np.uint64:
        return self._seed

    def set_seed(self, seed: np.uint64) -> np.uint64:
        self._seed = seed

    def skip(self, ns: np.int64) -> None:
        """
        Signed argument - skip forward as well as backward

        The algorithm here to determine the parameters used to skip ahead is
        described in the paper F. Brown, "Random Number Generation with Arbitrary Stride,"
        Trans. Am. Nucl. Soc. (Nov. 1994). This algorithm is able to skip ahead in
        O(log2(N)) operations instead of O(N). It computes parameters
        A and C which can then be used to find x_N = A*x_0 + C mod 2^M.
        """

        nskip: np.uint64 = np.uint64(ns)

        a: np.uint64 = self._a
        c: np.uint64 = self._c

        a_next: np.uint64 = LCG.UONE
        c_next: np.uint64 = LCG.UZERO

        while nskip > LCG.UZERO:
            if (nskip & LCG.UONE) != LCG.UZERO:
                a_next = a_next * a
                c_next = c_next * a + c

            c = (a + LCG.UONE) * c
            a = a * a

            nskip = nskip >> LCG.UONE

        self._seed = a_next * self._seed + c_next


#%%
np.seterr(over='ignore')

a = np.uint64(6364136223846793005)
c = np.uint64(1)

seed = np.uint64(1)

rng64 = LCG(seed, a, c)

print(rng64.next())
print(rng64.next())
print(rng64.next())

#%%
rng64.skip(-3) # back by 3
print(rng64.next())
print(rng64.next())
print(rng64.next())

rng64.skip(-3) # back by 3
rng64.skip(2) # forward by 2
print(rng64.next())

Answer 2

在 Python 3.6 及更高版本中，这很容易：

• 导入secrets模块：import secrets。
• 使用secrets.token_bytes(8) 生成随机字节序列。或者，如果该字符串应该是可读的，则使用以下生成 8 个字节的 16 个字符的字符串 (secrets.token_hex(8))，或 4 个字节的 8 个字符的字符串 (secrets.token_hex(4))。