Question

numpy.where()我不明白：

假设我有一个2D numpy ndarray：

import numpy as np
twodim =  np.array([[1, 2, 3, 4],  [1, 6, 7, 8], [1, 1, 1, 12],  [17, 3, 15, 16], [17, 3, 18, 18]])

现在，想要创建一个“检查”这个numpy数组的函数，以满足各种条件。

array([[ 1,  2,  3,  4],
       [ 1,  6,  7,  8],
       [ 1,  1,  1, 12],
       [17,  3, 15, 16],
       [17,  3, 18, 18]])

例如，此数组中的哪些条目具有（A）大于7（C）的偶数（B）可被3整除？

我想为此使用numpy.where()，并遍历此数组的每个条目，最后找到符合所有条件的元素（如果存在这样的条目）：

   even_entries = np.where(twodim % 2 == 0)
   greater_seven = np.where(twodim > 7 )
   divisible_three = np.where(twodim % 3 == 0)

如何做到这一点？我不知道如何遍历布尔...

我可以通过

访问矩阵（i，j）的索引

np.argwhere(even_entries)

我们可以做类似

的事情

import numpy as np
twodim =  np.array([[1, 2, 3, 4],  [1, 6, 7, 8], [1, 1, 1, 12],  [17, 3, 15, 16], [17, 3, 18, 18]])
even_entries = np.where(twodim % 2 == 0)
greater_seven = np.where(twodim > 7 )
divisible_three = np.where(twodim % 3 == 0)
for row in even_entries:
    for item in row:
        if item: #equivalent to `if item == True`
                for row in greater_seven:
                    for item in row:
                        if item: #equivalent to `if item == True`
                            for row in divisible_three:
                                for item in row:
                                    if item: #equivalent to `if item == True`
                                        # something like print(np.argwhere())

有什么建议吗？

EDIT1：下面的好主意。正如@hpaulj所提到的“你的测试会产生一个与twodim相同形状的布尔矩阵” 这是我在玩弄时遇到的一个问题 - 并非所有条件都产生与我的起始矩阵形状相同的矩阵。例如，假设我正在比较数组元素是否具有左侧或右侧（即水平）的匹配数组

twodim[:, :-1] == twodim[:, 1:]

这导致（5,3）布尔数组，而我们的原始矩阵是（5,4）数组

array([[False, False, False],
       [False, False, False],
       [ True,  True, False],
       [False, False, False],
       [False, False,  True]], dtype=bool)

如果我们垂直地做同样的事，那会产生一个（4,4）布尔数组，而原始矩阵是（5,4）

twodim[:-1] == twodim[1:]

array([[ True, False, False, False],
       [ True, False, False, False],
       [False, False, False, False],
       [ True,  True, False, False]], dtype=bool)

如果我们想知道哪些条目具有两个垂直和水平对，那么确定我们所处的维度是非常重要的。

Answer 1

您的测试会生成与twodim形状相同的布尔矩阵：

In [487]: mask3 = twodim%3==0
In [488]: mask3
Out[488]: 
array([[False, False,  True, False],
       [False,  True, False, False],
       [False, False, False,  True],
       [False,  True,  True, False],
       [False,  True,  True,  True]], dtype=bool)

正如其他答案所述，您可以逻辑地组合测试 - 和和或。

np.where与np.nonzero相同（在此用途中），只返回True值的坐标 - 作为2个数组的元组。

In [489]: np.nonzero(mask3)
Out[489]: 
(array([0, 1, 2, 3, 3, 4, 4, 4], dtype=int32),
 array([2, 1, 3, 1, 2, 1, 2, 3], dtype=int32))

argwhere返回相同的值，但是作为转置的2d数组。

In [490]: np.argwhere(mask3)
Out[490]: 
array([[0, 2],
       [1, 1],
       [2, 3],
       [3, 1],
       [3, 2],
       [4, 1],
       [4, 2],
       [4, 3]], dtype=int32)

mask和tuple都可用于直接索引数组：

In [494]: twodim[mask3]
Out[494]: array([ 3,  6, 12,  3, 15,  3, 18, 18])
In [495]: twodim[np.nonzero(mask3)]
Out[495]: array([ 3,  6, 12,  3, 15,  3, 18, 18])

argwhere不能直接用于索引，但可能更适合迭代，特别是如果你想要索引以及值：

In [496]: for i,j in np.argwhere(mask3):
   .....:     print(i,j,twodim[i,j])
   .....:     
0 2 3
1 1 6
2 3 12
3 1 3
3 2 15
4 1 3
4 2 18
4 3 18

where同样需要zip：

for i,j in zip(*np.nonzero(mask3)): print(i,j,twodim[i,j])

但总的来说，numpy我们试图避免迭代。如果您可以直接使用twodim[mask]，那么您的代码会更快。

布尔掩码的逻辑组合比where索引的组合更容易生成。要使用索引，我可能会采用set操作（并集，交叉，差异）。

对于缩小尺寸的测试，您必须决定如何映射到原始数组（以及其他测试）。 e.g。

A（5,3）掩码（列之间的差异）：

In [505]: dmask=np.diff(twodim, 1).astype(bool)
In [506]: dmask
Out[506]: 
array([[ True,  True,  True],
       [ True,  True,  True],
       [False, False,  True],
       [ True,  True,  True],
       [ True,  True, False]], dtype=bool)

它可以索引原始数组的3列

In [507]: twodim[:,:-1][dmask]
Out[507]: array([ 1,  2,  3,  1,  6,  7,  1, 17,  3, 15, 17,  3])
In [508]: twodim[:,1:][dmask]
Out[508]: array([ 2,  3,  4,  6,  7,  8, 12,  3, 15, 16,  3, 18])

它也可以与另一个面具的3列组合：

In [509]: dmask & mask3[:,:-1]
Out[509]: 
array([[False, False,  True],
       [False,  True, False],
       [False, False, False],
       [False,  True,  True],
       [False,  True, False]], dtype=bool)

在布尔数组形式中组合测试比使用where索引更容易。

Answer 2

如果您想找到满足所有三个条件的地方：

import numpy as np
twodim =  np.array([[1, 2, 3, 4],  [1, 6, 7, 8], [1, 1, 1, 12],  [17, 3, 15, 16], [17, 3, 18, 18]])

mask = (twodim % 2 == 0) & (twodim > 7) & (twodim % 3 =0)

print(twodim[mask])

[12 18 18]

最终不确定你想要的是，行中的所有元素是否必须满足条件并查找这些行或者是否需要单个元素。

Answer 3

import numpy as np
twodim =  np.array([[1, 2, 3, 4],  [1, 6, 7, 8], [1, 1, 1, 12],  [17, 3, 15, 16], [17, 3, 18, 18]])
condition = (twodim % 2. == 0.) & (twodim > 7.) & (twodim % 3. ==0.)
location = np.argwhere(condition == True) 


for i in location: 
     print i, twodim[i[0],i[1]],

>>> [2 3] 12 [4 2] 18 [4 3] 18

使用numpy.where（）迭代矩阵

3 个答案: