numpy.random.rand(d0, d1, ..., dn)：生成一个或多个在[0, 1)区间上均匀分布的随机浮点数数组。如果提供多个参数，它们会被解释为数组的维度。
numpy.random.randn(d0, d1, ..., dn)：生成一个或多个服从标准正态分布（平均值为0，标准差为1）的随机浮点数数组。
numpy.random.randint(low, high=None, size=None, dtype='l')：生成指定范围内的整数，可以设置尺寸以生成多维数组。
numpy.random.choice(a, size=None, replace=True, p=None)：从一维数组a中根据可选的概率分布抽样出大小为size的样本，可以选择是否允许替换。
numpy.random.normal(loc=0.0, scale=1.0, size=None)：生成正态分布（高斯分布）的随机数，可指定均值（loc）和标准差（scale）。
numpy.random.uniform(low=0.0, high=1.0, size=None)：生成在指定区间的均匀分布随机数。
numpy.random.binomial(n, p, size=None)：生成符合二项分布的随机数。
numpy.random.poisson(lam=1.0, size=None)：生成泊松分布的随机数。
numpy.random.seed(seed=None)：设置随机数生成器的种子，以便重复实验时获得相同的随机数序列。

二、实例：

1. numpy.random.rand

numpy.random.rand(d0, d1, ..., dn)：生成一个或多个在[0, 1)区间上均匀分布的随机浮点数数组。如果提供多个参数，它们会被解释为数组的维度。


import numpy as np
 
# 生成一个单个随机浮点数
single_random_number = np.random.rand()
print(single_random_number)  # 输出类似于：0.432178
 
# 生成一个长度为5的一维数组
random_array_1d = np.random.rand(5)
print(random_array_1d)  # 输出类似于：[0.345678, 0.789012, 0.123456, 0.901234, 0.567890]
 
# 生成一个2行3列的二维数组
random_array_2d = np.random.rand(2, 3)
print(random_array_2d)  # 输出类似于：
# [[0.234567, 0.678901, 0.012345],
#  [0.890123, 0.345678, 0.765432]]
 
# 更复杂的多维数组
random_array_3d = np.random.rand(2, 3, 4)
print(random_array_3d.shape)  # 输出 (2, 3, 4)，代表一个2×3×4的三维数组
'运行

2. numpy.random.randn

numpy.random.randn(d0, d1, ..., dn)：生成一个或多个服从标准正态分布（平均值为0，标准差为1）的随机浮点数数组。


import numpy as np
 
# 生成一个服从标准正态分布的单个随机浮点数
single_random_gaussian = np.random.randn()
print(single_random_gaussian)  # 输出类似于：-1.2345 或 2.5678
 
# 生成一个长度为5的一维数组，其中每个元素都服从标准正态分布
random_gaussians_1d = np.random.randn(5)
print(random_gaussians_1d)  # 输出类似于：[-1.5432, 0.9876, -0.3456, 1.2345, -0.7890]
 
# 生成一个2行3列的二维数组，所有元素也服从标准正态分布
random_gaussians_2d = np.random.randn(2, 3)
print(random_gaussians_2d)  # 输出类似于：
# [[-0.7654,  1.2345, -1.5678],
#  [ 1.0987, -0.3456,  0.6789]]
 
# 更复杂的多维数组
random_gaussians_3d = np.random.randn(2, 3, 4)
print(random_gaussians_3d.shape)  # 输出 (2, 3, 4)，意味着生成了一个2×3×4的三维数组，其中所有元素都来自标准正态分布
'运行

3. numpy.random.randint

基本语法如下：

numpy.random.randint(low, high=None, size=None, dtype='l')

生成指定范围内的整数，可以设置尺寸以生成多维数组。

low：必需参数，表示生成随机数的下界（包含此边界）。
high：必需参数，除非提供了 size 参数，此时 high 可选。表示生成随机数的上界（不包含此边界），即生成的随机数会小于high。
size：可选参数，如果提供，则输出为具有指定形状的随机数数组。例如，size=(m,n) 将生成一个 m×n 的二维数组。
dtype：可选参数，用于指定生成随机数的数据类型，默认为有符号长整型（'l' 对应于 int64）。


import numpy as np
 
# 生成一个1到10之间的随机整数
random_integer = np.random.randint(1, 11)
print(random_integer)  # 输出类似于：7
 
# 生成一个形状为(3, 4)的二维数组，元素范围从0到9
random_integers_2d = np.random.randint(0, 10, size=(3, 4))
print(random_integers_2d)  # 输出类似于：
# [[3, 7, 4, 1],
#  [9, 2, 8, 5],
#  [6, 0, 1, 9]]
 
