Python：多MxN数组迭代填充缺失值的高效实现方案问询

需求说明 #

现有多个形状为MxN的NumPy数组，需用非缺失值（以-999标记缺失）填充初始全缺失数组，核心规则：每个位置保留首次出现的非缺失值，后续数组的对应值不再覆盖已填充的有效数值。

示例场景 #

• 初始数组：

initial_array = np.full((3,3),-999)
# 输出：
# array([[-999, -999, -999],
#        [-999, -999, -999],
#        [-999, -999, -999]])
final = np.full((3,3),-999)

• 待填充数组：

b = np.array([[-999, -999,    1],
              [   1, -999, -999],
              [-999, -999, -999]])

c = np.array([[-999, -999,    2],
              [   2, -999, -999],
              [   2, -999, -999]])

d = np.array([[   3, -999, -999],
              [   3, -999, -999],
              [   3, -999,    3]])

• 期望最终数组：

final = np.array([[   3, -999,    1],
                  [   1, -999, -999],
                  [   2, -999,    3]])

原实现问题 #

原嵌套逐像素循环的方式在数组规模大、数量多的时候性能极差：

for i in range(0,initial_array.shape[0]):
  for j in range(0,initial_array.shape[1]):
    if initial_array[i,j] == -999:
        if next_array[i,j] > -999:
          final_array[i,j] = next_array[i,j]

高效实现方案 #

方案1：向量化批量处理（适合数组数量较少的场景） #

利用NumPy的三维堆叠和索引操作，一次性找到所有位置的首次非缺失值：

import numpy as np

# 定义示例数组
initial = np.full((3,3), -999)
b = np.array([[-999, -999,    1],
              [   1, -999, -999],
              [-999, -999, -999]])
c = np.array([[-999, -999,    2],
              [   2, -999, -999],
              [   2, -999, -999]])
d = np.array([[   3, -999, -999],
              [   3, -999, -999],
              [   3, -999,    3]])

# 1. 将所有待填充数组堆叠为三维数组（形状：[数组数量, M, N]）
arrays_stack = np.stack([b, c, d])

# 2. 创建非缺失值掩码（True表示该位置为有效数值）
mask = arrays_stack != -999

# 3. 找到每个位置首次出现有效数值的数组索引（argmax返回第一个True的位置）
first_valid_idx = np.argmax(mask, axis=0)

# 4. 根据索引提取对应数值
# 生成行列索引用于定位
row_idx = np.arange(initial.shape[0])[:, None]
col_idx = np.arange(initial.shape[1])
final = arrays_stack[first_valid_idx, row_idx, col_idx]

# 5. 处理所有数组都缺失的位置，保留-999
final[~mask.any(axis=0)] = -999

print(final)

方案2：迭代式批量更新（适合数组数量多、内存敏感的场景） #

通过向量化掩码批量更新，避免逐像素循环，内存占用更低：

import numpy as np

# 定义示例数组
initial = np.full((3,3), -999)
b = np.array([[-999, -999,    1],
              [   1, -999, -999],
              [-999, -999, -999]])
c = np.array([[-999, -999,    2],
              [   2, -999, -999],
              [   2, -999, -999]])
d = np.array([[   3, -999, -999],
              [   3, -999, -999],
              [   3, -999,    3]])

final = initial.copy()
# 遍历所有待填充数组
for arr in [b, c, d]:
    # 生成更新掩码：final中仍为缺失值，且当前数组对应位置为有效数值
    update_mask = (final == -999) & (arr != -999)
    # 批量更新对应位置
    final[update_mask] = arr[update_mask]

print(final)

方案优势 #

两种方案均基于NumPy的向量化操作，利用底层C优化实现，比原嵌套循环快10~1000倍（取决于数组规模）：

• 方案1适合数组数量较少的场景，一次性完成所有计算
• 方案2内存占用更低，适合数组数量多、单个数组规模大的场景

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