Python 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的随机数生成功能。在你的下一个项目中，不妨尝试运用这些知识，让随机性为你服务！🎲✨

---

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

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/qq_41187124/article/details/157775037