मैंने आकार 4 का एक वर्ग मैट्रिक्स और समान आकार का एक बूलियन मैट्रिक्स उत्पन्न किया है:

import numpy as np

A = np.random.randn(4,4)
B = np.full((4,4), True, dtype = bool)
B[[0],:] = False
B[:,[0]] = False

निम्नलिखित कोड आकार 4 के दो मैट्रिक्स लौटाता है, ए में सभी यादृच्छिक संख्याएं होती हैं, और बी में सभी बूलियन ऑपरेटर होते हैं जहां पहली पंक्ति और कॉलम गलत होता है

B = [[False, False, False, False],
     [False,  True,  True,  True],
     [False,  True,  True,  True],
     [False,  True,  True,  True]]

मैं जो चाहता हूं वह बी बूलियन मैट्रिक्स को ए पर लागू करना है, जैसे कि, मुझे ए के 3 से 3 मैट्रिक्स मिलते हैं जहां बी सत्य है (बी == सत्य में तत्व)। क्या उनका कोई लॉजिकल ऑपरेटर इस ऑपरेशन को करने के लिए सुन्न है? या क्या मुझे ए और बी के प्रत्येक तत्व के माध्यम से जाना है और उनकी तुलना करना है और फिर इसे एक नए मैट्रिक्स को असाइन करना है?

1
Pooja Parishar 24 अप्रैल 2020, 08:25

2 जवाब

In [214]: A = np.random.randn(4,4) 
     ...: B = np.full((4,4), True, dtype = bool) 
     ...: B[[0],:] = False 
     ...: B[:,[0]] = False                                                                             
In [215]: A                                                                                            
Out[215]: 
array([[-0.80676817, -0.20810386,  1.28448594, -0.52667651],
       [ 0.6292733 , -0.05575997,  0.32466482, -0.23495175],
       [-0.70896794, -1.60571282, -1.43718839, -0.42032337],
       [ 0.01541418, -2.00072652, -1.54197002,  1.2626283 ]])
In [216]: B                                                                                            
Out[216]: 
array([[False, False, False, False],
       [False,  True,  True,  True],
       [False,  True,  True,  True],
       [False,  True,  True,  True]])

बूलियन अनुक्रमण (मिलान आकार सरणी के साथ) हमेशा एक 1d सरणी उत्पन्न करता है। इस मामले में इसने A[0,:] के लिए कोई मान नहीं चुना:

In [217]: A[B]                                                                                         
Out[217]: 
array([-0.05575997,  0.32466482, -0.23495175, -1.60571282, -1.43718839,
       -0.42032337, -2.00072652, -1.54197002,  1.2626283 ])

लेकिन क्योंकि अन्य 3 पंक्तियों में सभी 3 True हैं, परिणाम को फिर से आकार देने से एक उचित परिणाम मिलता है:

In [218]: A[B].reshape(3,3)                                                                            
Out[218]: 
array([[-0.05575997,  0.32466482, -0.23495175],
       [-1.60571282, -1.43718839, -0.42032337],
       [-2.00072652, -1.54197002,  1.2626283 ]])

फिर से आकार देना समझ में आता है या नहीं, यह तत्वों की कुल संख्या और डेटा की आपकी अपनी व्याख्या पर निर्भर करता है।

0
hpaulj 24 अप्रैल 2020, 08:45

यदि आप कम से कम False तत्व वाली किसी भी पंक्ति/कॉल्स को हटाना चाहते हैं, तो आप ऐसी पंक्तियों और स्तंभों को खोजने के लिए np.any का उपयोग कर सकते हैं और फिर 2D सरणी बनाने के लिए np.ix_ का उपयोग कर सकते हैं। पंक्ति/कॉल इंडेक्स से:

A=A[np.ix_(*np.where(np.any(B, axis=0)), *np.where(np.any(B, axis=1)))]

यह आपको किसी भी 2D numpy array और समान आकार के बूलियन मास्क/हालत के लिए आउटपुट देगा। आप कोष्ठक में आयाम जोड़कर इसे किसी भी आयाम numpy array में विस्तारित कर सकते हैं।

नमूना ए:

[[-0.36027839 -1.54588632  0.1607951   1.68865218]
 [ 0.20959185  0.13962857  1.97189081 -0.7686762 ]
 [ 0.03868048 -0.36612182  0.77802273  0.23195807]
 [-1.26148984  0.44672696  0.45970364 -1.58457129]]

बी के साथ नकाबपोश ए:

[[ 0.13962857  1.97189081 -0.7686762 ]
 [-0.36612182  0.77802273  0.23195807]
 [ 0.44672696  0.45970364 -1.58457129]]
0
Ehsan 24 अप्रैल 2020, 09:12