Python 优化迭代循环

我正逐渐从Matlab转向Python，并希望获得一些关于优化迭代循环的建议。 这就是我当前运行循环的方式，我已经包含了定义变量的代码

nh = 2000 
h = np.array(range(nh))
nt = 10000 
wmin = 1 
wmax = 10
hw = np.array(wmin + (wmax-wmin)*invlogit(randn(1,nh))); 
sl = np.array(zeros((nh,1))+radians(40))
fa = np.array(zeros((nh,1))+radians(35))
c = np.array(zeros((nh,1))+4.4)
y = np.array(zeros((nh,1))+17.6)
yw = np.array(zeros((nh,1))+9.81)
ir = 0.028
m = np.array(zeros((nh,nt)));
m[:,49] = 0.1
z = np.array(zeros((nh,nt)))
z[:,0] = 0+(3.0773-0)*rand(nh,1).T
reset = np.array(zeros((nh,nt)))
fs = np.array(zeros((nh,nt)))

for t in xrange(0, nt-1):
    fs[:,t] = (c.T+(y.T-m[:,t]*yw.T)*z[:,t]*(np.cos(sl.T)**2)*np.tan(fa.T))/(y.T*z[:,t]*np.sin(sl.T)*np.cos(sl.T))
    reset[fs[:,t]<=1,t+1] = 1;
    z[fs[:,t]<=1,t+1] = 0;
    z[fs[:,t]>1,t+1] = z[fs[:,t]>1,t]+(ir/hw[0,fs[:,t]>1]).T

nh=2000
h=np.阵列（范围（nh））
新台币=10000元
wmin=1
wmax=10
hw=np.数组（wmin+（wmax wmin）*invlogit（randn（1，nh））；
sl=np.阵列（零（（nh，1））+弧度（40））
fa=np.数组（零（（nh，1））+弧度（35））
c=np.数组（零（（nh，1））+4.4）
y=np.数组（零（（nh，1））+17.6）
yw=np.数组（零（（nh，1））+9.81）
ir=0.028
m=np.数组（零（（nh，nt））；
m[：，49]=0.1
z=np.数组（零（（nh，nt）））
z[：，0]=0+（3.0773-0）*兰特（nh，1）.T
重置=np.数组（零（（nh，nt）））
fs=np.数组（零（（nh，nt）））
对于X范围内的t（0，nt-1）：
fs[：，t]=（c.t+（y.t-m[：，t]*y.t）*z[：，t]*（np.cos（sl.t）**2）*np.tan（fa.t））/（y.t*z[：，t]*np.sin（sl.t）*np cos（sl.t））
重置[fs[：，t]1，t]+（ir/hw[0，fs[：，t]>1]）.t

这就是我在Matlab中优化代码的方法，但是在python中它运行得相当慢。我怀疑有一种更像蟒蛇的方法可以做到这一点，我真的希望能朝着正确的方向推动一下。

---

非常感谢

不是专门针对循环，您在调用中做了大量额外的工作，这些调用看起来像：

np.array(zeros((nh,nt)))

只需使用：

np.zeros((nh,nt))

取而代之的是。此外，您还可以替换：

h = np.array(range(nh))

与：

其他意见：

• 您在每个循环中调用

  np.sin（sl.T）*np.cos（sl.T）

  ，尽管，

  sl

  似乎根本没有变化。只需计算一次，并将其分配给循环中使用的变量。你在一堆三角呼叫中这样做
表达式

(c.T+(y.T-m[:,t]*yw.T)*z[:,t]*(np.cos(sl.T)**2)*np.tan(fa.T))/(y.T*z[:,t]*np.sin(sl.T)*np.cos(sl.T))

使用循环内不会更改的

c、y、m、yw、sl、fa

。可以在循环之前计算几个子表达式
而且，大多数数组都包含一个重复值。您可以使用标量进行计算：

sl = radians(40)
fa = radians(35)
c = 4.4
y = 17.6
yw = 9.81

然后，使用预计算的子表达式：

A = cos(sl)**2 * tan(fa) * (y - m*yw)
B = y*sin(sl)*cos(sl)

for t in xrange(0, nt-1):
    fs[:,t] = (c + A[:,t]*z[:,t]) / (B*z[:,t])
    less = fs[:,t]<=1
    more = np.logical_not(less)
    reset[less,t+1] = 1
    z[less,t+1] = 0
    z[more,t+1] = z[more,t]+(ir/hw[0,more]).T

A=cos（sl）**2*tan（fa）*（y-m*yw）
B=y*sin（sl）*cos（sl）
对于X范围内的t（0，nt-1）：
fs[：，t]=（c+A[：，t]*z[：，t]）/（B*z[：，t]）
less=fs[：，t]有没有办法确定循环中4个操作中哪一个占用的时间最多？这可能会帮助我们确定最需要帮助的地方（我可能猜这是第一个…trig函数非常慢）。我还注意到，您正在以一种比C存储更适合Fortran存储的方式对数组进行索引。您可能会考虑在Fortran Orthon中存储NoMy数组。谢谢塞思，FORTRAN命令加快了进度。对于信息/示例，这可以使用z=np来完成。零（（nh，nt），order='F'）谢谢Josh，我现在已经在循环之前分配了trig，并整理了数组定义。速度略有提高，看起来整洁多了。CheersIt也值得你去看看numpy的广播规则文档。
A = cos(sl)**2 * tan(fa) * (y - m*yw)
B = y*sin(sl)*cos(sl)

for t in xrange(0, nt-1):
    fs[:,t] = (c + A[:,t]*z[:,t]) / (B*z[:,t])
    less = fs[:,t]<=1
    more = np.logical_not(less)
    reset[less,t+1] = 1
    z[less,t+1] = 0
    z[more,t+1] = z[more,t]+(ir/hw[0,more]).T