使用Numpy中1d数组的值从2d数组返回行和列

Question

我正在尝试使用1-dim数组的值来切片/返回Numpy中2-dim数组的行和列。 例如，假设我有以下一个暗淡数组：[1,3,5）]和以下两个暗淡数组：

array([[1, 0, 0, 0, 0, 0],
       [0, 4, 0, 0, 0, 1],
       [0, 0, 3, 0, 0, 0],
       [0, 1, 0, 7, 0, 10],
       [0, 0, 0, 0, 8, 0],
       [0, 2, 0, 0, 0, 9]])

如何返回以下内容：

array([[4, 0, 1],
       [1, 7, 10],
       [2, 0, 9]])

我还希望能够使用相同的示例制作6x6蒙版。 这样我就可以得到：

array([[True, True, True, True, True, True],
       [True, False, True, False, True, False],
       [True, True, True, True, True, True],
       [True, False, True, False, True, False],
       [True, True, True, True, True, True],
       [True, False, True, False, True, False]],)

我尝试了许多不同的方法，但似乎没有任何东西可以完全满足我的需求。 我知道我可以通过编写几个循环来做到这一点，但我认为必须有一种更简单的方法。 我也做了很多搜索，但仍然没有运气。 提前致谢！

Answer 1

这是你想要的吗？

>>> a = array([[1, 0, 0, 0, 0, 0],
...        [0, 4, 0, 0, 0, 1],
...        [0, 0, 3, 0, 0, 0],
...        [0, 1, 0, 7, 0, 10],
...        [0, 0, 0, 0, 8, 0],
...        [0, 2, 0, 0, 0, 9]])
>>> 
>>> a[1::2,1::2]
array([[ 4,  0,  1],
       [ 1,  7, 10],
       [ 2,  0,  9]])

由于跨步访问是如此常规，因此您可以使用基本切片来完成此操作。 至于面膜：

>>> a = np.ones(a.shape,dtype=bool)
>>> a[1::2,1::2] = False
>>> a
array([[ True,  True,  True,  True,  True,  True],
       [ True, False,  True, False,  True, False],
       [ True,  True,  True,  True,  True,  True],
       [ True, False,  True, False,  True, False],
       [ True,  True,  True,  True,  True,  True],
       [ True, False,  True, False,  True, False]], dtype=bool)

当然，这个答案是假设您希望沿轴的每个其他元素（从索引1开始）。 您可以修改切片以在索引为6时停止： a[1:6:2,1:6:2]或获取每个第3个元素a[1::3,1::3] ，但是如果需要随机访问数组，这会变得有点困难...

您可以执行以下操作：

>>> b = [1,3,5]
>>> a[:,b][b]
array([[ 4,  0,  1],
       [ 1,  7, 10],
       [ 2,  0,  9]])
>>> a[b][:,b]  #I think the same thing, but depending on data layout, one may be faster than the other
array([[ 4,  0,  1],
       [ 1,  7, 10],
       [ 2,  0,  9]])

但是，此时，您可能正在复制数组，而不仅仅是获取视图。 这效率较低，您将无法使用它来构造布尔型掩码，就像我们之前认为的那样。

Answer 2

例程np.meshgrid（）可能有用：

a = array([[1, 0, 0, 0, 0, 0],
   [0, 4, 0, 0, 0, 1],
   [0, 0, 3, 0, 0, 0],
   [0, 1, 0, 7, 0, 10],
   [0, 0, 0, 0, 8, 0],
   [0, 2, 0, 0, 0, 9]])

b = np.array([1, 3, 5])

B = np.meshgrid(b,b)

print a[B].T

Out: [[ 4  0  1]
      [ 1  7 10]
      [ 2  0  9]]

我认为这是理想的结果。

Answer 3

如果将大数组放在a ，将小数组放在i ，则可以使用a[i][...,i]进行切片。 也许也有一种方法可以一步完成，但是我还没有足够的numpy向导来了解它。

Answer 4

如果您知道步幅是规律的，那么mgilson的答案就是您想要的。 但是，如果a是您的数组，并且您想为某个一维数组b所有i和j获得a[i, j] ，则有一个陷阱。

In : a = array([[1, 0, 0, 0, 0, 0],
       [0, 4, 0, 0, 0, 1],
       [0, 0, 3, 0, 0, 0],
       [0, 1, 0, 7, 0, 10],
       [0, 0, 0, 0, 8, 0],
       [0, 2, 0, 0, 0, 9]])

In : b = np.array([1, 3, 5])

In : a[b, b]
Out: array([4, 7, 9])

问题在于，这只会使您获得元素（1、1），（3、3）和（5、5）。 如果您尝试在单独的步骤中进行索引编制，

In : a[b][b]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-87-c3c286c42537> in <module>()
----> 1 a[b][b]

IndexError: index 3 is out of bounds for axis 0 with size 3

出现此错误是因为我两次索引同一根轴。 这些工作之一：

In : a[b][:, b]
Out:
array([[ 4,  0,  1],
       [ 1,  7, 10],
       [ 2,  0,  9]])

In : a[:, b][b]
Out:
array([[ 4,  0,  1],
       [ 1,  7, 10],
       [ 2,  0,  9]])

[b]选择行， [:, b] :, [:, b]选择列； 这些索引操作可以互换。