标签: numpy-slicing

我一直在疯狂地想弄清楚我在这里做错了什么蠢事.

我正在使用NumPy,我有特定的行索引和特定的列索引,我想从中选择.这是我的问题的要点:

import numpy as np

a = np.arange(20).reshape((5,4))
# array([[ 0,  1,  2,  3],
#        [ 4,  5,  6,  7],
#        [ 8,  9, 10, 11],
#        [12, 13, 14, 15],
#        [16, 17, 18, 19]])

# If I select certain rows, it works
print a[[0, 1, 3], :]
# array([[ 0,  1,  2,  3],
#        [ 4,  5,  6,  7],
#        [12, 13, 14, 15]])

# If I select certain rows and a single column, it works
print …

我有一个 numpy 二维数组，我想根据列索引选择该数组的不同大小范围。这是输入数组a = np.reshape(np.array(range(15)), (5, 3))示例

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]

然后，listb = [4,3,1]确定每个列切片的不同范围大小，以便我们得到数组

[0 3 6 9]
[1 4 7]
[2]

我们可以连接和展平以获得最终所需的输出

[0 3 6 9 1 4 7 2]

目前，要执行此任务，我正在使用以下代码

slices = []
for i in range(a.shape[1]):
    slices.append(a[:b[i],i])

c = np.concatenate(slices)

并且，如果可能，我想将其转换为 pythonic 格式。

奖励：同样的问题，但现在考虑b确定行切片而不是列。

在NumPy工作,我了解如何使用本文从3D数组中切割2D数组.

根据我想切入的轴:

array = [[[0  1  2]
          [3  4  5]
          [6  7  8]]

         [[9  10 11]
          [12 13 14]
          [15 16 17]]

         [[18 19 20]
          [21 22 23]
          [24 25 26]]]

切片会给我:

i_slice = array[0]

    [[0  1  2]
     [3  4  5]
     [6  7  8]]

j_slice = array[:, 0]

    [[0  1  2]
     [9  10 11]
     [18 19 20]]

k_slice = array[:, :, 0]

    [[0  3  6]
     [9  12 15]
     [18 21 24]]

但是有可能以45度角切割？如:

j_slice_down = array[slice going down …

我有一个非常大的1d numpy数组Xold与给定的值.这些值应根据2d numpy数组Y指定的规则进行替换:例如

Xold=np.array([0,1,2,3,4])
Y=np.array([[0,0],[1,100],[3,300],[4,400],[2,200]])

每当Xold中的值与Y [:,0]中的值相同时,Xnew中的新值应该是Y [:,1]中的对应值.这是通过两个嵌套的for循环实现的:

Xnew=np.zeros(len(Xold))
for i in range(len(Xold)):
for j in range(len(Y)):
    if Xold[i]==Y[j,0]:
        Xnew[i]=Y[j,1]

通过给出的示例,这会产生Xnew=[0,100,200,300,400].但是,对于大型数据集,此过程非常缓慢.什么是更快,更优雅的方式来完成这项任务？

我想将数组拆分为带有掩码和索引的数组，
如下所示

a = array([ 0,  1,  2,  3,  4, 5]))  
b = [0,2,3]  

进入

c = array([[0, 2, 3], [1, 3, 4], [2, 4, 5]])  

我可以在没有循环的情况下执行此操作吗？

编辑：

更多例子...

说，我们有一个a形状的数组，[10, 10, 10]
其中a[x, y, :] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

现在给了面具 b = [0, 3, 7]

我希望输出是一个c具有形状的数组，[10, 10, 3, 3]
其中c[x, y, :, :] = [[0, 3, 7], [1, 4, 8], [2, 5, 9]]

我有一张图片，其中有一个缺失的部分，我知道它被涂成了绿色（第一张图片）。生成另一个“布尔值”图像的最pythonic 方法是什么，该图像显示缺失部分的白色和非缺失部分的黑色（第二张图像）？

是否可以在没有 for 循环的情况下完成它，而只是使用数组切片？

