NumPy 1.14 - numpy.ma.masked
Numpy.ma मॉड्यूल के निरंतर

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.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
([अक्ष, रखवाले])
|
दिए गए अक्ष के साथ सरणी के गैर-नकाबपोश तत्वों की गणना करें। |