random —生成伪随机数

源代码： Lib/random.py

---

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

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

实际上，有一些函数可以计算均匀分布，正态分布(高斯分布)，对数正态分布，负指数分布，伽玛分布和贝塔分布。为了生成角度分布，可以使用冯·米塞斯分布。

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

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

如果要使用自己设计的其他基本生成器，也可以将Random类作为子类：在这种情况下，请覆盖random()，seed()，getstate()和setstate()方法。可选地，新的生成器可以提供getrandbits()方法-这使randrange()可以在任意较大的范围内产生选择。

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

Bookkeeping functions

• random. seed(* a = None ， version = 2 *)
  • 初始化随机数生成器。

如果Ellipsis* a *或None，则使用当前系统时间。如果 os 提供了随机性源，那么将使用它们而不是系统时间(有关可用性的详细信息，请参见os.urandom()Function)。

如果* a *是一个整数，则直接使用。

在版本 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(停止)

• random. randrange((开始，停止 [，步骤])

  • 从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)的别名。

序列Function

• random. choice(* seq *)

  • 从非空序列* seq 返回一个随机元素。如果 seq *为空，则引发IndexError。

• random. choices(人口，权重=无，**，暨权重=无， k = 1 *)

  • 返回从* population 中选择的元素的 k 大小的列表，并进行替换。如果 population *为空，则引发IndexError。

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

如果未指定* weight 和 cum_weights ，则选择的可能性均等。如果提供了权重序列，则其长度必须与 population 序列的长度相同。同时指定 weight 和 cum_weights *是TypeError。

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

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

3.6 版的新Function。

• random. shuffle(* x * [，* random *])
  • 将序列* x *洗到位。

可选参数* random *是一个 0 参数的函数，返回\ [0.0, 1.0); by default, this is the function random()中的随机浮点数。

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

请注意，即使对于小的len(x)，* x *的排列总数也可以比大多数随机数生成器的周期迅速增大。这意味着长序列的大多数排列永远不会生成。例如，长度为 2080 的序列是最大的序列，可以在 Mersenne Twister 随机数生成器的周期内进行拟合。

• random. sample(人口，* k *)
  • 返回从填充序列或集合中选择的唯一元素的* k *长度列表。用于随机抽样而无需更换。

返回一个新列表，其中包含来自总体的元素，同时保留原始总体不变。结果列表按选择 Sequences 排列，因此所有子切片也将是有效的随机 samples。这样就可以将抽奖活动的获胜者(samples)划分为大奖和第二名的获胜者(子片段)。

人口成员不必为hashable或唯一。如果总体包含重复，则每次出现都是 samples 中的可能选择。

要从整数范围中选择 samples，请使用range()对象作为参数。这对于从大量人口sample(range(10000000), k=60)进行采样特别快速且节省空间。

如果 samples 大小大于总体大小，则将引发ValueError。

Real-valued distributions

以下函数生成特定的实值分布。函数参数以分布方程式中的相应变量命名，如通常的 math 实践中所用；这些方程式中的大多数都可以在任何统计信息文本中找到。

• random. random ( )

  • 返回范围为[0.0，1.0)的下一个随机浮点数。

• random. uniform(* a ， b *)

  • 返回一个随机浮点数* N *，其中a <= N <= b表示a <= b，而b <= N <= a表示b < a。

根据公式a + (b-a) * random()中的浮点舍入，端点值b可以包含或可以不包含在范围内。

• random. triangular(低，高，模式)

  • 返回一个随机浮点数* N ，使low <= N <= high且在这些边界之间具有指定的 mode *。 * low 和 high *边界默认为零和一。 * mode *参数默认为边界之间的中点，给出对称分布。

• random. betavariate(* alpha ， beta *)

  • 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 之间的弧度表示，而 kapp 是浓度参数，必须大于或等于零。如果 kappa *等于零，则此分布在 0 到 2 * * pi *的范围内减小为均匀的随机角度。

• random. paretovariate(* alpha *)

  • 帕累托分布。 * alpha *是 shape 参数。

• random. weibullvariate(* alpha ， beta *)

  • 威布尔分布。 * alpha 是比例参数， beta *是形状参数。

Alternative Generator

• 类别 random. Random([种子])

  • 实现random模块使用的默认伪随机数生成器的类。

• 类别 random. SystemRandom([种子])

  • 使用os.urandom()函数从 os 提供的源生成随机数的类。并非在所有系统上都可用。不依赖软件状态，并且序列不可复制。因此，seed()方法无效，将被忽略。如果调用getstate()和setstate()方法会提高NotImplementedError。

有关可重复性的说明

有时能够重现伪随机数生成器给出的序列很有用。pass重新使用种子值，只要不运行多个线程，就可以在每次运行之间重现相同的序列。

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

• 如果添加了新的播种方法，则将提供向后兼容的播种器。

• 当给兼容的播种器提供相同的种子时，生成器的random()方法将 continue 产生相同的序列。

示例和食谱

Basic examples:

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

Simulations:

>>> # 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使用替换重采样来估计 samples 平均值的置信区间的示例：

# 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}')

重采样置换测试确定药物与 console 剂作用之间观察到的差异的统计学显着性或p-value的示例：

# 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}.')