random — 生成伪随机数

源代码： :source:`Lib/random.py`

该模块为各种分布实现了伪随机数生成器。

对于整数，有一个范围内的统一选择。对于序列，有一个随机元素的统一选择，一个就地生成列表随机排列的函数，以及一个无需替换的随机采样函数。

在实线上，有一些函数可以计算均匀分布、正态分布（高斯分布）、对数正态分布、负指数分布、伽马分布和 beta 分布。为了生成角度分布，可以使用 von Mises 分布。

几乎所有的模块函数都依赖于基本函数random()，它在半开区间[0.0, 1.0)内均匀地产生一个随机浮点数。 Python 使用 Mersenne Twister 作为核心生成器。它产生 53 位精度浮点数，周期为 2**19937-1。 C 中的底层实现既快速又线程安全。 Mersenne Twister 是目前测试最广泛的随机数生成器之一。但是，由于完全确定性，它并不适合所有用途，并且完全不适合加密用途。

该模块提供的函数实际上是 random.Random 类的隐藏实例的绑定方法。您可以实例化自己的 Random 实例以获得不共享状态的生成器。

如果您想使用自己设计的不同基本生成器，类 Random 也可以被子类化：在这种情况下，覆盖 random()、seed()、[ X167X] 和 setstate() 方法。或者，新的生成器可以提供 getrandbits() 方法——这允许 randrange() 在任意大范围内生成选择。

random 模块还提供了 SystemRandom 类，该类使用系统函数 os.urandom() 从操作系统提供的源生成随机数。

警告

该模块的伪随机生成器不应用于安全目的。对于安全或加密用途，请参阅 secrets 模块。

也可以看看

M。松本和T。 Nishimura，“Mersenne Twister：一个 623 维均匀分布的均匀伪随机数发生器”，ACM 建模和计算机仿真交易卷。 8、没有。 1，1998 年 1 月第 3-30 页。

Complementary-Multiply-with-Carry recipe，用于具有长周期和相对简单更新操作的兼容替代随机数生成器。

簿记功能

random.seed(a=None, version=2)

初始化随机数生成器。

如果省略 a 或 None，则使用当前系统时间。如果操作系统提供随机源，则使用它们而不是系统时间（有关可用性的详细信息，请参阅 os.urandom() 函数）。

如果a是一个int，则直接使用。

使用版本 2（默认），str、bytes 或 bytearray 对象被转换为 int 及其所有位被使用。

对于版本 1（用于从旧版本的 Python 中复制随机序列），str 和 bytes 的算法生成的种子范围更窄。

在 3.2 版中更改：移动到版本 2 方案，该方案使用字符串种子中的所有位。

random.getstate(): 返回一个捕获生成器当前内部状态的对象。这个对象可以传递给 setstate() 来恢复状态。

random.setstate(state): state 应该是从之前对 getstate() 的调用中获得的，并且 setstate() 将生成器的内部状态恢复到当时的状态getstate() 被调用。

random.getrandbits(k): 返回一个带有 k 随机位的 Python 整数。此方法随 Mersenne Twister 生成器提供，其他一些生成器也可以将其作为 API 的可选部分提供。当可用时，getrandbits() 使 randrange() 能够处理任意大的范围。

整数函数

random.randrange(stop) random.randrange(start, stop[, step])

从 range(start, stop, step) 中返回一个随机选择的元素。这等效于 choice(range(start, stop, step))，但实际上并不构建范围对象。

位置参数模式与 range() 匹配。不应使用关键字参数，因为函数可能会以意想不到的方式使用它们。

在 3.2 版更改： randrange() 在生成均匀分布的值方面更加复杂。以前它使用像 int(random()*n) 这样的样式，这可能会产生轻微的不均匀分布。

random.randint(a, b): 返回一个随机整数 N，使得 a <= N <= b。 randrange(a, b+1) 的别名。

序列函数

random.choice(seq): 从非空序列 seq 中返回一个随机元素。如果 seq 为空，则引发 IndexError。

random.choices(population, weights=None, *, cum_weights=None, k=1)

返回一个 k 大小的元素列表，这些元素从 population 中选择并替换。如果 population 为空，则引发 IndexError。

如果指定了 weights 序列，则根据相对权重进行选择。或者，如果给出 cum_weights 序列，则根据累积权重进行选择（可能使用 itertools.accumulate() 计算）。例如，相对权重[10, 5, 30, 5]等价于累积权重[10, 15, 45, 50]。在内部，相对权重在进行选择之前转换为累积权重，因此提供累积权重可以节省工作。

如果 weights 和 cum_weights 均未指定，则选择的概率相等。如果提供了权重序列，则其长度必须与 population 序列的长度相同。指定 weights 和 cum_weights 是 TypeError。

weights 或 cum_weights 可以使用与 random() 返回的 float 值互操作的任何数字类型（包括整数、浮点数, 和分数，但不包括小数）。权重被假定为非负数。

对于给定的种子，具有相同权重的 choices() 函数通常会产生与重复调用 choice() 不同的序列。 choices() 使用的算法使用浮点算法来实现内部一致性和速度。 choice() 使用的算法默认为具有重复选择的整数算法，以避免舍入误差造成的小偏差。

3.6 版中的新功能。

random.shuffle(x[, random])

将序列 x 打乱到位。

可选参数 random 是一个 0 参数函数，返回 [0.0, 1.0) 中的随机浮点数；默认情况下，这是函数 random()。

要打乱不可变序列并返回新的打乱列表，请改用 sample(x, k=len(x))。

请注意，即使对于较小的 len(x)，x 的排列总数也可以快速增长，大于大多数随机数生成器的周期。这意味着无法生成长序列的大多数排列。例如，长度为 2080 的序列是 Mersenne Twister 随机数生成器周期内可以容纳的最大序列。

random.sample(population, k)

返回从填充序列或集合中选择的唯一元素的 k 长度列表。用于不放回的随机抽样。

返回一个包含来自总体的元素的新列表，同时保持原始总体不变。结果列表按选择顺序排列，因此所有子切片也将是有效的随机样本。这允许抽奖获胜者（样本）被划分为大奖和第二名获胜者（子片）。

总体成员不需要可散列或唯一。如果总体包含重复，则每次出现都是样本中的一个可能选择。

要从整数范围中选择一个样本，请使用 range() 对象作为参数。这对于从大量人口中采样尤其快速且节省空间：sample(range(10000000), k=60)。

如果样本大小大于总体大小，则会引发 ValueError。

实值分布

以下函数生成特定的实值分布。函数参数以分布方程中的相应变量命名，这在常见的数学实践中使用；大多数这些方程可以在任何统计课本中找到。

random.random(): 返回范围 [0.0, 1.0) 中的下一个随机浮点数。

random.uniform(a, b)

返回一个随机浮点数 N，使得 a <= b 的 a <= N <= b 和 b < a 的 b <= N <= a。

取决于等式 a + (b-a) * random() 中的浮点舍入，端点值 b 可能包含或不包含在范围内。

random.triangular(low, high, mode): 返回一个随机浮点数 N，使得 low <= N <= high 和指定的 mode 在这些边界之间。 low 和 high 边界默认为零和一。 mode 参数默认为边界之间的中点，给出对称分布。

random.betavariate(alpha, beta): 贝塔分布。参数条件为 alpha > 0 和 beta > 0。返回值介于 0 和 1 之间。

random.expovariate(lambd): 指数分布。 lambd 是 1.0 除以所需的平均值。它应该是非零的。（该参数将被称为“lambda”，但这是 Python 中的保留字。）如果 lambd 为正，则返回值范围从 0 到正无穷大，如果 lambd，则从负无穷大到 0 为阴性。

random.gammavariate(alpha, beta)

伽马分布。（不是伽马函数！）参数条件是alpha > 0和beta > 0。

概率分布函数为：

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

random.gauss(mu, sigma): 高斯分布。 mu 是平均值，sigma 是标准偏差。这比下面定义的 normalvariate() 函数稍快。

random.lognormvariate(mu, sigma): 对数正态分布。如果采用此分布的自然对数，您将得到均值为 mu 和标准差为 sigma 的正态分布。 mu 可以是任意值，sigma 必须大于零。

random.normalvariate(mu, sigma): 正态分布。 mu 是平均值，sigma 是标准偏差。

random.vonmisesvariate(mu, kappa): mu为平均角度，以弧度表示，0~2*pi，kappa为浓度参数，必须大于等于0 . 如果 kappa 等于 0，则该分布在 0 到 2*pi 范围内减少为均匀的随机角度。

random.paretovariate(alpha): 帕累托分布。 alpha 是形状参数。

random.weibullvariate(alpha, beta): 威布尔分布。 alpha 是尺度参数，beta 是形状参数。

替代发电机

class random.Random([seed]): 实现 random 模块使用的默认伪随机数生成器的类。

class random.SystemRandom([seed]): 使用 os.urandom() 函数从操作系统提供的源生成随机数的类。并非在所有系统上都可用。不依赖软件状态，序列不可重现。相应地，seed() 方法没有效果并被忽略。 getstate() 和 setstate() 方法在调用时会引发 NotImplementedError。

关于再现性的说明

有时，能够重现伪随机数生成器给出的序列很有用。通过重新使用种子值，只要多个线程没有运行，相同的序列就应该可以从运行到运行重现。

大多数 random 模块的算法和播种函数可能会在 Python 版本之间发生变化，但有两个方面保证不会发生变化：

如果添加了新的播种方法，则将提供向后兼容的播种机。
生成器的 random() 方法在兼容的种子给定相同的种子时将继续产生相同的序列。

例子和食谱

基本示例：

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x < 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

模拟：

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck of 52 playing cards
>>> # and determine the proportion of cards with a ten-value
>>> # (a ten, jack, queen, or king).
>>> deck = collections.Counter(tens=16, low_cards=36)
>>> seen = sample(list(deck.elements()), k=20)
>>> seen.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
...     return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
...     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

statistical bootstrapping 使用带替换重采样来估计样本均值的置信区间的示例：

# http://statistics.about.com/od/Applications/a/Example-Of-Bootstrapping.htm
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted(mean(choices(data, k=len(data))) for i in range(100))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}')

重采样置换测试的示例，以确定药物与安慰剂效果之间观察到的差异的统计显着性或 p 值：

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

模拟多服务器队列的到达时间和服务交付：

from heapq import heappush, heappop
from random import expovariate, gauss
from statistics import mean, median, stdev

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
for i in range(100_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = heappop(servers)
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = gauss(average_service_time, stdev_service_time)
    service_completed = arrival_time + wait + service_duration
    heappush(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}.  Stdev wait: {stdev(waits):.1f}.')
print(f'Median wait: {median(waits):.1f}.  Max wait: {max(waits):.1f}.')

也可以看看

黑客统计 Jake Vanderplas 的视频教程，介绍了使用一些基本概念（包括模拟、采样、混洗和交叉验证）进行统计分析。

经济模拟 Peter Norvig 对市场的模拟，展示了该模块提供的许多工具和分布（高斯、均匀、样本、贝塔变量、选择、三角形、和随机数）。

概率的具体介绍（使用 Python） Peter Norvig 的教程，涵盖概率论的基础知识、如何编写模拟以及如何使用 Python 执行数据分析。

random — 生成伪随机数 — Python 文档

目录