我的图像是一个形状为 numpy 的数组[height, width, 3]。我希望以下代码分配一个二维布尔数组，显示每个像素的值是否为绿色 ( [0, 255, 0])。

mask = image[:, :] == [0, 255, 0]

但是，它返回一个与图像 ( [height, width, 3])形状相同的数组，显示像素的红色、绿色或蓝色值分别是 0、255 还是 0。我可以在这里以某种方式使用any()或all()方法吗？

我在 pytorch 中有一个张量x，比如说形状 (5,3,2,6) 和另一个形状 (5,3,2,1) 的张量idx，其中包含第一个张量中每个元素的索引。我想要用第二个张量的索引对第一个张量进行切片。我尝试了 x= x[idx] 但当我真的希望它的形状为 (5,3,2) 或 (5,3,2,1) 时，我得到了一个奇怪的维度。

我会尝试举一个更简单的例子：比方说

x=torch.Tensor([[10,20,30],
                 [8,4,43]])
idx = torch.Tensor([[0],
                    [2]])

我想要类似的东西

y = x[idx]

这样 'y' 输出[[10],[43]]或类似的东西。

索引表示最后一个维度中所需元素的位置。对于上面的示例，其中 x.shape = (2,3) 最后一个维度是列，那么“idx”中的索引就是列。我想要这个，但是尺寸大于 2

我在numpy 文档中遇到了一个示例，其中有一个切片内具有复杂步长的示例（请参阅第二个示例）。

从实验中，我可以看到它在做什么；它类似于np.linspace.

In [42]: np.r_[-1:1:1j]
Out[42]: array([-1.])

In [43]: np.r_[-1:1:2j]
Out[43]: array([-1.,  1.])

In [44]: np.r_[-1:1:3j]
Out[44]: array([-1.,  0.,  1.])

In [45]: np.r_[-1:1:4j]
Out[45]: array([-1.        , -0.33333333,  0.33333333,  1.        ])

In [46]: np.r_[-1:1:5j]
Out[46]: array([-1. , -0.5,  0. ,  0.5,  1. ])

In [47]: np.r_[-1:1:6j]
Out[47]: array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ])

In [48]: np.all(np.r_[-1:1:6j] == np.linspace(-1, 1, 6))
Out[48]: True

但我不明白为什么这是预期的。如果我们从数学角度考虑，添加一个复数不应该改变数字的实部，而只会改变它的大小，而它只会随着每一步而增长！

我尝试查看索引文档：在用户指南中，以及API 文档；都没有提到切片中的复杂步长。

任何解释将不胜感激。

编辑：我没有彻底阅读文档，正如已接受的答案所指出的，行为如文档中所述。

我有一个 2D NumPy 数组V：

import numpy as np
np.random.seed(10)

V = np.random.randint(-10, 10, size=(6,8))

这给出V：

[[ -1  -6   5 -10   7   6   7  -2]
 [ -1 -10   0  -2  -6   9   6  -6]
 [  5   1   1  -9  -2  -6   4   7]
 [  9   3  -5   3   9   3   2  -9]
 [ -6   8   3   1   0  -1   5   8]
 [  6  -3   1   7   4  -3   1  -9]]

现在，我有 2 个列表r1和r2，包含列索引，如下所示： …

我们注意到，对于多维数组来说，花式索引和切片的混合使用非常令人困惑且没有记录，例如：

In [114]: x = np.arange(720).reshape((2,3,4,5,6))

In [115]: x[:,:,:,0,[0,1,2,4,5]].shape
Out[115]: (2, 3, 4, 5)

In [116]: x[:,:,0,:,[0,1,2,4,5]].shape
Out[116]: (5, 2, 3, 5)

我已经在https://numpy.org/doc/stable/user/basics.indexing.html上阅读了花哨索引的用法，我可以理解这一点x[:,0,:,[1,2]] = [x[:,0,:,1], x[:,0,:,2]]。但是我无法理解为什么上面的结果在第一个维度上Input [115]有所Input [116]不同。有人可以指出此类广播规则的记录在哪里吗？