使用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]選擇列； 這些索引操作可以互換。