Python NumPy - 随机数生成 正态分布与均匀分布

👋 大家好，欢迎来到我的技术博客！ 📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。 🎯 本文将围绕NumPy这个话题展开，希望能为你带来一些启发或实用的参考。 🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！

文章目录

• Python NumPy – 随机数生成：正态分布与均匀分布 🎲
• • 🔍 为什么需要理解随机数生成？
  • • 🧠 随机数的应用场景
  • 📊 均匀分布：平等机会的艺术
  • • 🔢 连续均匀分布的特性
    • 💻 NumPy中的均匀分布实现
    • 🎯 实际应用案例
  • 📈 正态分布：自然界的选择
  • • 📐 正态分布的数学基础
    • 🧪 NumPy中的正态分布实现
    • 🌟 正态分布的独特性质
  • 🔄 随机数生成器的核心机制
  • • 🔧 NumPy的随机数生成架构
    • 🎯 种子和可重现性
  • 📊 可视化随机分布
  • 🎯 高级随机数生成技巧
  • • 🔄 随机抽样技术
    • 🎲 随机过程模拟
  • 📊 性能优化和最佳实践
  • 🎯 实际应用场景
  • • 📊 数据科学中的应用
    • 🎮 游戏开发中的应用
  • 📈 统计检验和质量控制
  • 🎯 最佳实践总结
  • 📚 学习资源和进一步阅读
  • • 📘 推荐书籍
    • 🌐 在线资源
    • 🎓 学术论文
  • 🎯 结语

Python NumPy – 随机数生成：正态分布与均匀分布 🎲

在数据科学和机器学习的世界中，随机数生成是一个基础而重要的概念。无论是进行统计分析、模拟实验，还是训练神经网络，我们都需要依赖高质量的随机数来确保结果的可靠性和有效性。NumPy作为Python生态系统中最核心的科学计算库之一，提供了强大而灵活的随机数生成功能。

🔍 为什么需要理解随机数生成？

随机数在现代计算中扮演着至关重要的角色。从金融风险评估到物理模拟，从密码学到游戏开发，随机性都是不可或缺的元素。然而，计算机本质上是确定性的设备，它们如何产生真正的"随机"数呢？这正是伪随机数生成器发挥作用的地方。

🧠 随机数的应用场景

• 统计抽样：从大数据集中抽取代表性样本
• 蒙特卡洛模拟：通过大量随机试验来估算复杂问题的解
• 机器学习：初始化权重、数据增强、dropout等技术
• 密码学：生成密钥和随机盐值
• 游戏开发：创建不可预测的游戏体验

📊 均匀分布：平等机会的艺术

均匀分布是最简单也是最基本的概率分布之一。在这种分布下，每个可能的结果都具有相等的概率。想象一下掷骰子的情景——每个面朝上的概率都是1/6，这就是离散均匀分布的一个典型例子。

🔢 连续均匀分布的特性

连续均匀分布在指定区间内的任何点都有相同的概率密度。如果一个随机变量X在区间[a,b]上服从均匀分布，那么它的概率密度函数为：

f(x) = 1/(b-a), 当 a ≤ x ≤ b
f(x) = 0, 其他情况

这种分布的特点是简单、直观，并且在很多情况下都能提供良好的起点。

💻 NumPy中的均匀分布实现

让我们来看看如何使用NumPy生成均匀分布的随机数：

import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子以确保结果可重现
np.random.seed(42)

# 生成0到1之间的均匀分布随机数
uniform_random = np.random.uniform(0, 1, 1000)
print("均匀分布随机数样本:", uniform_random[:10])

# 生成指定范围内的均匀分布随机数
custom_uniform = np.random.uniform(–5, 5, 1000)
print("自定义范围均匀分布:", custom_uniform[:10])

# 创建更复杂的示例
def demonstrate_uniform_distribution():
"""演示均匀分布的各种用法"""

# 1. 基本的一维数组
arr_1d = np.random.uniform(0, 10, size=100)

# 2. 多维数组
arr_2d = np.random.uniform(–1, 1, size=(5, 5))

# 3. 不同形状的数组
arr_3d = np.random.uniform(0, 100, size=(2, 3, 4))

