7.2 常用随机数生成函数

7.2 常用随机数生成函数

NumPy 随机数生成：常用函数详解

7.2 常用随机数生成函数

NumPy 提供了多种生成随机数的函数，涵盖了从简单均匀分布到复杂概率分布的各种需求。以下是一些最常用的函数：

1. rand(): 生成服从均匀分布的随机数（0 到 1 之间）。

2. randn(): 生成服从标准正态分布（均值为 0，标准差为 1）的随机数。

3. randint(): 生成指定范围内的随机整数。

4. random_sample()/random()/ranf()/sample(): 生成 0 到 1 之间的随机浮点数。

5. choice(): 从给定数组中随机选择元素。

6. shuffle(): 随机打乱数组中的元素顺序（原地操作）。

7. permutation(): 返回一个随机排列的数组（不改变原数组）。

8. normal(): 生成服从正态分布的随机数（可指定均值和标准差）。

9. uniform(): 生成服从均匀分布的随机数（可指定范围）。

10. binomial(): 生成服从二项分布的随机数。

接下来，我们将逐一详细介绍这些函数，并提供代码示例。

7.2.1 rand()

rand(d0, d1, ..., dn) 函数用于生成服从均匀分布的随机数，范围在 [0, 1) 之间。参数 d0, d1, ..., dn 指定了生成数组的形状。

import numpy as np
# 生成一个 5x3 的随机数组，元素服从均匀分布
random_array = np.random.rand(5, 3)
print(random_array)
​

代码解释：

• np.random.rand(5, 3) 生成一个形状为 (5, 3) 的 NumPy 数组，其中的每个元素都是从 0 到 1 之间的均匀分布中随机抽取的。

7.2.2 randn()

randn(d0, d1, ..., dn) 函数用于生成服从标准正态分布（均值为 0，标准差为 1）的随机数。参数 d0, d1, ..., dn 指定了生成数组的形状。

import numpy as np
# 生成一个 4x4 的随机数组，元素服从标准正态分布
normal_array = np.random.randn(4, 4)
print(normal_array)
​

代码解释：

• np.random.randn(4, 4) 生成一个形状为 (4, 4) 的 NumPy 数组，其中的每个元素都是从标准正态分布中随机抽取的。

7.2.3 randint()

randint(low, high=None, size=None, dtype=int) 函数用于生成指定范围内的随机整数。

• low: 范围的下界（包含）。

• high: 范围的上界（不包含）。如果未指定，则生成的整数范围是 [0, low)。

• size: 输出数组的形状。

• dtype: 输出数组的数据类型。

import numpy as np
# 生成一个 1 到 10 之间的随机整数
random_integer = np.random.randint(1, 11)
print(random_integer)
# 生成一个 3x2 的随机整数数组，范围在 0 到 5 之间
random_integer_array = np.random.randint(0, 6, size=(3, 2))
print(random_integer_array)
​

代码解释：

• np.random.randint(1, 11) 生成一个 1 到 10 之间的随机整数（包括 1，不包括 11）。

• np.random.randint(0, 6, size=(3, 2)) 生成一个形状为 (3, 2) 的 NumPy 数组，其中的每个元素都是 0 到 5 之间的随机整数。

7.2.4 random_sample()/random()/ranf()/sample()

这些函数的功能相同，都用于生成 0 到 1 之间的随机浮点数。它们可以接受一个 size 参数来指定输出数组的形状。

import numpy as np
# 生成一个随机浮点数
random_float = np.random.random_sample()
print(random_float)
# 生成一个 2x4 的随机浮点数数组
random_float_array = np.random.random_sample(size=(2, 4))
print(random_float_array)
​

代码解释：

• np.random.random_sample() 生成一个 0 到 1 之间的随机浮点数。

• np.random.random_sample(size=(2, 4)) 生成一个形状为 (2, 4) 的 NumPy 数组，其中的每个元素都是 0 到 1 之间的随机浮点数。

7.2.5 choice()

choice(a, size=None, replace=True, p=None) 函数用于从给定数组中随机选择元素。

• a: 可以是一个数组，也可以是一个整数。如果是整数，则相当于 np.arange(a)。

• size: 输出数组的形状。

• replace: 是否允许重复选择。默认为 True。

• p: 一个与 a 长度相同的数组，指定每个元素被选择的概率。

import numpy as np
# 从数组 [1, 2, 3, 4, 5] 中随机选择一个元素
random_element = np.random.choice([1, 2, 3, 4, 5])
print(random_element)
# 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，允许重复选择
random_elements = np.random.choice([1, 2, 3, 4, 5], size=3)
print(random_elements)
# 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，不允许重复选择
random_elements_no_replace = np.random.choice([1, 2, 3, 4, 5], size=3, replace=False)
print(random_elements_no_replace)
# 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，指定选择概率
probabilities = [0.1, 0.2, 0.3, 0.2, 0.2]
random_elements_with_prob = np.random.choice([1, 2, 3, 4, 5], size=3, p=probabilities)
print(random_elements_with_prob)
​

代码解释：

• np.random.choice([1, 2, 3, 4, 5]) 从数组 [1, 2, 3, 4, 5] 中随机选择一个元素。

