在python中，有两个模块可以产生随机数：
1. python自带random包： 提供一些基本的随机数产生函数，可满足基本需要
2. numpy.random：提供一些产生随机数的高级函数，满足高级需求

本文先分别介绍这两个包的常用函数，文末将总结一下两个包的区别。

目录

random 介绍

函数汇总

函数	功能	返回	备注
random.random()	生成一个 [0,1) 之间的均匀分布浮点数	一个浮点数
random.uniform(a,b)	生成一个 [a,b] 之间的均匀分布的浮点数，相当于 a + (b-a) * random.random()	一个浮点数	可以存在 a>b 的情况
random.randint(a, b)	生成一个 [a,b] 之间的随机整数	一个整数
random.randrange(a, b, step)	生成一个[a,b)之间间隔步长为step的随机整数	一个整数	如random.randrange(0, 20, 2),相当于从[0,2,4,6,…,18]中随机取一个
random.choice(seq)	从特定序列中随机取一个元素	一个元素	seq：字符串,列表,元组,range(a, b)**等。 若seq为空，则返回IndexError
random.choices(seq, weights=None, *, cum_weights=None, k=1)	(依概率)从指定序列中（有放回）随机抽取 k 个元素,原始序列不变。可以设定 weights 或是 cum_weights 来改变元素权重	多个元素	seq：字符串,列表,元组,range(a, b)等：k 必须显式地赋值
random.sample(seq,k)	指定序列中（无放回）随机抽取 k 个元素,原始序列不变	多个元素	seq：字符串,列表,元组,range(a, b)等
random.shuffle(lst)	在原列表上将元素打乱,洗牌，原始序列改变	功能函数： 返回原序列打乱后的list	lst: 只支持列表

import random

random.random()             # 0.5102632768396692
random.uniform(0,10)        # 6.890853912057401
random.randint(0,10)        # 5
random.randrange(0,10,2)    # 4


# random.choice()
string = 'nice to meet you'
tup = ('a', 'b', 'c', 'd')
lst = ['a', 'b', 'c', 'd']
random.choice(string)       # e
random.choice(tup)          # c
random.choice(lst)          # a


# random.choices()
lst = ['a', 'b', 'c', 'd']
random.choices(lst,k=3)     # ['a', 'a', 'c']


# random.sample()
string = 'nice to meet you'
tup = ('a', 'b', 'c', 'd')
lst = ['a', 'b', 'c', 'd']
random.sample(string,2)        # ['e', 'i']
random.sample(tup,2)           # ['c', 'b']
random.sample(lst,2)           # ['a', 'b']


# random.shuffle()
lst = ['a', 'b', 'c', 'd']
random.shuffle(lst)
print(lst)                     # ['b', 'd', 'c', 'a']

产生特定分布的函数

一下函数均输出一个数

函数	功能
random.random()	均匀分布: [0,1)之间
random.uniform(a, b)	均匀分布： [a,b]之间
random.gauss(mu, sigma)	高斯分布：以 mu 为均值，sigma 为标准差。guass()比normalvariate()稍快
random.normalvariate(mu, sigma)	正态分布：以 mu 为均值，sigma 为标准差
random.lognormvariate(mu, sigma)	对数正态分布
random.expovariate(lambd)	指数分布
random.triangular(low, high, mode)	三角分布
random.betavariate(alpha, beta)	Beta分布
random.weibullvariate(alpha, beta)	韦伯分布
random.gammavariate(alpha, beta)	Gamma分布
random.paretovariate(alpha)	Pareto 分布

随机种子相关

函数	功能	备注
random.seed(a=None, version=2)	初始化随机种子	a 如果是 None 则使用当前的种子。 a 可以是 str, bytes, bytearray, 都会被转成 int。
random.getstate()	取得随机器内部状态
random.setstate(state)	设定随机器内部状态	state需为从 random.getstate() 获得的 state

import random
random.seed('foobar')     # 設定 random seed

# 随意消耗一些乱数
random.randint(0, 100)    # 32
random.randint(0, 100)    # 31
random.randint(0, 100)    # 44

rs = random.getstate()    # 储存当前的乱数状态

r0 = [random.randint(0, 100) for _ in range(10)]  # 生成 10 个乱数
random.setstate(rs)                               # 恢复乱数状态
r1 = [random.randint(0, 100) for _ in range(10)]  # 生成 10 个乱数