print("一维均匀分布数组:", arr_1d.shape)
print("二维均匀分布数组:", arr_2d.shape)
print("三维均匀分布数组:", arr_3d.shape)

return arr_1d, arr_2d, arr_3d

# 执行演示
demo_arrays = demonstrate_uniform_distribution()

🎯 实际应用案例

均匀分布在实际应用中有许多有趣的用途：

def practical_uniform_examples():
"""展示均匀分布的实际应用"""

# 1. 随机采样
population = np.arange(1, 1001) # 模拟1000人的群体
sample_indices = np.random.choice(len(population), size=100, replace=False)
sample = population[sample_indices]
print(f"随机抽样结果 (前10个): {sample[:10]}")

# 2. 随机打乱数据
data = np.array(['A', 'B', 'C', 'D', 'E', 'F', 'G'])
shuffled_data = np.random.permutation(data)
print(f"原始数据: {data}")
print(f"打乱后数据: {shuffled_data}")

# 3. 随机初始化权重
weights = np.random.uniform(–0.1, 0.1, size=(10, 5))
print(f"随机初始化权重矩阵形状: {weights.shape}")

# 4. 生成随机坐标
x_coords = np.random.uniform(0, 100, 50)
y_coords = np.random.uniform(0, 100, 50)
coordinates = list(zip(x_coords, y_coords))
print(f"随机坐标点 (前5个): {coordinates[:5]}")

practical_uniform_examples()

📈 正态分布：自然界的选择

如果说均匀分布代表了平等，那么正态分布则体现了自然界的智慧。从人类身高到考试成绩，从测量误差到股票收益率，正态分布无处不在。这种分布以其标志性的钟形曲线而闻名，也被称为高斯分布。

📐 正态分布的数学基础

正态分布由两个参数定义：

• 均值 (μ)：分布的中心位置
• 标准差 (σ)：分布的离散程度

其概率密度函数为：

f(x) = (1/√(2πσ²)) * e^(-(x-μ)²/(2σ²))

这个公式看起来可能有些复杂，但它的几何意义很直观：大多数数值集中在均值附近，随着距离均值越远，出现的概率越小。

🧪 NumPy中的正态分布实现

import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子
np.random.seed(42)

# 生成标准正态分布随机数 (均值=0, 标准差=1)
standard_normal = np.random.normal(0, 1, 1000)
print("标准正态分布样本:", standard_normal[:10])

# 生成自定义参数的正态分布随机数
custom_normal = np.random.normal(50, 15, 1000) # 均值=50, 标准差=15
print("自定义正态分布样本:", custom_normal[:10])

# 更多正态分布示例
def demonstrate_normal_distribution():
"""演示正态分布的各种用法"""

# 1. 不同参数的正态分布
normal_low_var = np.random.normal(0, 0.5, 1000) # 低方差
normal_high_var = np.random.normal(0, 3, 1000) # 高方差
normal_shifted = np.random.normal(5, 1, 1000) # 偏移均值

# 2. 多维正态分布
multivariate_normal = np.random.multivariate_normal(
mean=[0, 0],
cov=[[1, 0.5], [0.5, 1]],
size=1000
)

print("低方差正态分布样本:", normal_low_var[:5])
print("高方差正态分布样本:", normal_high_var[:5])
print("偏移均值正态分布样本:", normal_shifted[:5])
print("多维正态分布形状:", multivariate_normal.shape)

return normal_low_var, normal_high_var, normal_shifted, multivariate_normal

# 执行演示
normal_arrays = demonstrate_normal_distribution()

🌟 正态分布的独特性质

正态分布有许多令人着迷的性质，这些性质使得它在统计学中占据核心地位：

def explore_normal_properties():
"""探索正态分布的重要性质"""

# 生成大样本正态分布数据
large_sample = np.random.normal(100, 15, 100000)

# 1. 中心极限定理验证
print("=== 中心极限定理验证 ===")
print(f"样本均值: {np.mean(large_sample):.4f}")
print(f"理论均值: 100")
print(f"样本标准差: {np.std(large_sample):.4f}")
print(f"理论标准差: 15")

# 2. 68-95-99.7法则验证
mean_val = np.mean(large_sample)
std_val = np.std(large_sample)

within_1_sigma = np.sum(np.abs(large_sample – mean_val) <= std_val) / len(large_sample)
within_2_sigma = np.sum(np.abs(large_sample – mean_val) <= 2*std_val) / len(large_sample)
within_3_sigma = np.sum(np.abs(large_sample – mean_val) <= 3*std_val) / len(large_sample)

print("\\n=== 68-95-99.7法则验证 ===")
print(f"1σ范围内比例: {within_1_sigma:.3f} (理论: 0.68)")
print(f"2σ范围内比例: {within_2_sigma:.3f} (理论: 0.95)")
print(f"3σ范围内比例: {within_3_sigma:.3f} (理论: 0.997)")

# 3. 正态性检验的简单方法
from scipy import stats

# Shapiro-Wilk检验
statistic, p_value = stats.shapiro(large_sample[::100]) # 取子样本避免计算量过大
print(f"\\nShapiro-Wilk检验统计量: {statistic:.4f}")
print(f"P值: {p_value:.4f}")
if p_value > 0.05:
print("数据符合正态分布 (p > 0.05)")
else:
print("数据不符合正态分布 (p ≤ 0.05)")

explore_normal_properties()

🔄 随机数生成器的核心机制

了解随机数生成的背后机制对于正确使用这些工具至关重要。现代计算机使用的实际上是伪随机数生成器(Pseudo-Random Number Generators, PRNGs)，它们通过确定性算法产生看似随机的数字序列。

🔧 NumPy的随机数生成架构

import numpy as np

# 展示NumPy随机数生成器的不同方式
def random_generator_comparison():
"""比较不同的随机数生成方式"""

# 1. 传统方式 (已弃用但仍可用)
print("=== 传统方式 ===")
legacy_random = np.random.rand(5)
print(f"传统随机数: {legacy_random}")

# 2. 新的Generator接口 (推荐)
print("\\n=== 新Generator接口 ===")
rng = np.random.default_rng(seed=42)
new_random = rng.random(5)
print(f"新接口随机数: {new_random}")

# 3. 自定义随机数生成器
print("\\n=== 自定义生成器 ===")
custom_rng = np.random.Generator(np.random.PCG64(seed=123))
custom_random = custom_rng.random(5)
print(f"自定义生成器随机数: {custom_random}")

# 4. 不同分布的生成
print("\\n=== 多种分布对比 ===")
uniform_dist = rng.uniform(0, 10, 10)
normal_dist = rng.normal(5, 2, 10)
exponential_dist = rng.exponential(2, 10)

print(f"均匀分布: {uniform_dist}")
print(f"正态分布: {normal_dist}")
print(f"指数分布: {exponential_dist}")

random_generator_comparison()

🎯 种子和可重现性

在科学研究和工程实践中，能够重现结果是非常重要的。通过设置随机种子，我们可以确保每次运行代码时得到相同的结果。

def seed_demonstration():
"""演示种子的作用"""

print("=== 种子效果演示 ===")

# 不设置种子的情况
print("不设置种子:")
for i in range(3):
random_nums = np.random.rand(3)
print(f"第{i+1}次: {random_nums}")

print("\\n设置相同种子:")
for i in range(3):
np.random.seed(42)
random_nums = np.random.rand(3)
print(f"第{i+1}次: {random_nums}")

# 使用新的Generator接口
print("\\n使用Generator接口:")
rng1 = np.random.default_rng(seed=42)
rng2 = np.random.default_rng(seed=42)

print(f"rng1生成: {rng1.random(3)}")
print(f"rng2生成: {rng2.random(3)}")

seed_demonstration()

📊 可视化随机分布

可视化是理解数据分布的强大工具。通过图表，我们可以直观地看到不同分布的特征和差异。

import numpy as np
import matplotlib.pyplot as plt

def visualize_distributions():
"""可视化不同类型的分布"""

# 设置图形大小和样式
plt.figure(figsize=(15, 10))

# 生成数据
np.random.seed(42)
uniform_data = np.random.uniform(0, 10, 10000)
normal_data = np.random.normal(5, 2, 10000)

# 1. 均匀分布直方图
plt.subplot(2, 3, 1)
plt.hist(uniform_data, bins=50, alpha=0.7, color='skyblue', edgecolor='black')
plt.title('均匀分布直方图')
plt.xlabel('值')
plt.ylabel('频率')

# 2. 正态分布直方图
plt.subplot(2, 3, 2)
plt.hist(normal_data, bins=50, alpha=0.7, color='lightcoral', edgecolor='black')
plt.title('正态分布直方图')
plt.xlabel('值')
plt.ylabel('频率')

# 3. Q-Q图 (Quantile-Quantile Plot)
from scipy import stats
plt.subplot(2, 3, 3)
stats.probplot(normal_data, dist="norm", plot=plt)
plt.title('正态分布Q-Q图')
plt.grid(True)

# 4. 箱线图比较
plt.subplot(2, 3, 4)
plt.boxplot([uniform_data, normal_data], labels=['均匀分布', '正态分布'])
plt.title('分布比较箱线图')
plt.ylabel('值')

# 5. 密度图
plt.subplot(2, 3, 5)
plt.hist(uniform_data, bins=50, alpha=0.5, density=True, label='均匀分布')
plt.hist(normal_data, bins=50, alpha=0.5, density=True, label='正态分布')
plt.title('概率密度比较')
plt.xlabel('值')
plt.ylabel('密度')
plt.legend()

# 6. 散点图显示相关性
plt.subplot(2, 3, 6)
correlated_data = np.random.multivariate_normal([0, 0], [[1, 0.8], [0.8, 1]], 1000)
plt.scatter(correlated_data[:, 0], correlated_data[:, 1], alpha=0.5)
plt.title('相关正态分布散点图')
plt.xlabel('X')
plt.ylabel('Y')

plt.tight_layout()
plt.show()

# 注意：在实际环境中取消注释下面这行来显示图表
# visualize_distributions()

🎯 高级随机数生成技巧

掌握基本的随机数生成只是开始，真正精通需要了解一些高级技巧和最佳实践。

🔄 随机抽样技术

def advanced_sampling_techniques():
"""展示高级随机抽样技术"""

# 1. 加权随机抽样
print("=== 加权随机抽样 ===")
items = ['苹果', '香蕉', '橙子', '葡萄']
weights = [0.1, 0.3, 0.4, 0.2] # 权重总和应为1

rng = np.random.default_rng(42)
weighted_sample = rng.choice(items, size=20, p=weights)
unique, counts = np.unique(weighted_sample, return_counts=True)

print("加权抽样结果:")
for item, count in zip(unique, counts):
print(f" {item}: {count}次 ({count/20*100:.1f}%)")

# 2. 分层抽样
print("\\n=== 分层抽样 ===")
# 模拟不同年龄段的人群
age_groups = {
'儿童': np.arange(5, 13),
'青少年': np.arange(13, 18),
'成人': np.arange(18, 65),
'老年人': np.arange(65, 90)
}

stratified_sample = {}
for group, ages in age_groups.items():
sample_size = min(5, len(ages)) # 每组最多抽5个
stratified_sample[group] = rng.choice(ages, size=sample_size, replace=False)

for group, sample in stratified_sample.items():
print(f"{group}: {sample}")

# 3. 系统抽样
print("\\n=== 系统抽样 ===")
population = np.arange(1, 1001) # 1000个个体
sampling_interval = 10 # 每10个选1个
start_point = rng.integers(0, sampling_interval)
systematic_sample = population[start_point::sampling_interval][:20] # 取前20个

print(f"系统抽样起始点: {start_point}")
print(f"系统抽样结果: {systematic_sample}")

advanced_sampling_techniques()

🎲 随机过程模拟

随机过程在金融建模、物理学模拟等领域有广泛应用。

def random_process_simulation():
"""模拟随机过程"""

print("=== 随机游走模拟 ===")
rng = np.random.default_rng(42)

# 1D 随机游走
steps = 1000
step_choices = [–1, 1] # 向左或向右移动
random_steps = rng.choice(step_choices, size=steps)
position = np.cumsum(random_steps)

print(f"最终位置: {position[–1]}")
print(f"最大偏离原点: {np.max(np.abs(position))}")

# 几何布朗运动 (常用于股价模拟)
print("\\n=== 几何布朗运动 ===")
S0 = 100 # 初始价格
mu = 0.05 # 年化收益率
sigma = 0.2 # 波动率
T = 1 # 时间周期(年)
N = 252 # 交易日数
dt = T/N # 时间步长