• np.random.choice([1, 2, 3, 4, 5], size=3) 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，允许重复选择。

• np.random.choice([1, 2, 3, 4, 5], size=3, replace=False) 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，不允许重复选择。

• np.random.choice([1, 2, 3, 4, 5], size=3, p=probabilities) 从数组 [1, 2, 3, 4, 5] 中随机选择 3 个元素，根据 probabilities 数组指定的概率进行选择。

7.2.6 shuffle()

shuffle(x) 函数用于随机打乱数组中的元素顺序。这是一个原地操作，会直接修改原数组。

import numpy as np
# 创建一个数组
my_array = np.array([1, 2, 3, 4, 5])
# 随机打乱数组中的元素顺序
np.random.shuffle(my_array)
print(my_array)
​

代码解释：

• np.random.shuffle(my_array) 随机打乱 my_array 数组中的元素顺序。注意，这是一个原地操作，会直接修改 my_array。

7.2.7 permutation()

permutation(x) 函数用于返回一个随机排列的数组。如果 x 是一个整数，则相当于 np.random.permutation(np.arange(x))。与 shuffle() 不同，permutation() 不会修改原数组。

import numpy as np
# 创建一个数组
my_array = np.array([1, 2, 3, 4, 5])
# 返回一个随机排列的数组
permuted_array = np.random.permutation(my_array)
print(permuted_array)
print(my_array)  # 原数组未被修改
# 对一个整数进行排列
permuted_range = np.random.permutation(5)
print(permuted_range)
​

代码解释：

• np.random.permutation(my_array) 返回一个 my_array 数组的随机排列。原数组 my_array 不会被修改。

• np.random.permutation(5) 返回一个 np.arange(5) 的随机排列，即 [0, 1, 2, 3, 4] 的随机排列。

7.2.8 normal()

normal(loc=0.0, scale=1.0, size=None) 函数用于生成服从正态分布的随机数。

• loc: 均值（期望值）。

• scale: 标准差。

• size: 输出数组的形状。

import numpy as np
# 生成一个服从正态分布的随机数，均值为 5，标准差为 2
random_normal = np.random.normal(loc=5, scale=2)
print(random_normal)
# 生成一个 3x3 的随机数组，元素服从正态分布，均值为 0，标准差为 1
random_normal_array = np.random.normal(size=(3, 3))
print(random_normal_array)
​

代码解释：

• np.random.normal(loc=5, scale=2) 生成一个服从正态分布的随机数，均值为 5，标准差为 2。

• np.random.normal(size=(3, 3)) 生成一个形状为 (3, 3) 的 NumPy 数组，其中的每个元素都服从标准正态分布（均值为 0，标准差为 1）。

7.2.9 uniform()

uniform(low=0.0, high=1.0, size=None) 函数用于生成服从均匀分布的随机数。

• low: 范围的下界（包含）。

• high: 范围的上界（不包含）。

• size: 输出数组的形状。

import numpy as np
# 生成一个服从均匀分布的随机数，范围在 1 到 10 之间
random_uniform = np.random.uniform(low=1, high=10)
print(random_uniform)
# 生成一个 2x5 的随机数组，元素服从均匀分布，范围在 -1 到 1 之间
random_uniform_array = np.random.uniform(low=-1, high=1, size=(2, 5))
print(random_uniform_array)
​

代码解释：

• np.random.uniform(low=1, high=10) 生成一个服从均匀分布的随机数，范围在 1 到 10 之间。

• np.random.uniform(low=-1, high=1, size=(2, 5)) 生成一个形状为 (2, 5) 的 NumPy 数组，其中的每个元素都服从均匀分布，范围在 -1 到 1 之间。

7.2.10 binomial()

binomial(n, p, size=None) 函数用于生成服从二项分布的随机数。

• n: 试验次数。

• p: 每次试验成功的概率。

• size: 输出数组的形状。

import numpy as np
# 模拟 10 次抛硬币，每次抛硬币成功的概率为 0.5
random_binomial = np.random.binomial(n=10, p=0.5)
print(random_binomial)
# 模拟 10 个人，每个人抛 10 次硬币，每次抛硬币成功的概率为 0.5
random_binomial_array = np.random.binomial(n=10, p=0.5, size=10)
print(random_binomial_array)
​

代码解释：

• np.random.binomial(n=10, p=0.5) 模拟 10 次抛硬币，每次抛硬币成功的概率为 0.5，返回成功的次数。

• np.random.binomial(n=10, p=0.5, size=10) 模拟 10 个人，每个人抛 10 次硬币，每次抛硬币成功的概率为 0.5，返回每个人成功的次数。

随机数生成流程图

以下是使用 Mermaid 绘制的随机数生成函数调用流程图：

流程图解释：

1. 开始 (A)：流程的起点。

2. 选择随机数生成函数 (B)：根据需求选择合适的随机数生成函数。

3. 各个函数 (C-L)：rand(), randn(), randint(), random_sample(), choice(), shuffle(), permutation(), normal(), uniform(), binomial()。

4. 生成随机数 (M-V)：根据选择的函数生成对应的随机数。

5. 结束 (Z)：流程的终点。