如何缩短嵌套循环中公式的计算耗时？

兄弟，我看了你的代码，这计算量确实顶不住——1600×1600×130的三重循环，再套上外层几百次迭代，慢到天荒地老太正常了。不过有好几个靠谱的优化方向，能把速度提几十上百倍，咱们一步步说：

• 用NumPy向量化替代内层循环
  你代码里的核心计算array2[i,k] = sum(constant_value * array1[j,k] * function1(i-j))，本质上是一维互相关运算——对每个k，array1的第k行和function1的偏移值序列做互相关，再乘以常数。Python的for循环本身开销极大，但NumPy的底层是C实现的，能把内层循环的计算放到C层面执行，速度会快很多。

  先预计算function1所有可能的偏移值（毕竟i和j都是0~1599，偏移范围是-1599到1599），然后用np.correlate完成计算：

  import numpy as np
  
  # 预计算所有i-j对应的function1结果，避免重复调用函数
  max_offset = 1599
  f_vals = np.array([function1(d) for d in range(-max_offset, max_offset + 1)])
  
  constant_value = 你的常数值
  array1 = 你的输入数组（形状(1600, 130)）
  array2 = np.zeros_like(array1)
  
  # 对每个k维度做互相关
  for k in range(array1.shape[1]):
      # mode='same'保证输出长度和输入一致（1600），正好匹配i的范围
      array2[:, k] = constant_value * np.correlate(array1[:, k], f_vals, mode='same')
  

  这样直接把最耗时的j循环干掉，速度至少能提升一个数量级。

• 用Numba编译循环，把Python代码变成机器码
  如果不想改太多代码结构，Numba是个神器——它能把Python的循环代码即时编译成高效的机器码，性能接近纯C。你只需要给计算函数加个装饰器就行：

  from numba import jit
  
  # nopython=True让代码完全脱离Python解释器，速度最快
  @jit(nopython=True)
  def compute_array2(array1, array2, constant_value, f_vals):
      rows, cols = array1.shape
      max_offset = 1599
      for k in range(cols):
          for i in range(rows):
              total = 0.0
              for j in range(rows):
                  d = i - j
                  # 用预计算的f_vals直接取值，不用每次调用function1
                  total += array1[j, k] * f_vals[d + max_offset]
              array2[i, k] = constant_value * total
  
  # 先预计算f_vals
  max_offset = 1599
  f_vals = np.array([function1(d) for d in range(-max_offset, max_offset + 1)])
  array2 = np.zeros_like(array1)
  # 第一次调用会编译，之后就会飞快运行
  compute_array2(array1, array2, constant_value, f_vals)
  

  这个方案几乎不用改原来的循环逻辑，编译后的速度能比纯Python循环快50~100倍。

• 进阶优化：并行化k维度计算
  注意到每个k的计算是完全独立的（不同k之间没有依赖），你可以把k维度的任务拆成多个子任务，用多进程并行处理。如果你的NumPy是用MKL/OpenBLAS编译的，默认已经会用多线程处理大数组运算，也能自动利用CPU多核心。

  举个简单的多进程实现例子：

  from concurrent.futures import ProcessPoolExecutor
  
  def process_k(k):
      return constant_value * np.correlate(array1[:, k], f_vals, mode='same')
  
  # 用进程池并行处理所有k
  with ProcessPoolExecutor() as executor:
      results = list(executor.map(process_k, range(array1.shape[1])))
  # 把结果拼回array2
  array2 = np.column_stack(results)
  

  这个适合k数量较多的场景，能充分榨干CPU的多核心性能。

• 别忘预计算可复用的内容
  你原来的代码里每次循环j都要调用function1(i-j)，这也是隐形的开销。提前把所有可能的function1结果算出来存成数组，像上面例子里的f_vals，能避免大量重复的函数调用，积少成多也能省不少时间。

备注：内容来源于stack exchange，提问作者James Jacques