# 生成路径
t = np.linspace(0, T, N)
W = np.random.standard_normal(size=N)
W = np.cumsum(W)*np.sqrt(dt) # 标准布朗运动

# 几何布朗运动
X = (mu–0.5*sigma**2)*t + sigma*W
S = S0*np.exp(X) # 股价路径

print(f"初始价格: ${S0}")
print(f"最终价格: ${S[–1]:.2f}")
print(f"最高价格: ${np.max(S):.2f}")
print(f"最低价格: ${np.min(S):.2f}")

# 泊松过程
print("\\n=== 泊松过程 ===")
lambda_rate = 3 # 平均每小时事件数
time_period = 10 # 10小时

# 在时间期内生成事件
events_count = rng.poisson(lambda_rate * time_period)
event_times = rng.uniform(0, time_period, events_count)
event_times.sort()

print(f"总事件数: {events_count}")
print(f"事件发生时间: {event_times[:10]}…") # 显示前10个

random_process_simulation()

📊 性能优化和最佳实践

在处理大规模数据时，随机数生成的性能变得至关重要。

import time

def performance_comparison():
"""比较不同随机数生成方法的性能"""

print("=== 性能比较 ===")
sizes = [1000, 10000, 100000]

for size in sizes:
print(f"\\n数组大小: {size:,}")

# 测试传统方法
start_time = time.time()
for _ in range(100):
_ = np.random.rand(size)
legacy_time = time.time() – start_time

# 测试新Generator方法
rng = np.random.default_rng(42)
start_time = time.time()
for _ in range(100):
_ = rng.random(size)
generator_time = time.time() – start_time

print(f" 传统方法平均时间: {legacy_time/100:.6f}秒")
print(f" Generator方法平均时间: {generator_time/100:.6f}秒")
print(f" 性能提升: {(legacy_time/generator_time):.2f}倍")

performance_comparison()

🎯 实际应用场景

让我们看看随机数生成在现实世界中的具体应用。

📊 数据科学中的应用

def data_science_applications():
"""数据科学中的随机数应用"""

print("=== 数据科学应用 ===")

# 1. 数据集分割
print("1. 训练/测试集分割")
dataset_size = 1000
indices = np.arange(dataset_size)
np.random.shuffle(indices)

train_size = int(0.8 * dataset_size)
train_indices = indices[:train_size]
test_indices = indices[train_size:]

print(f"训练集大小: {len(train_indices)}")
print(f"测试集大小: {len(test_indices)}")

# 2. 特征工程 – 添加噪声
print("\\n2. 特征噪声添加")
clean_data = np.sin(np.linspace(0, 4*np.pi, 100))
noise = np.random.normal(0, 0.1, 100) # 添加高斯噪声
noisy_data = clean_data + noise

print(f"原始数据范围: [{np.min(clean_data):.3f}, {np.max(clean_data):.3f}]")
print(f"噪声数据范围: [{np.min(noisy_data):.3f}, {np.max(noisy_data):.3f}]")

# 3. 交叉验证折分
print("\\n3. K折交叉验证")
k_folds = 5
data_indices = np.arange(100)
np.random.shuffle(data_indices)
fold_size = len(data_indices) // k_folds

for fold in range(k_folds):
start_idx = fold * fold_size
end_idx = start_idx + fold_size if fold < k_folds – 1 else len(data_indices)
validation_indices = data_indices[start_idx:end_idx]
training_indices = np.concatenate([
data_indices[:start_idx],
data_indices[end_idx:]
])
print(f"折{fold+1}: 训练{len(training_indices)}个, 验证{len(validation_indices)}个")

data_science_applications()

🎮 游戏开发中的应用

def game_development_applications():
"""游戏开发中的随机数应用"""

print("=== 游戏开发应用 ===")

# 1. 掉落率系统
print("1. 物品掉落系统")
drop_rates = {
'普通物品': 0.7,
'稀有物品': 0.2,
'史诗物品': 0.08,
'传说物品': 0.02
}

def get_random_drop():
rng = np.random.default_rng()
roll = rng.random()
cumulative_prob = 0

