如何用Python实现200*200二维Numpy数组的多条件逐元素比较？

嗨，我刚好处理过类似的需求，其实用Numpy的向量化操作就能完美实现，比写嵌套循环高效多了！下面给你几种不同的实现方式，按需选择：

方法一：嵌套np.where（简洁写法） #

这种方式把所有条件整合到嵌套的np.where中，一行代码就能搞定逻辑：

import numpy as np

# 先构造示例数组（替换成你的200*200数组a和b）
a = np.array([[0, 5, 3], [2, 0, 0]])
b = np.array([[0, 0, 4], [1, 6, 0]])

# 取较小值的版本，要取较大值就把np.minimum换成np.maximum
result = np.where(
    (a == 0) & (b == 0),  # 条件1：两者都为0
    0,                     # 结果1：返回0
    np.where(
        (a == 0) | (b == 0),  # 条件2：其中一个为0
        np.where(a == 0, b, a),  # 结果2：返回非零的那个元素
        np.minimum(a, b)         # 条件3：都非零，返回较小值
    )
)

方法二：分步掩码赋值（更直观易调试） #

如果觉得嵌套np.where可读性差，可以用掩码分步处理每个条件，逻辑一目了然：

import numpy as np

a = np.array([[0, 5, 3], [2, 0, 0]])
b = np.array([[0, 0, 4], [1, 6, 0]])
result = np.empty_like(a)  # 创建和a同形状的空数组

# 情况1：两者都为0，赋值0
mask_both_zero = (a == 0) & (b == 0)
result[mask_both_zero] = 0

# 情况2：a为0，b非零，赋值b的值
mask_a_zero = (a == 0) & (b != 0)
result[mask_a_zero] = b[mask_a_zero]

# 情况3：b为0，a非零，赋值a的值
mask_b_zero = (b == 0) & (a != 0)
result[mask_b_zero] = a[mask_b_zero]

# 情况4：都非零，取较小值（换np.maximum就是较大值）
mask_both_non_zero = ~mask_both_zero & ~mask_a_zero & ~mask_b_zero
result[mask_both_non_zero] = np.minimum(a[mask_both_non_zero], b[mask_both_non_zero])

方法三：模拟C语言嵌套循环（不推荐，但满足你的需求） #

如果你确实想写类似C语言的嵌套循环逻辑，也可以实现，但注意：这种方法对于大数组效率极低，200*200的数组虽然能跑，但远不如前两种向量化方法高效：

import numpy as np

a = np.array([[0, 5, 3], [2, 0, 0]])
b = np.array([[0, 0, 4], [1, 6, 0]])
rows, cols = a.shape
result = np.zeros_like(a)

for x in range(rows):
    for y in range(cols):
        val_a = a[x][y]
        val_b = b[x][y]
        if val_a == 0 and val_b == 0:
            result[x][y] = 0
        elif val_a == 0:
            result[x][y] = val_b
        elif val_b == 0:
            result[x][y] = val_a
        else:
            result[x][y] = min(val_a, val_b)  # 换成max()就是取较大值

为什么推荐向量化方法？ #

Numpy的向量化操作是用底层C实现的，比Python层面的嵌套循环快几十甚至上百倍，尤其是当数组规模变大时，性能差异会非常明显。200*200的数组虽然小，但养成用向量化的习惯对后续处理更大的数据很有帮助。

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