Numpy.ma मॉड्यूल के निरंतर

MaskedArray वर्ग के अतिरिक्त, numpy.ma मॉड्यूल कई स्थिरांक को परिभाषित करता है।

numpy.ma.masked

masked स्थिरांक फ्लोट MaskedArray और एक अशक्त आकार के साथ MaskedArray का एक विशेष मामला है। इसका उपयोग यह जांचने के लिए किया जाता है कि एक नकाबपोश सरणी की एक विशिष्ट प्रविष्टि नकाबपोश है, या एक नकाबपोश सरणी की एक या कई प्रविष्टियों को मास्क करने के लिए:

>>> x = ma.array([1, 2, 3], mask=[0, 1, 0])
>>> x[1] is ma.masked
True
>>> x[-1] = ma.masked
>>> x
masked_array(data = [1 -- --],
             mask = [False  True  True],
       fill_value = 999999)

numpy.ma.nomask

मान दर्शाता है कि एक नकाबपोश सरणी में कोई अमान्य प्रविष्टि नहीं है। nomask का उपयोग आंतरिक रूप से कम्प्यूटेशन को तेज करने के लिए किया जाता है जब मास्क की आवश्यकता नहीं होती है।

numpy.ma.masked_print_options

एक नकाबपोश सरणी मुद्रित होने पर लापता डेटा के बदले में उपयोग किया जाने वाला स्ट्रिंग। डिफ़ॉल्ट रूप से, यह स्ट्रिंग '--' ।

MaskedArray वर्ग

class numpy.ma.MaskedArray [source]

लापता डेटा के साथ संख्यात्मक सरणियों में हेरफेर करने के लिए डिज़ाइन किए गए ndarray का एक उपवर्ग।

MaskedArray का एक उदाहरण कई तत्वों के संयोजन के रूप में सोचा जा सकता है:

• data , किसी भी आकार या डेटाटाइप (डेटा) के नियमित रूप से ndarray के रूप में।
• डेटा के समान आकार के साथ एक बूलियन mask , जहां एक True वैल्यू इंगित करता है कि डेटा का संबंधित तत्व अमान्य है। नामांकित फ़ील्ड के बिना nomask लिए विशेष मूल्य का nomask भी स्वीकार्य है, और यह दर्शाता है कि कोई भी डेटा अमान्य नहीं है।
• एक fill_value , एक मान जो अमान्य प्रविष्टियों को बदलने के लिए इस्तेमाल किया जा सकता है ताकि एक मानक ndarray को वापस किया जा ndarray ।

नकाबपोश सरणियों के गुण और गुण

MaskedArray.data

नकाबपोश सरणी के दृश्य के रूप में अंतर्निहित डेटा लौटाता है। यदि अंतर्निहित डेटा ndarray उपवर्ग है, तो इसे इस तरह से लौटाया जाता है।

>>> x = ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.data
matrix([[1, 2],
        [3, 4]])

baseclass विशेषता के माध्यम से डेटा के प्रकार तक पहुँचा जा सकता है।

MaskedArray.mask

डेटा के रूप में एक ही आकार और संरचना के साथ एक सरणी के रूप में अंतर्निहित मुखौटा लौटाता है, लेकिन जहां सभी क्षेत्र परमाणु रूप से बूलियन हैं। True मान अमान्य प्रविष्टि को इंगित करता है।

MaskedArray.recordmask

यदि फ़ील्ड का कोई नाम नहीं है, तो यह सरणी का मास्क लौटाता है। संरचित सरणियों के लिए, बूलियनों की एक अशांति लौटाता है जहां प्रविष्टियां True यदि सभी फ़ील्ड नकाबपोश हैं, तो False :

>>> x = ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
...         mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
...        dtype=[('a', int), ('b', int)])
>>> x.recordmask
array([False, False,  True, False, False])

MaskedArray.fill_value

एक नकाबपोश सरणी की अवैध प्रविष्टियों को भरने के लिए इस्तेमाल किया गया मान लौटाता है। मान या तो एक अदिश राशि है (यदि नकाबपोश सरणी का कोई नाम फ़ील्ड नहीं है), या 0-D dtype उसी dtype साथ है जो नकाबपोश सरणी के रूप में है यदि इसे खेतों का नाम दिया गया है।

डिफ़ॉल्ट भरने का मान सरणी के डेटाटाइप पर निर्भर करता है:

डाटा प्रकार	चूक
bool	सच
पूर्णांक	999999
नाव	1.e20
जटिल	1.e20 + 0j
वस्तु	'?'
तार	'एन / ए'

MaskedArray.baseclass

अंतर्निहित डेटा का वर्ग लौटाता है।

>>> x =  ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 0], [1, 0]])
>>> x.baseclass
<class 'numpy.matrixlib.defmatrix.matrix'>

MaskedArray.sharedmask

लौटता है कि क्या सरणी का मुखौटा कई नकाबपोश सरणियों के बीच साझा किया गया है। यदि यह मामला है, तो एक सरणी के मुखौटा में कोई भी संशोधन दूसरों को प्रचारित किया जाएगा।

MaskedArray.hardmask

लौटता है कि क्या मुखौटा कठोर है ( True ) या नरम ( False )। जब मुखौटा कठोर होता है, तो नकाबपोश प्रविष्टियां अनमास्क नहीं की जा सकती हैं।

MaskedArray का उपवर्ग है, एक नकाबपोश सरणी भी ndarray उदाहरण की सभी विशेषताओं और गुणों को प्राप्त करती है।

MaskedArray.base	बेस ऑब्जेक्ट अगर मेमोरी किसी अन्य ऑब्जेक्ट से है।
MaskedArray.ctypes	Ctypes मॉड्यूल के साथ सरणी के इंटरैक्शन को सरल बनाने के लिए एक ऑब्जेक्ट।
dtype	सरणी के तत्वों का डेटा-प्रकार।
MaskedArray.flags	सरणी के मेमोरी लेआउट के बारे में जानकारी।
MaskedArray.itemsize	बाइट्स में एक सरणी तत्व की लंबाई।
MaskedArray.nbytes	सरणी के तत्वों द्वारा खपत कुल बाइट्स।
MaskedArray.ndim	सरणी आयामों की संख्या।
MaskedArray.shape	सरणी आयामों का टपल।
MaskedArray.size	सरणी में तत्वों की संख्या।
MaskedArray.strides	किसी सरणी को ट्रेस करते समय प्रत्येक आयाम में कदम रखने के लिए बाइट्स का ट्यूपल।
MaskedArray.imag	काल्पनिक हिस्सा।
MaskedArray.real	असली हिस्सा
MaskedArray.flat	सरणी का सपाट संस्करण।
MaskedArray.__array_priority__

नकाबपोश तरीके

रूपांतरण

MaskedArray.__float__ ()	फ्लोट में बदलें।
MaskedArray.__hex__
MaskedArray.__int__ ()	इंट में बदलें।
MaskedArray.__long__ ()	लंबे समय में परिवर्तित करें।
MaskedArray.__oct__
MaskedArray.view ([dtype, type])	उसी डेटा के साथ सरणी का नया दृश्य।
MaskedArray.astype (newtype)	MaskedArray कलाकारों की एक प्रति देता है जिसे नया स्वरूप दिया जाता है।
MaskedArray.byteswap ([inplace])	सरणी तत्वों के बाइट्स स्वैप करें
MaskedArray.compressed ()	सभी गैर-नकाबपोश डेटा को 1-डी सरणी के रूप में लौटाएं।
MaskedArray.filled ([fill_value])	किसी दिए गए मूल्य से भरे हुए नकाबपोश मूल्यों के साथ स्वयं की एक प्रति लौटाएं।
MaskedArray.tofile (fid [, sep, format])	बाइनरी प्रारूप में एक फ़ाइल के लिए एक नकाबपोश सरणी सहेजें।
MaskedArray.toflex ()	एक नकाबपोश सरणी को एक लचीली-प्रकार सरणी में बदल देता है।
MaskedArray.tolist ([fill_value])	एक पदानुक्रम सूची के रूप में नकाबपोश सरणी के डेटा भाग को वापस करें।
MaskedArray.torecords ()	एक नकाबपोश सरणी को एक लचीली-प्रकार सरणी में बदल देता है।
MaskedArray.tostring ([fill_value, ऑर्डर])	यह फ़ंक्शन टोबाइट्स के लिए एक संगतता उपनाम है।
MaskedArray.tobytes ([fill_value, ऑर्डर])	सरणी डेटा को कच्चे बाइट्स वाले स्ट्रिंग के रूप में सरणी में लौटाएं।