for item, rate in drop_rates.items():
cumulative_prob += rate
if roll <= cumulative_prob:
return item
return '普通物品' # 默认返回

# 模拟100次掉落
drops = [get_random_drop() for _ in range(100)]
unique_drops, counts = np.unique(drops, return_counts=True)

print("100次掉落结果:")
for item, count in zip(unique_drops, counts):
expected = drop_rates.get(item, 0) * 100
print(f" {item}: {count}次 (期望: {expected:.1f}次)")

# 2. 角色属性随机生成
print("\\n2. 角色属性生成")
class Character:
def __init__(self, name):
self.name = name
self.strength = max(1, int(np.random.normal(10, 3)))
self.agility = max(1, int(np.random.normal(10, 3)))
self.intelligence = max(1, int(np.random.normal(10, 3)))

def __str__(self):
return f"{self.name}(力量:{self.strength},敏捷:{self.agility},智力:{self.intelligence})"

characters = [Character(f"角色{i}") for i in range(5)]
for char in characters:
print(char)

# 3. 地牢地图生成
print("\\n3. 简单地图生成")
map_size = 20
dungeon_map = np.zeros((map_size, map_size))

# 随机放置墙壁
wall_positions = np.random.choice(map_size*map_size, size=int(0.3*map_size*map_size), replace=False)
for pos in wall_positions:
row, col = divmod(pos, map_size)
dungeon_map[row, col] = 1

# 放置玩家和宝藏
empty_positions = np.where(dungeon_map == 0)
player_pos = np.random.choice(len(empty_positions[0]))
treasure_pos = np.random.choice(len(empty_positions[0]))

player_row, player_col = empty_positions[0][player_pos], empty_positions[1][player_pos]
treasure_row, treasure_col = empty_positions[0][treasure_pos], empty_positions[1][treasure_pos]

dungeon_map[player_row, player_col] = 2 # 玩家
dungeon_map[treasure_row, treasure_col] = 3 # 宝藏

print("简化地牢地图 (0=空地, 1=墙, 2=玩家, 3=宝藏):")
print(dungeon_map[:10, :10]) # 显示部分地图

game_development_applications()

📈 统计检验和质量控制

生成的随机数是否真的满足预期的分布？这是需要通过统计检验来验证的问题。

from scipy import stats

def statistical_testing():
"""对随机数进行统计检验"""

print("=== 统计检验 ===")

# 生成测试数据
np.random.seed(42)
uniform_sample = np.random.uniform(0, 1, 10000)
normal_sample = np.random.normal(0, 1, 10000)

# 1. 均匀分布检验
print("1. 均匀分布检验")

# Kolmogorov-Smirnov检验
ks_statistic, ks_pvalue = stats.kstest(uniform_sample, 'uniform')
print(f" KS检验统计量: {ks_statistic:.6f}")
print(f" KS检验P值: {ks_pvalue:.6f}")

# 卡方检验
observed_freq, bin_edges = np.histogram(uniform_sample, bins=10)
expected_freq = len(uniform_sample) / 10
chi2_statistic, chi2_pvalue = stats.chisquare(observed_freq, [expected_freq]*10)
print(f" 卡方检验统计量: {chi2_statistic:.6f}")
print(f" 卡方检验P值: {chi2_pvalue:.6f}")

# 2. 正态分布检验
print("\\n2. 正态分布检验")

# Shapiro-Wilk检验
sw_statistic, sw_pvalue = stats.shapiro(normal_sample[::100]) # 子样本避免计算过久
print(f" Shapiro-Wilk检验统计量: {sw_statistic:.6f}")
print(f" Shapiro-Wilk检验P值: {sw_pvalue:.6f}")

# Anderson-Darling检验
ad_result = stats.anderson(normal_sample[::100], dist='norm')
print(f" Anderson-Darling检验统计量: {ad_result.statistic:.6f}")
print(f" 临界值: {ad_result.critical_values}")
print(f" 显著性水平: {ad_result.significance_level}")

# 3. 独立性检验
print("\\n3. 随机性检验")

# 游程检验 (简化版)
binary_sequence = (uniform_sample > 0.5).astype(int)
runs = 1
for i in range(1, len(binary_sequence)):
if binary_sequence[i] != binary_sequence[i–1]:
runs += 1

