随机性如何？这是一个奇怪的问题，但在涉及信息安全的情况下，它是最重要的问题之一。每当你在 Python 中生成随机数据、字符串或数字时，最好至少对这些数据是如何生成的有一个粗略的了解。

在这里，您将介绍一些用于在 Python 中生成随机数据的不同选项，然后根据其安全性、多功能性、用途和速度对每个选项进行比较。

伪随机

使用 Python 生成的大多数随机数据在科学意义上并不是完全随机的。相反，它是伪随机的：使用伪随机数生成器 （PRNG） 生成，这本质上是用于生成看似随机但仍然可重复的数据的任何算法。

抛硬币才是真随机，但是这种真实场景不能绝对的模拟。

“真”随机数可以由真随机数生成器 （TRNG） 生成，您猜对了。一个例子是反复从地板上捡起一个骰子，把它扔到空中，然后让它以它的方式着陆。

假设你的投掷是公正的，你真的不知道骰子会落在什么数字上。掷骰子是一种使用硬件生成任何不确定数字的粗略形式

随机种子

也许“随机”和“确定性”这两个术语似乎不能彼此相邻存在。为了更清楚起见，这里有一个非常精简的版本，它通过使用 迭代创建一个“随机”数字。 最初定义为种子值，然后演变为基于该种子的确定性数字序列：random()x = (x * 3) % 19x

class NotSoRandom(object):    def seed(self, a=3):        """Seed the world's most mysterious random number generator."""        self.seedval = a    def random(self):        """Look, random numbers!"""        self.seedval = (self.seedval * 3) % 19        return self.seedval_inst = NotSoRandom()seed = _inst.seedrandom = _inst.random

>>> random.randint(0, 10)7>>> random.randint(500, 50000)18601

给一个种子值获取随机数据者

>>> seed(1234)>>> [random() for _ in range(10)][16, 10, 11, 14, 4, 12, 17, 13, 1, 3]>>> seed(1234)>>> [random() for _ in range(10)][16, 10, 11, 14, 4, 12, 17, 13, 1, 3]

控制随机数的范围

>>> random.randrange(1, 10)

random.uniform(x, y) 方法将随机生成一个实数，它在 [x,y] 范围内。

x -- 随机数的最小值，包含该值。

y -- 随机数的最大值，不包含该值。返回一个浮点数

# _*_ coding: utf-8 _*_import randomprint("uniform(1 , 6) 的随机返回值为 : ", random.uniform(1 , 6))print("uniform(10, 16) 的随机返回值为 : ", random.uniform(10, 16)) 

>>> random.seed(444)>>> random.random()0.3088946587429545>>> random.random()0.01323751590501987>>> random.seed(444)  # Re-seed>>> random.random()0.3088946587429545>>> random.random()0.01323751590501987

注意“随机”数字的重复。随机数的序列变得具有确定性，或完全由种子值 444 决定。

让我们看一下 的一些更基本的功能。上面，你生成了一个随机浮点数。您可以使用该函数在 Python 中的两个端点之间生成一个随机整数。这跨越了整个 [x， y] 间隔，可能包括两个端点：

>>> random.randint(0, 10)7>>> random.randint(500, 50000)18601

