如何编写循环简化迭代脚本，实现多次计算迭代？

问题描述 #

当前计算需手动创建新变量（如Re1ii、lambda1ii）完成迭代，初始条件代码如下：

Re1i = 3.2*10**7
Re2i = (3/4)*Re1i
lambda1i = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1i**0.9)))))**2)
lambda2i = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2i**0.9)))))**2)
V1i = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1i*d2) + (lambda2i*l2*((A1**2)/(A2**2)))))    

手动迭代示例（仅展示一次）：

Re1ii = (rho*V1i*d1)/mu
Re2ii = (3/4)*Re1i  # 注：此处疑似笔误，应为基于新Re1ii计算
lambda1ii = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1ii**0.9)))))**2)
lambda2ii = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2ii**0.9)))))**2)
V1ii = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1ii*d2) + (lambda2ii*l2*((A1**2)/(A2**2)))))

# 后续需手动创建Re1iii、lambda1iii等，效率极低

需用循环自动完成迭代，避免手动创建新变量。

解决方案 #

核心逻辑是复用变量存储当前迭代值，每次迭代用前一轮结果覆盖更新即可，无需新建变量。推荐使用基于收敛条件的while循环（更符合工程计算需求），也可选择固定次数的for循环。

1. 收敛条件迭代（推荐） #

设置收敛阈值（如V1的变化量小于1e-6），满足条件时终止迭代，同时设置最大迭代次数防止死循环：

import numpy as np

# 预定义所有常量（替换为你的实际参数）
ks = 0.01
g = 9.81
dh = 0.5
d1 = 0.2
d2 = 0.15
l1 = 10
l2 = 8
A1 = np.pi*(d1/2)**2
A2 = np.pi*(d2/2)**2
rho = 1000
mu = 0.001

# 初始化变量
Re1 = 3.2 * 10**7
Re2 = (3/4) * Re1
lambda1 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1**0.9)))))**2)
lambda2 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2**0.9)))))**2)
V1 = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1*d2) + (lambda2*l2*((A1**2)/(A2**2)))))

# 迭代参数设置
max_iter = 1000
tolerance = 1e-6
iter_count = 0
converged = False

while not converged and iter_count < max_iter:
    # 保存上一轮V1用于收敛判断
    V1_prev = V1
    
    # 更新Re值
    Re1 = (rho * V1 * d1) / mu
    Re2 = (3/4) * Re1  # 修正原笔误，基于新Re1计算Re2
    
    # 更新lambda值
    lambda1 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1**0.9)))))**2)
    lambda2 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2**0.9)))))**2)
    
    # 计算新的V1
    V1 = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1*d2) + (lambda2*l2*((A1**2)/(A2**2)))))
    
    # 判断收敛
    if abs(V1 - V1_prev) < tolerance:
        converged = True
    
    iter_count += 1

# 输出结果
if converged:
    print(f"迭代收敛，共执行{iter_count}次")
    print(f"最终Re1: {Re1:.2e}, V1: {V1:.4f}")
else:
    print(f"达到最大迭代次数{max_iter}，未收敛")

2. 固定次数迭代 #

若无需收敛判断，仅执行指定次数迭代：

import numpy as np

# 常量定义同上...

# 初始化变量
Re1 = 3.2 * 10**7
Re2 = (3/4) * Re1
lambda1 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1**0.9)))))**2)
lambda2 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2**0.9)))))**2)
V1 = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1*d2) + (lambda2*l2*((A1**2)/(A2**2)))))

n_iterations = 10  # 设定迭代次数
for _ in range(n_iterations):
    Re1 = (rho * V1 * d1) / mu
    Re2 = (3/4) * Re1
    lambda1 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re1**0.9)))))**2)
    lambda2 = ((1/(-2*np.log10((ks/3.7) + (5.74/(Re2**0.9)))))**2)
    V1 = np.sqrt((dh*2*g*d1*d2)/((l1*lambda1*d2) + (lambda2*l2*((A1**2)/(A2**2)))))

print(f"完成{n_iterations}次迭代，最终V1: {V1:.4f}")

关键说明 #

• 无需新建变量，直接用Re1、lambda1、V1等覆盖更新即可，每次迭代自动使用最新值计算下一轮。
• 修正了原手动迭代中Re2计算的疑似笔误，改为基于新Re1计算。
• 收敛条件迭代能避免不必要的计算，同时max_iter参数可防止因逻辑错误导致死循环。

内容的提问来源于stack exchange，提问作者tom.finegan