n1 = np.sum(binary_sequence)
n2 = len(binary_sequence) – n1
expected_runs = (2*n1*n2)/(n1+n2) + 1
variance_runs = (2*n1*n2*(2*n1*n2–n1–n2))/((n1+n2)**2*(n1+n2–1))
z_score = (runs – expected_runs) / np.sqrt(variance_runs)

print(f" 游程数: {runs}")
print(f" 期望游程数: {expected_runs:.2f}")
print(f" Z分数: {z_score:.4f}")
if abs(z_score) < 1.96:
print(" 序列独立性良好 (|Z| < 1.96)")
else:
print(" 序列可能存在相关性 (|Z| ≥ 1.96)")

statistical_testing()

🎯 最佳实践总结

通过前面的学习，我们可以总结出一些使用NumPy随机数生成的最佳实践：

def best_practices_summary():
"""总结随机数生成的最佳实践"""

print("=== 随机数生成最佳实践 ===")

print("✅ 1. 使用新的Generator接口")
print(" 推荐: np.random.default_rng(seed=42)")
print(" 避免: np.random.seed(42) (虽然仍可用)")

print("\\n✅ 2. 合理设置种子")
print(" – 开发阶段: 固定种子确保可重现")
print(" – 生产环境: 使用真实随机种子")
print(" – 多线程: 每个线程使用不同种子")

print("\\n✅ 3. 选择合适的分布")
print(" – 均匀分布: 当所有结果等可能时")
print(" – 正态分布: 模拟自然现象时")
print(" – 其他分布: 根据具体需求选择")

print("\\n✅ 4. 性能考虑")
print(" – 大批量生成比多次小批量快")
print(" – 预分配数组空间")
print(" – 避免在循环中重复创建生成器")

print("\\n✅ 5. 质量验证")
print(" – 使用统计检验验证分布")
print(" – 检查随机性的独立性")
print(" – 监控长期稳定性")

print("\\n✅ 6. 安全注意事项")
print(" – 密码学应用需要专门的安全随机数")
print(" – 避免将随机数用于安全敏感场景")
print(" – 定期更新随机数生成算法")

best_practices_summary()

📚 学习资源和进一步阅读

想要深入学习随机数生成和概率分布，以下是一些优秀的学习资源：

📘 推荐书籍

• 《统计学》 by David Freedman等 – 提供扎实的统计学基础
• 《概率论与数理统计》 by 盛骤等 – 中文经典教材
• 《Python数据科学手册》 by Jake VanderPlas – 实践导向的学习材料

🌐 在线资源

• NumPy官方文档 – 最权威的技术文档
• SciPy统计模块文档 – 丰富的统计检验方法
• Statistics How To – 统计学概念的通俗解释

🎓 学术论文

• 关于随机数生成算法的研究论文可以在arXiv上找到
• 对于特定应用领域的随机过程研究，建议查阅相关期刊

🎯 结语

随机数生成是数据科学和科学计算的基础技能之一。通过NumPy提供的强大功能，我们可以轻松生成各种分布的随机数，用于数据分析、模拟实验、机器学习等各种应用场景。

掌握均匀分布和正态分布这两种最基本的分布类型，不仅能够满足大部分日常需求，还能为我们进一步学习其他复杂分布奠定坚实基础。同时，理解随机数生成的原理和最佳实践，能够帮助我们在实际工作中避免常见陷阱，提高工作效率。

记住，在使用随机数时要始终考虑：

• 目的明确 – 为什么要使用随机数？
• 分布合适 – 哪种分布最符合需求？
• 质量保证 – 生成的随机数是否满足要求？
• 性能优化 – 是否有更高效的实现方式？

随着经验的积累，你会发现随机数生成不仅是技术活，更是一门艺术。它需要我们既要理解数学原理，又要结合实际应用场景，最终创造出既准确又高效的数据生成方案。

希望这篇详细的介绍能够帮助你更好地理解和使用NumPy的随机数生成功能。在你的下一个项目中，不妨尝试运用这些知识，让随机性为你服务！🎲✨

🙌 感谢你读到这里！ 🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。 💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！ 💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿 🔔 关注我，不错过下一篇干货！我们下期再见！✨