Python np.where（）的内部工作以及如何检查空/无

这是一个与基本面相关的问题，因此对其他人来说可能显得非常愚蠢，但这里是： 通过阅读和，我了解到

np.where（）

为

y

返回一个空数组，如果传递的参数数组是1D。但是我如何检查它是否实际上是一个空数组，而不是

None

或

NaN

我已经检查了

是否为noneess

，但是如果一开始无法访问返回值，我就很难知道该怎么做。我试图访问此值（请参见下面的代码），但得到了一个索引器

此外，我对

numpy.where（）

的内部工作原理有点困惑。从中可以看出，np.where（）返回一个ndarray，但如果我在Jupyter上运行它，它将返回一个元组

下面是我使用的代码。（numpy版本：numpy==1.15.4）

如果我遗漏了什么，请告诉我

---

提前谢谢

我认为您需要检查

结果[0]

的值

print(type(result[0]))

您的测试阵列：

In [57]: arr = np.array([4,5,6])                                                                             
In [58]: arr                                                                                                 
Out[58]: array([4, 5, 6])

该测试生成一个布尔数组：

In [59]: arr>6                                                                                               
Out[59]: array([False, False, False])

在该数组中搜索非零，

True

，没有。根据文档，结果是一个元组，每个输入维度一个数组：

In [60]: np.nonzero(arr>6)                                                                                   
Out[60]: (array([], dtype=int64),)
In [61]: _[0]                                                                                                
Out[61]: array([], dtype=int64)

Out[61]。大小为0<代码>输出[61]。形状

为

（0，）

一个更有趣的阈值：

In [62]: np.where(arr>4)                                                                                     
Out[62]: (array([1, 2]),)
In [63]: np.nonzero(arr>4)                                                                                   
Out[63]: (array([1, 2]),)

此元组可直接用于索引原始数组：

In [64]: arr[_]                                                                                              
Out[64]: array([5, 6])

Out[69]

也是一个有效的索引元组

当我们处理2或3d数组时，结果的元组性质变得更加有趣和有用

例如，二维阵列中3的倍数：

In [65]: arr = np.arange(12).reshape(3,4)                                                                    
In [66]: arr                                                                                                 
Out[66]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [67]: (arr % 3)==0                                                                                        
Out[67]: 
array([[ True, False, False,  True],
       [False, False,  True, False],
       [False,  True, False, False]])
In [68]: np.nonzero(_)                                                                                       
Out[68]: (array([0, 0, 1, 2]), array([0, 3, 2, 1]))
In [69]: arr[_]                                                                                              
Out[69]: array([0, 3, 6, 9])

---

你看到

注释了吗？您正在单输入模式下使用
where
。为此，它指的是
np.nonzero
。我和大多数SO用户都对在这种
非零
模式下使用
where
感到内疚。哦，这很有趣-我肯定掩盖了
注释
，并且肯定是在使用
np.nonzero
而没有意识到它。。。谢谢你的洞察力！我在Jupyter上试过这个，但是对于
print（type（result[0]））
它给了我一个预期的数据数组，但是对于
print（type（result[1]））
它仍然给了我索引器：元组索引超出范围
In [64]: arr[_]                                                                                              
Out[64]: array([5, 6])

In [65]: arr = np.arange(12).reshape(3,4)                                                                    
In [66]: arr                                                                                                 
Out[66]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [67]: (arr % 3)==0                                                                                        
Out[67]: 
array([[ True, False, False,  True],
       [False, False,  True, False],
       [False,  True, False, False]])
In [68]: np.nonzero(_)                                                                                       
Out[68]: (array([0, 0, 1, 2]), array([0, 3, 2, 1]))
In [69]: arr[_]                                                                                              
Out[69]: array([0, 3, 6, 9])