如何获取包含另一个二维数组索引的二维数组

Question

问题

import numpy as np

我有一个数组，没有它的内容的任何先验信息。例如：

ourarray = \
np.array([[0,1],
          [2,3],
          [4,5]])

我想获得可用于索引ourarray的数字对。我想得到：

array([[0, 0, 1, 1, 2, 2],
       [0, 1, 0, 1, 0, 1]])

（0,0、0,1、1,0等，ourarray的所有可能索引都在该数组中。）

---

相似但不同的帖子

• how to find indices of a 2d numpy array occuring in another 2d array：在这里，它们在另一个数组中搜索一个数组，而不是返回整个数组的索引

• Find indices of rows of numpy 2d array in another 2D array：他们首先要处理两个数组，目标不是基于包含索引的第一个数组创建第二个数组

---

尝试1（成功但低效）

我可以通过以下方式获得此阵列：

np.array(np.where(np.ones(ourarray.shape)))

这给出了期望的结果，但它需要creting{}，这似乎不是一种有效的方法

---

尝试2（失败）

我还尝试：

np.array(np.where(ourarray))

这不起作用，因为没有为ourarray的0项返回索引

---

问题

尝试1有效，但我正在寻找一种更有效的方法。如何才能更有效地完成此任务？

Answer 1

您可以使用^{}，然后使用.T获得您想要的

试试这个：

>>> ourarray = np.array([[0,1],[2,3], [4,5]])
>>> np.argwhere(ourarray>=0).T
array([[0, 0, 1, 1, 2, 2],
       [0, 1, 0, 1, 0, 1]])

如果数组中可能存在任何值，则可以使用以下方法：

ourarray = np.array([[np.nan,1],[2,np.inf], [-4,-5]])
np.argwhere(np.ones(ourarray.shape)==1).T
# array([[0, 0, 1, 1, 2, 2],
#        [0, 1, 0, 1, 0, 1]])

Answer 2

您打算如何使用此索引

由nonzero（where）生成的元组是为方便索引而设计的：

In [54]: idx = np.nonzero(np.ones_like(ourarray))
In [55]: idx
Out[55]: (array([0, 0, 1, 1, 2, 2]), array([0, 1, 0, 1, 0, 1]))
In [56]: ourarray[idx]
Out[56]: array([0, 1, 2, 3, 4, 5])

或等效地显式使用2个数组：

In [57]: ourarray[idx[0], idx[1]]
Out[57]: array([0, 1, 2, 3, 4, 5])

您的np.array(idx)可以像[57]中那样使用，但不能像[56]中那样使用。在[56]中使用tuple是很重要的

如果我们将transpose应用于此，我们将得到一个数组

In [58]: tidx = np.transpose(idx)
In [59]: tidx
Out[59]: 
array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1],
       [2, 0],
       [2, 1]])

要将其用于索引，我们必须迭代：

In [60]: [ourarray[i,j] for i,j in tidx]
Out[60]: [0, 1, 2, 3, 4, 5]

另一个答案中提出的{}只是转置。使用outarray>=0实际上与np.ones表达式没有什么不同。两者都构成一个数组，该数组对所有元素都是True/1

In [61]: np.argwhere(np.ones_like(ourarray))
Out[61]: 
array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1],
       [2, 0],
       [2, 1]])

还有其他生成索引的方法，np.indices，np.meshgrid，np.mgrid，np.ndindex，但它们需要某种形式的重新塑造和/或转置，才能得到您想要的：

In [71]: np.indices(ourarray.shape)
Out[71]: 
array([[[0, 0],
        [1, 1],
        [2, 2]],

       [[0, 1],
        [0, 1],
        [0, 1]]])
In [72]: np.indices(ourarray.shape).reshape(2,6)
Out[72]: 
array([[0, 0, 1, 1, 2, 2],
       [0, 1, 0, 1, 0, 1]])

时间安排

如果ourarray>=0起作用，它比np.ones快：

In [79]: timeit np.ones_like(ourarray)
6.22 µs ± 11.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [80]: timeit ourarray>=0
1.43 µs ± 15 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

np.where/nonzero增加了一个不平凡的时间：

In [81]: timeit np.nonzero(ourarray>=0)
6.43 µs ± 8.15 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

还有一点时间将元组转换为数组：

In [82]: timeit np.array(np.nonzero(ourarray>=0))
10.4 µs ± 35.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

argwhere的transpose往返增加了更多的时间：

In [83]: timeit np.argwhere(ourarray>=0).T
16.9 µs ± 35.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

indices与[82]大致相同，但其规模可能不同

In [84]: timeit np.indices(ourarray.shape).reshape(2,-1)
10.9 µs ± 33.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)