# 生成一个一维数组，长度为5，元素范围从-10到10
random_integers_negative_to_positive = np.random.randint(-10, 11, size=5)
print(random_integers_negative_to_positive)  # 输出类似于：[-7, 3, 0, 8, -1]
'运行

4. numpy.random.choice

用于从给定的一维数组或者序列中随机抽取元素或多个元素，从而实现数据抽样。这个函数在统计学、机器学习等领域非常有用，比如构建随机样本集、模拟随机事件等。基本语法如下：

numpy.random.choice(a, size=None, replace=True, p=None)

a：必需参数，可以是一个一维数组或者整数序列，从中进行选择。
size：可选参数，定义了抽取元素的数量和形状。如果是一个整数，那么抽取固定数量的独立样本；如果是元组形式，则确定输出数组的形状。
replace：可选参数，默认为 True，表示是否允许重复抽取（有放回抽样）。若设置为 False，则进行无放回抽样，确保抽取的元素互不相同，直到耗尽所有元素为止。
p：可选参数，是一个与 a 同型的数组，其中的元素值表示对应元素被抽取的概率分布。如果不提供，则每个元素被抽取的概率相等。


import numpy as np
 
# 假设我们有一个列表
choices = ['apple', 'banana', 'cherry', 'date']
 
# 随机抽取一个元素
random_item = np.random.choice(choices)
print(random_item)  # 可能输出 'apple'
 
# 随机抽取3个不同的元素，不放回
random_items_unique = np.random.choice(choices, size=3, replace=False)
print(random_items_unique)  # 可能输出 array(['banana', 'cherry', 'date'], dtype='<U6')
 
# 根据概率抽取，比如 'apple' 被抽中的概率是 0.5，其余各为 0.25
probabilities = [0.5, 0.25, 0.125, 0.125]
weighted_random_item = np.random.choice(choices, p=probabilities)
print(weighted_random_item)  # 更可能输出 'apple'
'运行

5. `numpy.random.normal`

是 Python 中 NumPy 库的 numpy.random 模块的一部分，用于生成来自正态（高斯）分布的随机数。正态分布是一种连续概率分布，由其中心（均值）和扩散程度（标准差）定义。它呈钟形，对称于均值，并由于在中心极限定理中的核心地位而在统计学和模拟中广泛应用。

用法如下：

numpy.random.normal(loc=0.0, scale=1.0, size=None)

loc (float, 可选)：此参数指定正态分布的均值或中心。默认设置为 0.0。
scale (float, 可选)：此参数代表正态分布的标准差，决定了其扩散程度或宽度。默认值为 1.0。
size (int 或 tuple of ints, 可选)：此参数定义了包含生成随机数的输出数组的形状。如果 size 是一个整数，它返回长度为该整数的一维数组。如果 size 是一个元组，则生成具有相应维度的数组。如果未提供 size 或其值为 None，则返回单个浮点数。


import numpy as np
 
# 从标准正态分布（均值 = 0，标准差 = 1）生成一个单个随机数
single_value = np.random.normal()
print(single_value)
 
# 从均值 = 5、标准差 = 2 的正态分布中生成一个长度为 10 的随机数向量
random_vector = np.random.normal(loc=5, scale=2, size=10)
print(random_vector)
 
# 生成一个 2D 数组（3 行 x 4 列）的随机数，来自均值 = -1、标准差 = 0.5 的正态分布
random_2d_array = np.random.normal(loc=-1, scale=0.5, size=(3, 4))
print(random_2d_array)
'运行

6.`numpy.random.uniform`

是 Python 中 NumPy 库的 numpy.random 模块的一部分，用于生成均匀分布的随机数。

用法如下：

numpy.random.uniform(low=0.0, high=1.0, size=None)

low (float, 可选)：此参数指定均匀分布的下限（最小可能值）。默认设置为 0.0。
high (float, 可选)：此参数代表均匀分布的上限（最大可能值）。默认值为 1.0。
size (int 或 tuple of ints, 可选)：此参数定义了包含生成随机数的输出数组的形状。如果 size 是一个整数，它返回长度为该整数的一维数组。如果 size 是一个元组，则生成具有相应维度的数组。如果未提供 size 或其值为None，则返回单个浮点数。


import numpy as np
 
# 从 [0, 1) 范围内的标准均匀分布生成一个单个随机数
single_value = np.random.uniform()
print(single_value)
 
# 从 [-5, 6) 范围内的均匀分布中生成一个长度为 10 的随机数向量
random_vector = np.random.uniform(low=-5, high=6, size=10)
print(random_vector)
 