आकार में हेरफेर

Reshape के लिए, आकार बदलें, और स्थानांतरित करें, एकल tuple तर्क को n पूर्णांकों से बदला जा सकता है जिसे n-tuple के रूप में व्याख्या किया जाएगा।

MaskedArray.flatten ([आदेश])	एक आयाम में ध्वस्त सरणी की एक प्रति लौटाएं।
MaskedArray.ravel ([आदेश])	दृश्य के रूप में स्वयं का 1D संस्करण लौटाता है।
MaskedArray.reshape (* s, ** kwargs)	अपने डेटा को बदले बिना सरणी को एक नया आकार दें।
MaskedArray.resize (न्यूज़हाप [, रीफ़ेच, ऑर्डर])
MaskedArray.squeeze ([अक्ष])	एक के आकार से एकल आयामी प्रविष्टियाँ निकालें।
MaskedArray.swapaxes (axis1, axis2)	axis1 और axis1 साथ सरणी के दृश्य को आपस में axis1 ।
MaskedArray.transpose (* कुल्हाड़ियों)	एरेस के साथ एरे का दृश्य लौटाया गया।
MaskedArray.T

आइटम चयन और हेरफेर

ऐरे कीवर्ड के लिए ऐरे तरीकों के लिए, यह None को None चूकता है। यदि अक्ष कोई नहीं है , तो सरणी को 1-डी सरणी के रूप में माना जाता है। अक्ष के लिए कोई अन्य मान उस आयाम का प्रतिनिधित्व करता है जिसके साथ ऑपरेशन को आगे बढ़ना चाहिए।

MaskedArray.argmax ([अक्ष, भरण_भुगतान, बाहर])	दिए गए अक्ष के साथ अधिकतम मूल्यों के सूचकांकों की सरणी देता है।
MaskedArray.argmin ([अक्ष, भरण_भुगतान, बाहर])	दिए गए अक्ष के साथ न्यूनतम मूल्यों पर सूचकांकों की सरणी लौटाएं।
MaskedArray.argsort ([अक्ष, प्रकार, आदेश,…])	निर्दिष्ट अक्ष के साथ सरणी को सॉर्ट करने वाले सूचकांकों की एक ndarray लौटें।
MaskedArray.choose (विकल्प [, बाहर, मोड])	विकल्पों के एक सेट से एक नई सरणी बनाने के लिए एक इंडेक्स सरणी का उपयोग करें।
MaskedArray.compress (स्थिति [, अक्ष, बाहर])	लौटें जहां a शर्त True ।
MaskedArray.diagonal ([ऑफ़सेट, एक्सिस 1, एक्सिस 2])	निर्दिष्ट विकर्ण वापस करें।
MaskedArray.fill (मान)	एक स्केलर मान के साथ सरणी भरें।
MaskedArray.item (* MaskedArray.item )	एक सरणी के एक तत्व को एक मानक पायथन स्केलर पर कॉपी करें और इसे वापस करें।
MaskedArray.nonzero ()	बिना बताए तत्वों के सूचकांकों को वापस करें जो शून्य नहीं हैं।
MaskedArray.put (सूचकांक, मूल्य [, मोड])	स्टोरेज-इंडेक्स किए गए स्थानों को संबंधित मानों पर सेट करें।
MaskedArray.repeat (दोहराता [, अक्ष])	किसी सरणी के तत्वों को दोहराएं।
MaskedArray.searchsorted (v [, पक्ष, सॉर्टर])	आदेश प्राप्त करने के लिए सूचकांकों को खोजें जहां v के तत्वों को एक में डाला जाना चाहिए।
MaskedArray.sort ([अक्ष, प्रकार, आदेश,…))	सरणी को, जगह में सॉर्ट करें
MaskedArray.take (सूचकांक [, अक्ष, बाहर, मोड])

