如何在Python中用不同T值重复流程并计算速度标准差

针对每个T值，我会得到一个速度列表并计算其标准差。我希望尝试多个不同的T值，无需重复复制运行代码，就能为每个T值生成速度列表并计算标准差。求Python实现方案。

import numpy as np
from numpy.random import random

T2 = 1 #change as needed
N = 100  #number of loops (random walkers)
random_walk = np.empty((N,100)) #first element is row, second is column
for i in range (len(random_walk)):
    U_pos = 0
    U_neg = 0 
    U = U_pos - U_neg
    P_neg = 0.5*(1 - np.tanh(U/(2*T2)))
    P_pos = 0.5*(1 + np.tanh(U/(2*T2)))
    for j in range (len(random_walk[0])):
        random_walk[i][0] = 0
        if (random() > 0) and (P_neg > random()):  
            movement = -1
            U_j = np.random.pareto(2,1)+0.5
            if U_j > U_neg: 
                U_neg = U_j
            else: 
                U_neg = U_neg
            U = U_pos - U_neg
            P_neg = 0.5*(1 - np.tanh(U/(2*T2)))
            P_pos = 0.5*(1 + np.tanh(U/(2*T2)))
        else:
            movement = 1
            U_j = np.random.pareto(2,1)+0.5
            if U_j > U_pos:
                U_pos = U_j
            else: 
                U_pos = U_pos
            U = U_pos - U_neg
            P_pos = 0.5*(1 + np.tanh(U/(2*T2)))
            P_neg = 0.5*(1 - np.tanh(U/(2*T2)))   
        random_walk[i][j] = random_walk[i][j-1] + movement

核心思路 #

将单个T值的随机漫步逻辑封装成可复用函数，通过遍历预设的T值列表批量完成计算，避免重复复制代码，同时修复原代码中的索引越界问题。

完整代码 #

import numpy as np

def calculate_walker_speeds(T, num_walkers=100, num_steps=100):
    """
    计算给定T值下所有随机漫步者的平均速度列表
    参数:
        T: 温度参数
        num_walkers: 漫步者数量
        num_steps: 每个漫步者的总步数
    返回:
        speeds: 每个漫步者的平均速度列表（最终位移/总步数）
    """
    random_walk = np.empty((num_walkers, num_steps))
    for i in range(num_walkers):
        U_pos = 0
        U_neg = 0
        U = U_pos - U_neg
        P_neg = 0.5 * (1 - np.tanh(U / (2 * T)))
        P_pos = 0.5 * (1 + np.tanh(U / (2 * T)))
        
        # 初始化第一步位置
        random_walk[i][0] = 0
        # 从第2步开始计算，避免j-1索引越界
        for j in range(1, num_steps):
            if np.random.random() < P_neg:
                movement = -1
                U_j = np.random.pareto(2, 1)[0] + 0.5
                if U_j > U_neg:
                    U_neg = U_j
            else:
                movement = 1
                U_j = np.random.pareto(2, 1)[0] + 0.5
                if U_j > U_pos:
                    U_pos = U_j
            
            # 更新U值和移动概率
            U = U_pos - U_neg
            P_neg = 0.5 * (1 - np.tanh(U / (2 * T)))
            P_pos = 0.5 * (1 + np.tanh(U / (2 * T)))
            
            # 更新当前位置
            random_walk[i][j] = random_walk[i][j-1] + movement
    
    # 计算每个漫步者的平均速度：最终位移除以总步数
    final_positions = random_walk[:, -1]
    speeds = final_positions / num_steps
    return speeds

# 定义要测试的T值列表
T_values = [0.5, 1, 2, 5]

# 批量计算每个T值对应的速度列表和标准差
results = {}
for T in T_values:
    speeds = calculate_walker_speeds(T)
    speed_std = np.std(speeds)
    results[T] = {
        "speeds": speeds,
        "std_dev": speed_std
    }
    print(f"T={T}: 速度标准差 = {speed_std:.4f}")

# 如需查看某个T值的速度列表，可直接调用
# print(results[1]["speeds"])

关键优化点 #

• 函数封装：将随机漫步核心逻辑封装为函数，参数化T值、漫步者数量和步数，大幅提升代码复用性。
• 修复索引错误：内层循环从第2步（range(1, num_steps)）开始，避免j=0时访问random_walk[i][j-1]导致的数组越界问题。
• 简化条件判断：移除原代码中多余的random() > 0判断（np.random.random()返回值默认在(0,1)区间），直接用np.random.random() < P_neg判断移动方向。
• 批量处理：通过遍历T_values列表自动完成多T值计算，结果存储在字典中，方便后续分析和调用。

内容的提问来源于stack exchange，提问作者Bao Khanh