# 生成一个 2D 数组（3 行 x 4 列）的随机数，范围在 [0.9, 1.1)
random_2d_array = np.random.uniform(low=0.9, high=1.1, size=(3, 4))
print(random_2d_array)
'运行

7.numpy.random.binomial

是 Python 中 NumPy 库 numpy.random 模块提供的一个函数，用于生成符合二项分布的随机数。二项分布描述了在一系列独立的伯努利试验（每次试验只有“成功”或“失败”两种可能结果）中，成功的次数的统计分布情况。

numpy.random.binomial(n, p, size=None)

n (int): 这是每个伯努利试验序列的总试验次数。必须为非负整数。
p (float): 这是单次伯努利试验中成功的概率，取值范围为 0 到 1（含两端点）。它决定了每个试验中成功的相对频率。
size (int 或 tuple of ints, optional): 定义了输出数组的形状。如果 size 是一个整数，返回一维数组；如果 size 是一个元组，则生成具有相应维度的数组。若未指定 size 或其值为 None，则返回单个整数。


import numpy as np
 
# 在 10 次独立试验中，成功概率为 0..jpg 的情况下，生成一个单次观测值
single_observation = np.random.binomial(n=10, p=0.6)
print(single_observation)
 
# 同样条件下，生成一组 5 个独立的二项分布观测值
multiple_observations = np.random.binomial(n=10, p=0.6, size=5)
print(multiple_observations)
 
# 生成一个 3 行 x 4 列的 2D 数组，每项表示 20 次试验中成功概率为 0.3 的观测值
random_2d_array = np.random.binomial(n=20, p=0.3, size=(3, 4))
print(random_2d_array)
'运行

8.`numpy.random.poisson`

是 Python 中 NumPy 库 numpy.random 模块提供的一个函数，用于生成符合泊松分布的随机数。泊松分布是一种统计与概率论中常用的离散概率分布，它描述了在单位时间内（或单位面积、单位体积等）发生某类随机事件的次数的统计规律，尤其适用于事件发生次数在单位时间（或单位空间）内相对较少且相互独立的情况。

numpy.random.poisson(lam=1.0, size=None)

参数：

lam (float, optional): 泊松分布的率参数（λ），即单位时间（或单位空间）内平均发生的事件次数。它是正数，决定了分布的形状和位置。默认值为 1.0。
size (int or tuple of ints, optional): 定义了输出数组的形状。如果 size 是一个整数，返回一维数组；如果 size 是一个元组，则生成具有相应维度的数组。若未指定 size 或其值为 None，则返回单个整数。


import numpy as np
 
# 在单位时间内，平均发生 4 次事件的情况下，生成一个单次观测值
single_observation = np.random.poisson(lam=4)
print(single_observation)
 
# 同样条件下，生成一组 5 个独立的泊松分布观测值
multiple_observations = np.random.poisson(lam=4, size=5)
print(multiple_observations)
 
# 生成一个 3 行 x 4 列的 2D 数组，每项表示在平均发生 3 次事件的条件下，单位时间内的观测值
random_2d_array = np.random.poisson(lam=3, size=(3, 4))
print(random_2d_array)
'运行

9. `numpy.random.seed`

是 NumPy 库中 numpy.random 模块的一个函数，用于设置 NumPy 随机数生成器的种子（seed）。在使用随机数时，设置种子的主要目的是为了确保可重复性，即当你使用相同的种子时，无论何时运行程序，都会得到完全一样的随机数序列。

numpy.random.seed(seed=None)

参数：

seed (int or None, optional): 一个整数，用作随机数生成器的种子。如果提供了种子值，那么每次使用相同的种子值初始化随机数生成器时，后续生成的随机数序列将是确定的和可复现的。如果 seed 为 None 或未指定，则会尝试从系统级别的源（如操作系统的随机数生成器或当前时间）获取一个随机种子值。这通常会导致每次运行程序时生成不同的随机数序列。


import numpy as np
 
# 设置固定的种子值为 42
np.random.seed(42)
 
# 现在生成的随机数序列将基于种子值 42，因此每次运行这段代码时，结果都相同
random_numbers = np.random.randn(10)
print(random_numbers)
 
# 如果不设置种子，或者设置为 None，则每次运行时，由于使用了系统当前时间等动态信息作为种子，
# 所生成的随机数序列将是不确定的，每次运行结果不同
np.random.seed()
another_random_numbers = np.random.randn(10)
print(another_random_numbers)
'运行

第一次执行：

第二次执行：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/966105