अचार और कॉपी

MaskedArray.copy ([आदेश))	सरणी की एक प्रति लौटाएं।
MaskedArray.dump (फ़ाइल)	निर्दिष्ट फ़ाइल में सरणी का एक अचार डंप करें।
MaskedArray.dumps ()	सरणी के अचार को एक स्ट्रिंग के रूप में लौटाता है।

गणना

MaskedArray.all ([अक्ष, आउट, रखवाले])	यदि सभी तत्व True का मूल्यांकन करते हैं, तो सही लौटाता है।
MaskedArray.anom ([अक्ष, dtype])	दिए गए अक्ष के साथ विसंगतियों (अंकगणित माध्य से विचलन) की गणना करें।
MaskedArray.any ([अक्ष, आउट, रखवाले])	यदि कोई सत्य के मूल्यांकन के तत्वों में से a लौटाता है तो सही है।
MaskedArray.clip ([न्यूनतम, अधिकतम, बाहर])	एक सरणी लौटाएं, जिसके मान [min, max] तक सीमित हैं।
MaskedArray.conj ()	सभी तत्वों को जटिल-संयुग्मित करें।
MaskedArray.conjugate ()	जटिल संयुग्म, तत्व-वार लौटें।
MaskedArray.cumprod ([अक्ष, dtype, आउट])	दिए गए अक्ष पर सरणी तत्वों के संचयी उत्पाद को लौटाएं।
MaskedArray.cumsum ([अक्ष, dtype, आउट])	दिए गए अक्ष पर सरणी तत्वों के संचयी योग को लौटाएं।
MaskedArray.max ([अक्ष, आउट, भरण_…,])	किसी दिए गए अक्ष के साथ अधिकतम लौटें।
MaskedArray.mean ([धुरी, dtype, out, keepdims])	दिए गए अक्ष के साथ सरणी तत्वों का औसत लौटाता है।
MaskedArray.min ([अक्ष, आउट, भरण_…,])	किसी दिए गए अक्ष के साथ न्यूनतम लौटें।
MaskedArray.prod ([अक्ष, dtype, आउट, कीपडीम])	दिए गए अक्ष पर सरणी तत्वों के उत्पाद को लौटाएं।
MaskedArray.product ([धुरी, dtype, out, keepdims])	दिए गए अक्ष पर सरणी तत्वों के उत्पाद को लौटाएं।
MaskedArray.ptp ([अक्ष, आउट, भरण_स्थान])	दिए गए आयाम के साथ वापसी (अधिकतम - न्यूनतम) (यानी
MaskedArray.round ([दशमलव, आउट])	प्रत्येक तत्व को दशमलव की दी गई संख्या पर वापस लौटाएं।
MaskedArray.std ([धुरी, dtype, out, ddof,…])	दिए गए अक्ष के साथ सरणी तत्वों के मानक विचलन लौटाता है।
MaskedArray.sum ([धुरी, dtype, out, keepdims])	दिए गए अक्ष पर सरणी तत्वों का योग लौटाएं।
MaskedArray.trace ([ऑफ़सेट, एक्सिस 1, एक्सिस 2,…])	सरणी के विकर्णों के साथ राशि लौटाएं।
MaskedArray.var ([अक्ष, dtype, आउट, ddof,…])	निर्दिष्ट अक्ष के साथ विचरण की गणना करें।

अंकगणित और तुलनात्मक संचालन

तुलना ऑपरेटरों:

MaskedArray.__lt__ ($ स्वयं, मूल्य, /)	स्व <मान लौटाएं।
MaskedArray.__le__ ($ स्व, मूल्य, /)	स्व <= मान लौटाएं।
MaskedArray.__gt__ ($ स्वयं, मूल्य, /)	स्व> मान लौटाएं।
MaskedArray.__ge__ ($ स्वयं, मूल्य, /)	स्व लौटें = = मान।
MaskedArray.__eq__ (अन्य)	जांचें कि क्या अन्य आत्म तत्व के बराबर है।
MaskedArray.__ne__ (अन्य)	जांचें कि क्या अन्य आत्म तत्व के बराबर नहीं है।

एक सरणी का सच मूल्य ( bool ):

MaskedArray.__nonzero__

अंकगणित:

MaskedArray.__abs__ (स्व)
MaskedArray.__add__ (अन्य)	दूसरे के लिए स्वयं को जोड़ें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__radd__ (अन्य)	अन्य को स्व में जोड़ें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__sub__ (अन्य)	अन्य को स्वयं से घटाएं, और एक नया मुखौटा बनाकर लौटें।
MaskedArray.__rsub__ (अन्य)	स्वयं को दूसरे से घटाएं, और एक नया मुखौटा तैयार करें।
MaskedArray.__mul__ (अन्य)	दूसरे के द्वारा स्वयं को गुणा करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__rmul__ (अन्य)	स्वयं द्वारा अन्य को गुणा करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__div__ (अन्य)	अन्य को स्वयं में विभाजित करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__rdiv__
MaskedArray.__truediv__ (अन्य)	अन्य को स्वयं में विभाजित करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__rtruediv__ (अन्य)	स्वयं को अन्य में विभाजित करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__floordiv__ (अन्य)	अन्य को स्वयं में विभाजित करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__rfloordiv__ (अन्य)	स्वयं को अन्य में विभाजित करें, और एक नया नकाबपोश सरणी लौटाएं।
MaskedArray.__mod__ ($ स्व, मूल्य, /)	स्व% मान लौटाओ।
MaskedArray.__rmod__ ($ स्वयं, मूल्य, /)	वापसी मान% स्व।
MaskedArray.__divmod__ ($ स्व, मूल्य, /)	रिटर्न डिमॉड (स्व, मूल्य)।
MaskedArray.__rdivmod__ ($ स्वयं, मूल्य, /)	Divmod (मान, स्व) लौटाएं।
MaskedArray.__pow__ (अन्य)	क्षमता NaNs / Inf मास्किंग, अन्य शक्ति के लिए स्वयं को उठाएँ
MaskedArray.__rpow__ (अन्य)	संभावित NaN / Inf को मास्क करते हुए, पावर सेल्फ को उठाएं
MaskedArray.__lshift__ ($ स्व, मूल्य, /)	स्व वापस लौटें << मूल्य।
MaskedArray.__rlshift__ ($ स्वयं, मूल्य, /)	वापसी मान << स्व।
MaskedArray.__rshift__ ($ स्व, मूल्य, /)	स्व लौटें >> मान।
MaskedArray.__rrshift__ ($ स्व, मूल्य, /)	वापसी मूल्य >> स्व।
MaskedArray.__and__ ($ स्व, मूल्य, /)	स्व और मान लौटाएं।
MaskedArray.__rand__ ($ स्वयं, मूल्य, /)	वापसी मूल्य और स्व।
MaskedArray.__or__ ($ स्व, मूल्य, /)	स्व लौटें। मूल्य
MaskedArray.__ror__ ($ स्वयं, मूल्य, /)	वापसी मूल्य | स्व।
MaskedArray.__xor__ ($ स्व, मूल्य, /)	स्व ^ मान लौटाएं।
MaskedArray.__rxor__ ($ स्वयं, मूल्य, /)	वापसी मूल्य ^ स्व।

अंकगणित, इन-प्लेस:

MaskedArray.__iadd__ (अन्य)	अन्य को स्व-स्थान में जोड़ें।
MaskedArray.__isub__ (अन्य)	स्व-स्थान से अन्य को घटाना।
MaskedArray.__imul__ (अन्य)	जगह-जगह पर खुदकुशी करना।
MaskedArray.__idiv__ (अन्य)	स्वयं को अन्य जगह से विभाजित करें।
MaskedArray.__itruediv__ (अन्य)	सच्चा स्वयं को अन्य जगह से विभाजित करता है।
MaskedArray.__ifloordiv__ (अन्य)	फर्श को अन्य जगह से स्व विभाजित करें।
MaskedArray.__imod__ ($ स्वयं, मूल्य, /)	स्व% = मान लौटाएं।
MaskedArray.__ipow__ (अन्य)	स्वयं को अन्य शक्ति के स्थान पर उठाएं।
MaskedArray.__ilshift__ ($ स्व, मूल्य, /)	स्व वापस लौटें << = मूल्य।
MaskedArray.__irshift__ ($ स्व, मूल्य, /)	स्व लौटें >> = मान।
MaskedArray.__iand__ ($ स्व, मूल्य, /)	स्व & = मान लौटाएं।
MaskedArray.__ior__ ($ स्वयं, मूल्य, /)	स्व लौटें = मूल्य।
MaskedArray.__ixor__ ($ स्वयं, मूल्य, /)	स्व ^ वापसी = मान।

प्रतिनिधित्व

MaskedArray.__repr__ ()	शाब्दिक स्ट्रिंग प्रतिनिधित्व।
MaskedArray.__str__ ()
MaskedArray.ids ()	डेटा और मुखौटा क्षेत्रों के पते लौटाएं।
MaskedArray.iscontiguous ()	बूलियन को इंगित करें कि डेटा सन्निहित है।

विशेष विधियाँ

मानक पुस्तकालय कार्यों के लिए:

MaskedArray.__copy__ ()	उपयोग किया जाता है अगर copy.copy एक सरणी पर कहा जाता है।
MaskedArray.__deepcopy__ ([ज्ञापन])
MaskedArray.__getstate__ ()	नकाबपोश सरणी की आंतरिक स्थिति, अचार बनाने के उद्देश्य से लौटें।
MaskedArray.__reduce__ ()	MaskedArray को अचार करने के लिए एक 3-टपल लौटें।
MaskedArray.__setstate__ (राज्य)	नकाबपोश सरणी की आंतरिक स्थिति को पुनर्स्थापित करें, अचार के प्रयोजनों के लिए।

मूल अनुकूलन:

MaskedArray.__new__ ([डेटा, मास्क, dtype,…])	खरोंच से एक नया नकाबपोश सरणी बनाएँ।
MaskedArray.__array__ (…)	यदि dtype नहीं दिया गया है या dtype सरणी के वर्तमान dtype से भिन्न है, तो dtype नहीं दिया गया है या प्रदान किए गए डेटा प्रकार का एक नया सरणी, स्वयं के लिए एक नया संदर्भ देता है।
MaskedArray.__array_wrap__ (obj [, संदर्भ])	Ufuncs के लिए विशेष हुक।

कंटेनर अनुकूलन: ( Indexing देखें)

MaskedArray.__len__ ($ स्वयं, /)	वापसी लेन (स्व)।
MaskedArray.__getitem__ (indx)	x .__ getitem __ (y) <==> x [y]
MaskedArray.__setitem__ (इंडेक्स, मूल्य)	x .__ setitem __ (i, y) <==> x [i] = y
MaskedArray.__delitem__ ($ स्वयं, कुंजी, /)	स्वयं हटाएं [कुंजी]।
MaskedArray.__contains__ ($ स्वयं, कुंजी, /) शामिल हैं	स्व में वापसी कुंजी।

विशिष्ट तरीके

मुखौटा संभालना

निम्नलिखित तरीकों का उपयोग मुखौटा के बारे में जानकारी तक पहुंचने या मुखौटा में हेरफेर करने के लिए किया जा सकता है।

MaskedArray.__setmask__ (मास्क [, कॉपी])	मास्क सेट करें।
MaskedArray.harden_mask ()	मास्क को जोर से फोर्स करें।
MaskedArray.soften_mask ()	मास्क को नरम करने के लिए मजबूर करें।
MaskedArray.unshare_mask ()	मास्क को कॉपी करें और शेयर्स को फ्लैग सेट करें।
MaskedArray.shrink_mask ()	जब संभव हो तो नकाब को मुखौटा कम करें।

fill_value को fill_value

MaskedArray.get_fill_value ()	नकाबपोश सरणी के भरने के मूल्य को वापस करें।
MaskedArray.set_fill_value ([मूल्य])	नकाबपोश सरणी के भरने का मूल्य निर्धारित करें।

लापता तत्वों की गिनती

MaskedArray.count ([अक्ष, रखवाले])

दिए गए अक्ष के साथ सरणी के गैर-नकाबपोश तत्वों की गणना करें।