Как сохранить структуру массива такой, какая она есть, в то время как логическая маска в numpy python

Question

Я уже ищу слишком много постов, касающихся булевой маскировки, но так и не нашел четкого описания. Итак, отправка новых вопросов.

Я пробовал

import numpy as np

#create numpy array
np_arr=np.array([[1,23,22],[54,28,45],[36,74,85],[25,26,98]])
print("Normal Numpy Array:\n",np_arr)

#Create boolean mask (no grator than 36)
mask=np_arr>36

#print mask value
print("\nBoolean Mask:\n",mask)

#apply mask on numpy array
apply_mask=np_arr[mask]
print("\nNumpy array  Apply Mask:\n",apply_mask)

Это дает вывод

Normal Numpy Array:
 [[ 1 23 22]
 [54 28 45]
 [36 74 85]
 [25 26 98]]
(4, 3)

Boolean Mask:
 [[False False False]
 [ True False  True]
 [False  True  True]
 [False False  True]]

Numpy array  Apply Mask:
 [54 45 74 85 98]

Но я ожидаю

Normal Numpy Array:
 [[ 1 23 22]
 [54 28 45]
 [36 74 85]
 [25 26 98]]


Boolean Mask:
 [
 [ True  True]
 [True  True]
 [True]
 ]

Numpy array  Apply Mask:
[
 [54 45]
 [74 85]
 [98]
 ]

Я хочу сохранить структуру Result таким же, как указано выше

Я пытался np.where , но мне нужно решить ееиспользование с помощью логической маски

np.where(np_arr,np_arr,0)
#This will add 0 to numpy array 

Answer 1

In [152]: arr =np.array([[1,23,22],[54,28,45],[36,74,85],[25,26,98]])           
In [153]: mask= arr>36                                                          
In [154]: arr                                                                   
Out[154]: 
array([[ 1, 23, 22],
       [54, 28, 45],
       [36, 74, 85],
       [25, 26, 98]])
In [155]: mask                                                                  
Out[155]: 
array([[False, False, False],
       [ True, False,  True],
       [False,  True,  True],
       [False, False,  True]])
In [156]: arr[mask]                                                             
Out[156]: array([54, 45, 74, 85, 98])

Похоже, что вы хотите маску строки за строкой:

In [157]: [a[m] for a,m in zip(arr,mask)]                                       
Out[157]: [array([], dtype=int64), array([54, 45]), array([74, 85]), array([98])]

Когда желаемым выводом являются массивы или списки различной длины, это хороший признак того, что требуется какая-то итерация. Операции «весь массив» возвращают массив - 1d, 2d и т. Д., А не список массивов.

Иногда удобно создать маскированный массив:

In [161]: np.ma.MaskedArray(data=arr, mask=~mask)                               
Out[161]: 
masked_array(
  data=[[--, --, --],
        [54, --, 45],
        [--, 74, 85],
        [--, --, 98]],
  mask=[[ True,  True,  True],
        [False,  True, False],
        [ True, False, False],
        [ True,  True, False]],
  fill_value=999999)

nonzero(псевдоним where) может создать индексный кортеж, который выбирает те же элементы:

In [164]: np.nonzero(mask)                                                      
Out[164]: (array([1, 1, 2, 2, 3]), array([0, 2, 1, 2, 2]))
In [165]: arr[_]                                                                
Out[165]: array([54, 45, 74, 85, 98])

, но это, очевидно, не помогает при создании списка строк. Ну, вы могли бы сделать какую-то группировку по первому индексному массиву.

Этот кортеж дает представление о том, как выполняется логическое маскирование. Он выбирает 5 элементов, определенных парами (1,0), (1,2), (2,1) и т. Д.

Вы можете использовать where или маску, чтобы установить для False значения 0. :

In [166]: np.where(mask, arr, 0)                                                
Out[166]: 
array([[ 0,  0,  0],
       [54,  0, 45],
       [ 0, 74, 85],
       [ 0,  0, 98]])
In [167]: arr*mask.astype(int)                                                  
Out[167]: 
array([[ 0,  0,  0],
       [54,  0, 45],
       [ 0, 74, 85],
       [ 0,  0, 98]])

Но это отличается от вашего списка списков.