# r0, r1 随机数应该一样
r0 == r1                                          # True

注意：

如果要产生随机密码或token，请使用secrets模块，因为安全性问题，绝对不要使用random来产生密码。

Reference

python官方doc：9.6. random — Generate pseudo-random numbers
python Source code: Lib/random.py
random — 你所不知道的 Python 標準函式庫用法 02

numpy.random 介绍

numpy官方doc：Random sampling (numpy.random)

函数汇总

函数	功能	备注
numpy.random.seed(seed=None)	设定随机种子	seed : int or 1-d array_like, optional
numpy.random.rand(d0,d1,…,dn)	返回给定维度的array，每个数是服从开区间[0,1)的均匀分布的浮点数
numpy.random.randn(d0,d1,…,dn)	返回给定维度的array，每个数是服从标准正态分布的浮点数
numpy.random.random_sample(size=None)	生成[0,1)之间均匀分布的浮点数
numpy.random.random(size=None)	生成[0,1)之间均匀分布的浮点数
numpy.random.ranf(size=None)	生成[0,1)之间均匀分布的浮点数
numpy.random.sample(size=None)	生成[0,1)之间均匀分布的浮点数
numpy.random.randint(low, high=None, size=None, dtype=’l’)	返回给定维度的整数array，每个数是开区间[low,high)或[0,low)的均匀分布的整数	dtype为数据类型，默认的数据类型是np.int
numpy.random.random_integers(low, high=None, size=None)	返回给定维度的整数array，每个数是闭区间[low,high]或[1,low]的均匀分布的整数	该函数在最新的numpy版本中已被替代，建议使用randint函数
numpy.random.choice(a, size=None, replace=True, p=None)	(依概率)从给定的一维数组中（有放回或无放回地）随机选择	参数： a为一维数组类似数据或整数；size为数组维度；replace：True为有放回，False为无放回；p为数组中的数据出现的概率
numpy.random.shuffle(x)	原列表上将元素打乱。 与random.shuffle()一样	x: array or list

产生特定分布的函数

各分布函数详见numpy官方doc。

常用函数示例

numpy.random.seed()

# 第一次 seed = 0
np.random.seed(0)
np.random.rand(5)
>> array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ])

# 换一个seed
np.random.seed(1676)
np.random.rand(5)
>> array([0.39983389, 0.29426895, 0.89541728, 0.71807369, 0.3531823 ])

# 第二次 seed = 0，发现结果与第一次一样，即得到了可复现的随机数
np.random.seed(0)
np.random.rand(5)
>> array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ])

numpy.random.rand()

根据给定维度生成均匀分布开区间[0,1)之间的数

import numpy as np

# numpy.random.rand
np.random.rand()  # 当没有参数时，返回单个数据
>> 0.8214199637356738

np.random.rand(4) # shape: 4
>> array([0.28966543, 0.2007679 , 0.87655807, 0.94153647])

np.random.rand(4,2) # shape: 4*2
>> array([[0.05436321, 0.7350782 ],
          [0.52215659, 0.53889898],
          [0.46468492, 0.71335749],
          [0.8038878 , 0.64666693]])

np.random.rand(4,3,2)  # shape: 4*3*2
>> array([[[0.34545913, 0.69313943],
           [0.79446914, 0.87836912],
           [0.65324253, 0.79146979]],

         [[0.62297291, 0.85356693],
          [0.54331809, 0.82817135],
          [0.41794522, 0.38204339]],

         [[0.67268369, 0.25551782],
          [0.71614578, 0.77045723],
          [0.27518846, 0.99426059]],

         [[0.20126485, 0.89100356],
          [0.04855106, 0.72816571],
          [0.50437136, 0.27798907]]])

numpy.random.randn()

返回给定维度的array，每个数服从标准正态分布

np.random.randn() # 当没有参数时，返回单个数据
>> -1.1241580894939212

np.random.randn(2,4)
>> array([[ 0.27795239, -2.57882503,  0.3817649 ,  1.42367345],
       [-1.16724625, -0.22408299,  0.63006614, -0.41714538]])

