1

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

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]],)

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

4

4 回答 4

5

这是你想要的吗？

>>> 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]])

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

于 2013-06-19T23:41:57.043 回答
1

例程 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]]

我认为这是想要的结果。

于 2013-06-20T04:21:32.260 回答
0

如果你把你的大阵列a和你的小阵列i，你可以做切片a[i][...,i]。也可能有一种方法可以一步完成，但我还不足以成为一个 numpy 向导来了解它。

于 2013-06-19T23:42:55.377 回答
0

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

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]列；这些索引操作可以互换。

于 2013-06-19T23:53:52.220 回答