使用 ，您可以排除区间的右侧，这意味着生成的数字始终位于 [x， y） 内，并且始终小于正确的端点：random.randrange()

>>> random.randrange(1, 10)5

如果需要生成位于特定 [x， y] 区间内的随机浮点数，则可以使用 ，它从连续均匀分布中取：random.uniform()

>>> random.uniform(20, 30)27.42639687016509>>> random.uniform(30, 40)36.33865802745107

要从非空序列（如列表或元组）中选取随机元素，可以使用 .还可以从序列中选择多个元素进行替换（可以重复）：random.choice()random.choices()

>>> items = ['one', 'two', 'three', 'four', 'five']>>> random.choice(items)'four'>>> random.choices(items, k=2)['three', 'three']>>> random.choices(items, k=3)['three', 'five', 'four']

从列表中随机取得元素

>>> random.sample(items, 4)['one', 'five', 'four', 'three']

可以使用 就地随机化序列。这将修改序列对象并随机化元素的顺序：random.shuffle()

>>> random.shuffle(items)>>> items['four', 'three', 'two', 'one', 'five'

import stringdef unique_strings(k: int, ntokens: int,               pool: str=string.ascii_letters) -> set:    """Generate a set of unique string tokens.    k: Length of each token    ntokens: Number of tokens    pool: Iterable of characters to choose from    For a highly optimized version:        """    seen = set()    # An optimization for tightly-bound loops:    # Bind these methods outside of a loop    join = ''.join    add = seen.add    while len(seen) < ntokens:        token = join(random.choices(pool, k=k))        add(token)    return seen

et中保证元素不重复，while 循环将一直执行，直到集具有您指定长度的元素，''.join()将字母 from 连接成一个长度为 Python 的 Python 。、s

>>> unique_strings(k=4, ntokens=5){'AsMk', 'Cvmi', 'GIxv', 'HGsZ', 'eurU'}>>> unique_strings(5, 4, string.printable){"'O*1!", '9Ien%', 'W=m7<', 'mUD|z'}

>>> # Return samples from the standard normal distribution>>> np.random.randn(5)array([ 0.36,  0.38,  1.38,  1.18, -0.94])>>> np.random.randn(3, 4)array([[-1.14, -0.54, -0.55,  0.21],       [ 0.21,  1.27, -0.81, -3.3 ],       [-0.81, -0.36, -0.88,  0.15]])>>> # `p` is the probability of choosing each element>>> np.random.choice([0, 1], p=[0.6, 0.4], size=(5, 4))array([[0, 0, 1, 0],       [0, 1, 1, 1],       [1, 1, 1, 0],       [0, 0, 0, 1],       [0, 1, 0, 1]])

在 的语法中，参数是可选的，用于指示最终对象的形状。在这里，创建一个包含 2 行和 3 列的 4d 数组。数据将是 i.i.d.，这意味着每个数据点都是独立于其他数据点绘制的。randn(d0, d1, ..., dn)d0, d1, ..., dnnp.random.randn(3, 4)

>>> # NumPy's `randint` is [inclusive, exclusive), unlike `random.randint()`>>> np.random.randint(0, 2, size=25, dtype=np.uint8).view(bool)array([ True, False,  True,  True, False,  True, False, False, False,       False, False,  True,  True, False, False, False,  True, False,        True, False,  True,  True,  True, False,  True])

>>> # Start with a correlation matrix and standard deviations.>>> # -0.40 is the correlation between A and B, and the correlation>>> # of a variable with itself is 1.0.>>> corr = np.array([[1., -0.40],...                  [-0.40, 1.]])>>> # Standard deviations/means of A and B, respectively>>> stdev = np.array([6., 1.])>>> mean = np.array([2., 0.5])>>> cov = corr2cov(corr, stdev)>>> # `size` is the length of time series for 2d data>>> # (500 months, days, and so on).>>> data = np.random.multivariate_normal(mean=mean, cov=cov, size=500)>>> data[:10]array([[ 0.58,  1.87],       [-7.31,  0.74],       [-6.24,  0.33],       [-0.77,  1.19],       [ 1.71,  0.7 ],       [-3.33,  1.57],       [-1.13,  1.23],       [-6.58,  1.81],       [-0.82, -0.34],       [-2.32,  1.1 ]])>>> data.shape(500, 2)

Python 模块random

NumPy 对应项

用

random()

rand()

[0.0， 1.0] 中的随机浮点数

randint(a, b)

random_integers()

[a， b] 中的随机整数

randrange(a, b[, step])

randint()

[a， b] 中的随机整数

uniform(a, b)

uniform()

[a， b] 中的随机浮点数

choice(seq)

choice()

来自 的随机元素seq

choices(seq, k=1)

choice()

替换的随机元素kseq

sample(population, k)

choice（） 替换为replace=False

随机元素，无需替换kseq

shuffle(x[, random])

shuffle()

就地随机播放序列x

normalvariate(mu, sigma)或gauss(mu, sigma)

normal()

来自具有均值和标准差的正态分布的样本musigma

尽可能随机os.urandom()：尽可能随机

Python 的 os.urandom（） 函数被 secrets 和 uuid 使用。生成与操作系统相关的随机字节，这些字节可以安全地称为加密安全：os.urandom()

在Unix操作系统上，它从特殊文件中读取随机字节，这反过来又“允许访问从设备驱动程序和其他来源收集的环境噪声”。（谢谢你，维基百科。这是特定于某个实例的硬件和系统状态的乱码信息，但同时又足够随机。/dev/urandom在Windows上，使用C++函数CryptGenRandom（）。从技术上讲，此函数仍然是伪随机函数，但它的工作原理是从进程 ID、内存状态等变量生成种子值。

虽然从技术上讲仍然是伪随机的，但这个函数更符合我们对随机性的看法。唯一的参数是要返回的字节数：os.urandom()

>>> os.urandom(3)b'\xa2\xe8\x02'>>> x = os.urandom(6)>>> xb'\xce\x11\xe7"!\x84'>>> type(x), len(x)(bytes, 6)

os.urandom()返回单个字节序列：

>>> xb'\xce\x11\xe7"!\x84'

生成随机令牌的最后一个选项是 Python 的 uuid 模块中的函数。UUID 是一个通用唯一标识符，是一个 128 位序列（长度为 32），旨在“保证跨空间和时间的唯一性”。 是该模块最有用的函数之一，此函数还使用 os.urandom（）：uuid4()struuid4()

>>> import uuid>>> uuid.uuid4()UUID('3e3ef28d-3ff0-4933-9bba-e5ee91ce0e7b')>>> uuid.uuid4()UUID('2e115fcb-5761-4fa1-8287-19f4ee2877ac')

所有函数都会生成类的实例，该实例封装了 ID，uuidUUID.int.bytes.hex

>>> tok = uuid.uuid4()>>> tok.bytesb'.\xb7\x80\xfd\xbfIG\xb3\xae\x1d\xe3\x97\xee\xc5\xd5\x81'>>> len(tok.bytes)16>>> len(tok.bytes) * 8  # In bits128>>> tok.hex'2eb780fdbf4947b3ae1de397eec5d581'>>> tok.int62097294383572614195530565389543396737

uuid1()默认情况下，使用计算机的主机 ID 和当前时间。由于对当前时间的依赖性低至纳秒级分辨率，因此 UUID 得出了“保证随时间的唯一性”这一说法。uuid3()并且都采用命名空间标识符和名称。前者使用 MD5 哈希，后者使用 SHA-1。uuid5()

uuid4()相反，完全是伪随机（或随机）。它包括获取 16 个字节 via ，将其转换为大端整数，并执行一些按位运算以符合形式规范。os.urandom()

随机的办法randomnumpy.randomuuid