np.random.randn(4,3,2)
>> array([[[ 1.27820764,  0.92479163],
        [-0.15151257,  1.3428253 ],
        [-1.30948998,  0.15493686]],

       [[-1.49645411, -0.27724089],
        [ 0.71590275,  0.81377671],
        [-0.71833341,  1.61637676]],

       [[ 0.52486563, -1.7345101 ],
        [ 1.24456943, -0.10902915],
        [ 1.27292735, -0.00926068]],

       [[ 0.88303   ,  0.46116413],
        [ 0.13305507,  2.44968809],
        [-0.73132153, -0.88586716]]])

numpy.random.randint()

返回随机整数的array

np.random.randint(1,size=5) # 返回[0,1)之间的整数，所以只有0
>> array([0, 0, 0, 0, 0])

np.random.randint(1,5) # 返回1个[1,5)之间的随机整数
>> 4

np.random.randint(-5,5,size=(2,2)) # 返回[1,5)之间的随机整数
>> array([[ 2, -1],
          [ 2,  0]])

numpy.random.random_integers() 即将废弃

与numpy.random.randint()功能类似。该函数在最新的numpy版本中已被替代，建议使用randint()函数

np.random.random_integers(5,size=5)

__main__:1: DeprecationWarning: This function is deprecated. Please call randint(1, 5 + 1) instead
>> array([2, 4, 3, 4, 2])

生成[0,1)之间均匀分布的浮点数

print('-----------random_sample()--------------')
print(np.random.random_sample(size=(2,2)))
print('-----------random()--------------')
print(np.random.random(size=(2,2)))
print('-----------ranf()--------------')
print(np.random.ranf(size=(2,2)))
print('-----------sample()--------------')
print(np.random.sample(size=(2,2)))


# 输出：
-----------random_sample()--------------
[[0.70770026 0.32289658]
 [0.37320026 0.12638252]]
-----------random()--------------
[[0.47976139 0.82591445]
 [0.24703018 0.02357945]]
-----------ranf()--------------
[[0.90345548 0.77388432]
 [0.97383893 0.47288215]]
-----------sample()--------------
[[0.74441927 0.31705026]
 [0.55894275 0.79483591]]

numpy.random.choice()

# 从np.range(5)即0~4的整数中，（默认)有放回地等概率选择三个数
np.random.choice(5,3)  
>> array([1, 3, 3])

# 无放回地选择。此时输出size应小于range
np.random.choice(5, 3, replace=False)
>> array([0, 2, 3])



#从np.range(5)即0~4的整数中，（默认)有放回地选择3*2维的array数组
np.random.choice(5,size=(3,2))
>> array([[0, 2],
          [2, 2],
          [1, 4]])

#从列表中有放回地等概率选择元素，组成3*3维的array数组
list_ = ['a', 'b','c','d', 'e']
np.random.choice(list_,size=(3,3))
>> array([['c', 'b', 'a'],
          ['b', 'e', 'c'],
          ['d', 'b', 'b']], dtype='<U1')


# 不等概率随机选取
# 参数p为概率，长度应与参数a一致，p里的数据之和应为1
np.random.choice(list_,size=(3,3),p=[0.1,0.6,0.1,0.1,0.1])
>> array([['b', 'b', 'a'],
          ['b', 'b', 'b'],
          ['e', 'a', 'b']], dtype='<U1')

numpy.shuffle()

arr = np.arange(9).reshape((3, 3))
np.random.shuffle(arr)

arr
>> array([[3, 4, 5],
          [6, 7, 8],
          [0, 1, 2]])

两个包的区别

numpy.random比python原生random更灵活，具体如表：

比较内容	原生random	numpy.random
输入类型	非空的列表类型（包括列表、字符串和元组）	非空的列表类型（包括列表、字符串和元组）+ numpy.array类型
输出维度	一个数或一个list（多个数）	可指定复杂的size
指定(a,b)范围	可以	整数可指定，浮点数不行，需自行转换
批量输出	不可	可。通过指定size参数
特定分布	涵盖了常用的几个分布; 只能单个输出	几乎涵盖了所有分布；可批量输出
有放回和无放回（选取元素时）	sample()无放回选k个；choices()有放回选k个	choice()可有参数来指定有/无放回
不等概率取样	choices()指定weights参数	choice()指定p参数
shuffle()函数	random.shuffle(x)只支持list	numpy.random.shuffle(x)支持array和list

numpy将原生random的sample()和choices()合并为一个numpy.choice()函数。