Question

如果我有一组形状为（1000,1000）的数据，并且知道需要的值包含在索引中（25：888,11：957），该如何分离彼此有两段数据？

我无法弄清楚如何使np.delete（）喜欢特定的2D情况，并且我还需要数据的好坏部分进行分析，因此我不能只将数组范围指定为处于良好的指数范围内。

我觉得这里没有一个简单的解决方案。

Answer 1

这是您要分割数组的方式吗？

In [364]: arr = np.ones((1000,1000),int)                                        
In [365]: beta = arr[25:888, 11:957]                                            
In [366]: beta.shape                                                            
Out[366]: (863, 946)
In [367]: arr[:25,:].shape                                                      
Out[367]: (25, 1000)
In [368]: arr[888:,:].shape                                                     
Out[368]: (112, 1000)
In [369]: arr[25:888,:11].shape                                                 
Out[369]: (863, 11)
In [370]: arr[25:888,957:].shape                                                
Out[370]: (863, 43)

我正在成像一个正方形，中间切出一个矩形。指定该矩形很容易，但是必须将该框架视为4个矩形-除非通过缺少的内容的掩码对其进行描述。

检查我是否拥有所有东西：

In [376]: x = np.array([_366,_367,_368,_369,_370])                              
In [377]: np.multiply.reduce(x, axis=1).sum()                                   
Out[377]: 1000000

Answer 2

假设您的原始numpy数组为my_arr

提取“好”部分：

这很容易，因为好的部分是矩形。

good_arr = my_arr[25:888, 11:957]

提取“错误”部分：

“不良”部分的形状不是矩形。相反，它具有矩形形状，并切出了矩形孔。

因此，除非您可以浪费一些额外的空间来处理切出的部分，否则您不能真正以任何类似数组的结构单独存储“坏”部分。

“错误”部分有哪些选项？

选项1： 对提取好的部分感到满意和满意。让坏部分保留为原始my_arr的一部分。在遍历my_arr槽时，您始终可以根据索引来区分好项目和坏项目。缺点是，每当您只想处理不良品时，就必须通过嵌套的双循环来进行处理，而不是使用numpy的某些矢量化功能。

选项2： 假设我们只想对my_arr的不良项目执行某些操作，例如按行总计或按列总计，并且不希望嵌套for循环的开销。您可以创建一个称为numpy的蒙版数组。使用带掩码的数组，您可以执行大多数常规的numpy操作，并且numpy会自动从计算中排除被掩码的项目。请注意，内部会涉及一些内存浪费，仅是将项目存储为“蒙版”

以下代码说明了如何从原始数组masked_arr创建一个称为my_arr的蒙版数组：

import numpy as np

my_size = 10       # In your case, 1000
r_1, r_2 = 2, 8    # In your case, r_1 = 25, r_2 = 889 (which is 888+1)
c_1, c_2 = 3, 5    # In your case, c_1 = 11, c_2 = 958 (which is 957+1)

# Using nested list comprehension, build a boolean mask as a list of lists, of shape (my_size, my_size).
# The mask will have False everywhere, except in the sub-region [r_1:r_2, c_1:c_2], which will have True.
mask_list = [[True if ((r in range(r_1, r_2)) and (c in range(c_1, c_2))) else False 
                    for c in range(my_size)] for r in range(my_size)]

# Your original, complete 2d array. Let's just fill it with some "toy data"
my_arr = np.arange((my_size * my_size)).reshape(my_size, my_size)

print (my_arr)

masked_arr = np.ma.masked_where(mask_list, my_arr)
print ("masked_arr is:\n", masked_arr, ", and its shape is:", masked_arr.shape)

上面的输出是：

[[ 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 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]
masked_arr is:
 [[0 1 2 3 4 5 6 7 8 9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 -- -- 25 26 27 28 29]
 [30 31 32 -- -- 35 36 37 38 39]
 [40 41 42 -- -- 45 46 47 48 49]
 [50 51 52 -- -- 55 56 57 58 59]
 [60 61 62 -- -- 65 66 67 68 69]
 [70 71 72 -- -- 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]] , and its shape is: (10, 10)

现在，您有了被遮罩的数组，就可以对其执行大多数的numpy操作，并且numpy将自动排除被遮罩的项目（打印时显示为“ --”的项目）屏蔽数组）

使用蒙版数组可以执行的操作的一些示例：

# Now, you can print column-wise totals, of only the bad items.
print (masked_arr.sum(axis=0))

# Or row-wise totals, for that matter.
print (masked_arr.sum(axis=1))

上面的输出是：

[450 460 470 192 196 500 510 520 530 540]
[45 145 198 278 358 438 518 598 845 945]

从2D Numpy数组中删除特定指标

2 个答案: