You are here:  Home » Python » random – 生成伪随机数的详解 (6) Python语言的数学和数学模块(必读进阶学习教程)(参考资料)

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

对于整数,从一个范围内统一选择。对于序列,有一个随机元素的统一选择,一个就地生成列表随机排列的函数,以及一个用于无放回随机抽样的函数。

在实线上,有计算均匀分布、正态分布(高斯分布)、对数正态分布、负指数分布、伽马分布和贝塔分布的函数。为了生成角度分布,可以使用 von Mises 分布。

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

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

Random如果您想使用自己设计的不同基本生成器,也可以对类进行子类化:在这种情况下,重写、random()、 seed()getstate()方法setstate()。可选地,一个新的生成器可以提供一种getrandbits()方法——这允许randrange()在任意大的范围内产生选择。

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

random.seed(a=Noneversion=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 整数。 此方法随 MersenneTwister 生成器一起提供,一些其他生成器也可能将其作为 API 的可选部分提供。 如果可用,getrandbits() 使 randrange() 能够处理任意大的范围。

整数函数

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

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

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

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

序列函数

random.choice(seq)
从非空序列seq返回一个随机元素。如果seq为空,则引发IndexError
random.choicespopulation , weights=None , * , cum_weights=None , k=1 
返回一个 k 大小的元素列表,该列表从带有替换的总体中选择。如果人口为空,则引发 IndexError。

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

如果既未指定 weights 也未指定 cum_weights,则以相等的概率进行选择。如果提供了权重序列,则它的长度必须与总体序列相同。同时指定权重和 cum_weights 是一个 TypeError。

权重或 cum_weights 可以使用与 random() 返回的浮点值互操作的任何数字类型(包括整数、浮点数和分数,但不包括小数)。

对于给定的种子,具有相同权重的 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(populationk)
返回从种群序列或集合中选择的唯一元素的 k 长度列表。 用于无放回的随机抽样。

返回一个新列表,其中包含人口中的元素,同时保持原始人口不变。 结果列表按选择顺序排列,因此所有子切片也将是有效的随机样本。 这允许抽奖获奖者(样本)被划分为大奖和二等奖获奖者(子切片)。

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

要从一系列整数中选择样本,请使用 range() 对象作为参数。 这对于从大量人口中抽样特别快速且节省空间:sample(range(10000000), k=60)。

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

实值分布

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

random.random
返回 [0.0, 1.0) 范围内的下一个随机浮点数。
random.uniform(ab)
返回一个随机浮点数 N,满足 a <= N <= b for a <= b 和 b <= N <= a for b < a。

根据等式 a + (b-a) * random() 中的浮点舍入,端点值 b 可能包含也可能不包含在范围内。

random.triangular(lowhighmode)
返回一个随机浮点数 N,使得 low <= N <= high 并且在这些边界之间具有指定的模式。 下限和上限默认为零和一。 mode 参数默认为边界之间的中点,给出对称分布。
random.betavariate(alphabeta)
贝塔分布。 参数的条件是 alpha > 0 和 beta > 0。返回值介于 0 和 1 之间。
random.expovariate(lambd)
指数分布。 lambd 是 1.0 除以所需的平均值。 它应该是非零的。 (该参数将被称为“lambda”,但这是 Python 中的保留字。)如果 lambd 为正,则返回值范围从 0 到正无穷大,如果 lambd 为负,则返回值范围从负无穷大到 0。
random.gammavariate(alphabeta)
伽马分布。 (不是 gamma 函数!)参数的条件是 alpha > 0 和 beta > 0。

概率分布函数为:

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
random.gauss(musigma)
高斯分布。 mu是均值,sigma是标准差。这比normalvariate()下面定义的函数稍快。
random.lognormvariate(musigma)
记录正态分布。如果您取此分布的自然对数,您将得到一个均值为mu和标准差为sigma的正态分布。 mu可以是任意值,sigma必须大于零。
random.normalvariate(musigma)
正态分布。 mu是均值,sigma是标准差。
random.vonmisesvariate(mu, kappa)
mu是平均角度,以 0 到 2* pi之间的弧度表示,kappa 是浓度参数,必须大于或等于零。如果 kappa等于零,则此分布在 0 到 2* pi范围内减少为均匀的随机角度。
random.paretovariate(alpha)
帕累托分布。 alpha是形状参数。
random.weibullvariate(alphabeta)
威布尔分布。 alpha是尺度参数,beta是形状参数。

替代发电机

classrandom.Random([seed])
实现模块使用的默认伪随机数生成器的类 random
classrandom.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(10000)) / 10000
0.4169

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

使用有放回的重采样来估计大小为 5 的样本均值的置信区间的统计自举示例:

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

data = 1, 2, 4, 4, 10
means = sorted(mean(choices(data, k=5)) for i in range(20))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[1]:.1f} to {means[-2]:.1f}')

重采样排列检验的示例,以确定药物与安慰剂作用之间观察到的差异 的统计显着性或p 值:

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import 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 = 10000
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 random import expovariate, gauss
from statistics import mean, median, stdev

average_arrival_interval = 5.6
average_service_time = 5.0
stdev_service_time = 0.5

num_waiting = 0
arrivals = []
starts = []
arrival = service_end = 0.0
for i in range(20000):
    if arrival <= service_end:
        num_waiting += 1
        arrival += expovariate(1.0 / average_arrival_interval)
        arrivals.append(arrival)
    else:
        num_waiting -= 1
        service_start = service_end if num_waiting else arrival
        service_time = gauss(average_service_time, stdev_service_time)
        service_end = service_start + service_time
        starts.append(service_start)

waits = [start - arrival for arrival, start in zip(arrivals, starts)]
print(f'Mean wait: {mean(waits):.1f}.  Stdev wait: {stdev(waits):.1f}.')
print(f'Median wait: {median(waits):.1f}.  Max wait: {max(waits):.1f}.')