NumPy 1.14 - class.__array_ufunc__()
मानक सरणी उपवर्ग

मानक सरणी उपवर्ग
NumPy में ndarray एक "नई शैली" पायथन में निर्मित प्रकार है। इसलिए, यह वांछित होने पर (पायथन या सी में) से विरासत में प्राप्त किया जा सकता है। इसलिए, यह कई उपयोगी वर्गों के लिए एक आधार बना सकता है। अक्सर एरे ऑब्जेक्ट को सब-क्लास करना या कोर ऐरे कंपोनेंट का उपयोग करना चाहे तो एक नए क्लास का आंतरिक हिस्सा एक कठिन निर्णय है, और यह केवल पसंद का मामला हो सकता है। NumPy में सरलीकृत करने के लिए कई उपकरण हैं कि आपकी नई वस्तु अन्य सरणी ऑब्जेक्ट के साथ कैसे इंटरैक्ट करती है, और इसलिए चुनाव अंत में महत्वपूर्ण नहीं हो सकता है। प्रश्न को सरल बनाने का एक तरीका यह है कि आप अपने आप से पूछें कि जिस वस्तु में आप रुचि रखते हैं उसे एकल सरणी के रूप में प्रतिस्थापित किया जा सकता है या क्या वास्तव में इसके मूल में दो या अधिक सरणियों की आवश्यकता है।
ध्यान दें कि
asarray
हमेशा बेस-क्लास
asarray
देता है।
यदि आप आश्वस्त हैं कि एरे ऑब्जेक्ट का आपका उपयोग किसी
asanyarray
किसी उपवर्ग को संभाल सकता है, तो
asanyarray
का उपयोग उप-वर्ग को आपके सबरूटीन के माध्यम से अधिक सफाई से प्रचार करने की अनुमति देने के लिए किया जा सकता है।
प्रधान में एक उपवर्ग सरणी के किसी भी पहलू को फिर से परिभाषित कर सकता है और इसलिए, सख्त दिशानिर्देशों के तहत,
asanyarray
शायद ही उपयोगी होगा।
हालाँकि, सरणी ऑब्जेक्ट के अधिकांश उपवर्ग बफर ऑब्जेक्ट, या सरणी के गुण जैसे सरणी ऑब्जेक्ट के कुछ पहलुओं को फिर से परिभाषित नहीं करेंगे।
एक महत्वपूर्ण उदाहरण, हालांकि, आपकी सबरूटीन एक सरणी के एक मनमाने ढंग से उपवर्ग को संभालने में सक्षम नहीं हो सकती है, क्योंकि मैट्रीस तत्व-दर-तत्व गुणन के बजाय मैट्रिक्स * को गुणा करने के लिए "*" ऑपरेटर को फिर से परिभाषित करता है।
विशेष गुण और विधियाँ
यह भी देखें
NumPy कई हुक प्रदान करता है जिन्हें कक्षाएं अनुकूलित कर सकती हैं:
-
class.__array_ufunc__(ufunc, method, *inputs, **kwargs)
-
संस्करण 1.13 में नया।
ध्यान दें
एपीआई provisional , यानी, हम अभी तक पिछड़े संगतता की गारंटी नहीं देते हैं।
कोई भी वर्ग, ndarray उपवर्ग या नहीं, इस पद्धति को परिभाषित कर सकता है या NumPy के ufuncs के व्यवहार को ओवरराइड करने के लिए इसे किसी को
None
सेटNone
कर सकता है। यह पायथन के__mul__
और अन्य बाइनरी ऑपरेशन__mul__
समान ही काम करता है।- ufunc ufunc ऑब्जेक्ट है जिसे कहा जाता था।
-
मेथड
एक स्ट्रिंग है जो यह दर्शाता है कि उफंक विधि को (
"__call__"
,"reduce"
,"reduceat"
,"accumulate"
,"outer"
,"inner"
) में से एक कहा गया था। -
निविष्टियाँ
ufunc
के लिए इनपुट तर्कों का एकufunc
। -
kwargs
एक शब्दकोश है जिसमें ufunc के वैकल्पिक इनपुट तर्क होते हैं।
यदि दिया गया है, तो कोई भी तर्क, स्थिति और कीवर्ड दोनों को,
kwargs
में एक
tuple
रूप में पारित किया जाता है। विवरण के लिए यूनिवर्सल फ़ंक्शंस (ufunc) में चर्चा देखें।
विधि या तो ऑपरेशन के परिणाम पर वापस लौटना चाहिए, या
NotImplemented
यदि अनुरोध किए गए ऑपरेशन को लागू नहीं किया गया है।यदि किसी इनपुट या आउटपुट तर्क में
__array_ufunc__
विधि है, तो इसे ufarc के बजाय निष्पादित किया जाता है। यदि एक से अधिक तर्क__array_ufunc__
लागू करते हैं, तो उन्हें क्रम में आज़माया जाता है:__array_ufunc__
से पहले उपवर्ग, आउटपुट से पहले इनपुट, अन्यथा दाएं से बाएं।NotImplemented
अलावा कुछ और लौटाने वाली पहली दिनचर्या परिणाम निर्धारित करती है। यदि सभी__array_ufunc__
ऑपरेशनNotImplemented
वापसNotImplemented
, तो एकTypeError
उठाया जाता है।ध्यान दें
हम (सामान्यीकृत) Ufunc के रूप में संख्यात्मक कार्यों को फिर से लागू करने का इरादा रखते हैं, जिस स्थिति में उनके लिए
__array_ufunc__
विधि द्वारा ओवरराइड किया जाना संभव हो जाएगा। एक प्रमुख उम्मीदवारmatmul
, जो वर्तमान में एक यूफंक नहीं है, लेकिन सामान्य रूप से सामान्यीकृत यूफंक्स के रूप में अपेक्षाकृत आसानी से फिर से लिखा जा सकता है। ऐसा हीargsort
,min
औरargsort
जैसे कार्यों के साथ हो सकता है।अजगर में कुछ अन्य विशेष तरीकों के साथ, जैसे
__hash__
और__iter__
, यह इंगित करना संभव है कि आपकी कक्षा__array_ufunc__ = None
सेट करके ufuncs का समर्थन__array_ufunc__ = None
। Ufuncs हमेशाTypeError
बढ़ाते हैं जब एक ऑब्जेक्ट पर कॉल किया जाता है जो__array_ufunc__ = None
सेट करता है।__array_ufunc__
की उपस्थिति यह भी प्रभावित करती है कि__array_ufunc__
बाइनरी ऑपरेशंस को हैंडलarr + obj
औरarr < obj
जैसे कैसे हैंडल करता है जबarr
एकndarray
औरobj
एक कस्टम क्लास का एक उदाहरण है। दो संभावनाएँ हैं। अगरobj.__array_ufunc__
मौजूद है और कोईNone
, तोndarray.__add__
और दोस्तों को ufunc मशीनरी को सौंप देगा, जिसका अर्थ है किarr + obj
np.add(arr, obj)
बन जाता है, और फिर invokesobj.__array_ufunc__
add
। यह उपयोगी है यदि आप एक ऑब्जेक्ट को परिभाषित करना चाहते हैं जो एक सरणी की तरह कार्य करता है।वैकल्पिक रूप से, अगर
obj.__array_ufunc__
किसी के लिएNone
सेटNone
, तो एक विशेष मामले के रूप में,ndarray.__add__
जैसी विशेष विधियां इस पर ध्यानndarray.__add__
और बिना किसी प्रकार केndarray.__add__
को बढ़ाएगी। यदि आप बाइनरी संचालन के माध्यम से सरणियों के साथ बातचीत करने वाली वस्तुओं को बनाना चाहते हैं, तो यह उपयोगी है, लेकिन स्वयं सरणियाँ नहीं हैं। उदाहरण के लिए, सिस्टम को संभालने वाली इकाइयों में "मीटर" इकाई का प्रतिनिधित्व करने वाला एक ऑब्जेक्टm
हो सकता है, और यहarr * m
करने के लिए सिंटैक्सarr * m
का समर्थन करना चाहता है कि सरणी में "मीटर" की इकाइयाँ हैं, लेकिन अन्यथा ufuncs के माध्यम से सरणियों के साथ बातचीत नहीं करना चाहते हैं। या अन्यथा। यह__array_ufunc__ = None
और__mul__
और__rmul__
तरीकों को परिभाषित करके किया जा सकता है। (ध्यान दें कि इसका मतलब है कि__array_ufunc__
जो हमेशाNotImplemented
लौटाता है,__array_ufunc__ = None
सेटिंग को सेट करने के समान__array_ufunc__ = None
: पूर्व मामले में,__array_ufunc__ = None
arr + obj
__array_ufunc__ = None
को बढ़ाएगा, जबकि बाद वाले मामले में यह एक__radd__
विधि को परिभाषित करना संभव है। इसे रोकें।)उपरोक्त इन-प्लेस ऑपरेटरों के लिए नहीं है, जिसके लिए
NotImplemented
कभी नहीं लौटायाNotImplemented
। इसलिए,arr += obj
हमेशा एकTypeError
ओर ले जाएगा। इसका कारण यह है कि सरणियों के लिए इन-प्लेस ऑपरेशन को सामान्य रूप से एक साधारण रिवर्स ऑपरेशन द्वारा प्रतिस्थापित नहीं किया जा सकता है। (उदाहरण के लिए, डिफ़ॉल्ट रूप से,arr += obj
कोarr = arr + obj
करने के लिए अनुवादित किया जाएगाarr = arr + obj
, अर्थात,arr
को प्रतिस्थापित किया जाएगा, इसके स्थान पर सरणी के संचालन के लिए अपेक्षित है।ध्यान दें
यदि आप
__array_ufunc__
को परिभाषित__array_ufunc__
:-
यदि आप
__add__
उपवर्ग नहीं हैं, तो हम आपकी कक्षा को__add__
और__lt__
जैसे विशेष तरीकों को परिभाषित करने की सलाह देते हैं, जो__add__
तरह__add__
को सौंपते हैं। ऐसा करने का एक आसान तरीकाNDArrayOperatorsMixin
से उप-वर्गNDArrayOperatorsMixin
। -
यदि आप
ndarray
उप-वर्ग करते हैं, तो हम अनुशंसा करते हैं कि आप अपने सभी ओवरराइड लॉजिक को__array_ufunc__
में__array_ufunc__
और विशेष विधियों को ओवरराइड न करें। यह सुनिश्चित करता है कि वर्ग पदानुक्रम ufunc मशीनरी द्वारा अलग-अलग के बजाय केवल एक ही स्थान पर निर्धारित किया जाता है और बाइनरी ऑपरेशन नियमों (जो उपवर्गों के विशेष तरीकों को वरीयता देता है;__array_ufunc__
की स्थापना के लिए एक स्थान के केवल पदानुक्रम को लागू करने का वैकल्पिक तरीका;None
, बहुत अप्रत्याशित प्रतीत होता है और इस प्रकार भ्रमित होता है, क्योंकि तब उपवर्ग ufuncs के साथ बिल्कुल भी काम नहीं करेगा)। -
__array_ufunc__
अपने स्वयं के__array_ufunc__
को परिभाषित करता है, जो कि ufunc का मूल्यांकन करता है यदि कोई तर्क ओवरराइड नहीं होता है, और अन्यथाNotImplemented
रिटर्न देता है। यह उपवर्गों के लिए उपयोगी हो सकता है, जिसके लिए__array_ufunc__
अपनी स्वयं की कक्षा के किसी भी उदाहरण को__array_ufunc__
परिवर्तित करता है: फिर इसेsuper().__array_ufunc__(*inputs, **kwargs)
का उपयोग करके अपनेsuper().__array_ufunc__(*inputs, **kwargs)
पर पारित कर सकता है, और अंत में संभव होने के बाद परिणाम वापस कर सकता है। बैक-रूपांतरण। इस अभ्यास का लाभ यह है कि यह सुनिश्चित करता है कि व्यवहार का विस्तार करने वाले उपवर्गों का पदानुक्रम होना संभव है। विवरण के लिए उपवर्ग ndarray देखें।
ध्यान दें
यदि कोई वर्ग
__array_ufunc__
पद्धति को परिभाषित करता है, तो यह__array_wrap__
,__array_prepare__
,__array_priority__
तंत्र को ufuncs के लिए नीचे वर्णित करता है (जो अंततः पदावनत हो सकता है) को निष्क्रिय करता है।
-
class.__array_finalize__(obj)
-
इस पद्धति को तब कहा जाता है जब सिस्टम आंतरिक रूप से obj से एक नया सरणी आवंटित करता है, जहां obd ndarray का उपवर्ग (उपप्रकार) है। इसका उपयोग निर्माण के बाद स्वयं की विशेषताओं को बदलने के लिए किया जा सकता है (उदाहरण के लिए 2-डी मैट्रिक्स सुनिश्चित करने के लिए), या "जनक" से मेटा-जानकारी को अपडेट करने के लिए। उपवर्ग इस पद्धति के डिफ़ॉल्ट कार्यान्वयन को विरासत में मिला है जो कुछ भी नहीं करता है।
-
class.__array_prepare__(array, context=None)
-
प्रत्येक ufunc की शुरुआत में, इस विधि को उच्चतम सरणी प्राथमिकता, या आउटपुट ऑब्जेक्ट के साथ इनपुट ऑब्जेक्ट पर कहा जाता है यदि कोई निर्दिष्ट किया गया था। आउटपुट ऐरे में पास किया जाता है और जो कुछ भी लौटाया जाता है उसे ufunc में पास कर दिया जाता है। उपवर्ग इस पद्धति के एक डिफ़ॉल्ट कार्यान्वयन को विरासत में देते हैं जो केवल उत्पादन सरणी को बिना शर्त लौटाता है। उपक्लास इस विधि का उपयोग करने के लिए उप-वर्ग की आवृत्ति में आउटपुट सरणी को बदलने और मेटाडेटा को अपडेट करने से पहले गणना के लिए ufunc में सरणी को लौटाने का विकल्प चुन सकते हैं।
ध्यान दें
Ufuncs के लिए, यह अंततः
__array_ufunc__
पक्ष में इस पद्धति को__array_ufunc__
की__array_ufunc__
।
-
class.__array_wrap__(array, context=None)
-
प्रत्येक ufunc के अंत में, इस विधि को इनपुट ऑब्जेक्ट पर उच्चतम सरणी प्राथमिकता या आउटपुट ऑब्जेक्ट के साथ कहा जाता है यदि कोई निर्दिष्ट किया गया था। Ufunc-कंप्यूटेड ऐरे में पास किया जाता है और जो भी लौटाया जाता है वह यूजर को दिया जाता है। उप-वर्ग इस विधि के एक डिफ़ॉल्ट कार्यान्वयन को विरासत में लेते हैं, जो सरणी को ऑब्जेक्ट की कक्षा के एक नए उदाहरण में बदल देता है। उप-वर्ग उपयोक्ता के आउटपुट सरणी को बदलने के लिए इस विधि का उपयोग करने का विकल्प चुन सकते हैं और उपयोक्ता को उपयोगकर्ता को लौटाने से पहले मेटाडेटा अद्यतन कर सकते हैं।
ध्यान दें
Ufuncs के लिए, यह अंततः
__array_ufunc__
पक्ष में इस पद्धति को__array_ufunc__
की__array_ufunc__
।
-
class.__array_priority__
-
इस विशेषता के मूल्य का उपयोग यह निर्धारित करने के लिए किया जाता है कि उन स्थितियों में किस प्रकार का ऑब्जेक्ट लौटाया जाए जहां लौटे हुए ऑब्जेक्ट के पायथन प्रकार के लिए एक से अधिक संभावना हो। उपवर्ग इस विशेषता के लिए 0.0 का डिफ़ॉल्ट मान प्राप्त करते हैं।
ध्यान दें
Ufuncs के लिए, यह अंततः
__array_ufunc__
पक्ष में इस पद्धति को__array_ufunc__
की__array_ufunc__
।
-
class.__array__([dtype])
-
यदि एक वर्ग (ndarray उपवर्ग या नहीं) के पास
__array__
विधि का उपयोग__array__
के आउटपुट ऑब्जेक्ट के रूप में किया जाता है, तो परिणाम__array__
द्वारा लौटाए गए ऑब्जेक्ट को लिखा जाएगा। इसी तरह का रूपांतरण इनपुट सरणियों पर किया जाता है।
मैट्रिक्स ऑब्जेक्ट्स
matrix
ऑब्जेक्ट्स को ndarray से विरासत में मिला है और इसलिए, उनके पास ndarrays की समान विशेषताएँ और विधियाँ हैं।
मैट्रिक्स ऑब्जेक्ट्स के छह महत्वपूर्ण अंतर हैं, हालांकि, जब आप मैट्रिसेस का उपयोग करते हैं तो अप्रत्याशित परिणाम हो सकते हैं, लेकिन उनसे एरियर्स की तरह कार्य करने की अपेक्षा करें:
- मैट्रिक्स ऑब्जेक्ट्स को एक स्ट्रिंग संकेतन का उपयोग करके बनाया जा सकता है, जिसमें मैटलैब-शैली के सिंटैक्स की अनुमति होती है जहां रिक्त स्थान अलग-अलग कॉलम और अर्धविराम (';') अलग-अलग पंक्तियों में होते हैं।
- मैट्रिक्स ऑब्जेक्ट हमेशा दो-आयामी होते हैं। इसके दूरगामी निहितार्थ हैं, उस m.ravel () में अभी भी दो आयामी (पहले आयाम में 1 के साथ) और आइटम का चयन दो-आयामी ऑब्जेक्ट देता है ताकि अनुक्रम व्यवहार सरणियों की तुलना में मौलिक रूप से भिन्न हो।
- मैट्रिक्स ऑब्जेक्ट मैट्रिक्स-गुणन होने के लिए कई गुना अधिक सवारी करते हैं। सुनिश्चित करें कि आप इसे उन कार्यों के लिए समझते हैं जिन्हें आप मैट्रिस प्राप्त करना चाहते हैं। विशेष रूप से इस तथ्य के प्रकाश में कि asanyarray (m) एक मैट्रिक्स है जब m एक मैट्रिक्स है।
- मैट्रिक्स की वस्तुएं एक शक्ति को बढ़ाने के लिए मैट्रिक्स पर वस्तुओं की सवारी करती हैं। एक फ़ंक्शन के अंदर शक्ति का उपयोग करने के बारे में एक ही चेतावनी जो इस तथ्य के लिए एक सरणी ऑब्जेक्ट प्राप्त करने के लिए asanyarray (…) का उपयोग करता है।
- मैट्रिक्स ऑब्जेक्ट्स का डिफ़ॉल्ट __array_priority__ 10.0 है, और इसलिए ndarrays के साथ मिश्रित ऑपरेशन हमेशा मैट्रिस का उत्पादन करते हैं।
-
मैट्रिसेस में विशेष गुण होते हैं जो गणना को आसान बनाते हैं। य़े हैं
matrix.T
मैट्रिक्स का संक्रमण लौटाता है। matrix.H
रिटर्न (जटिल) संयुग्म self
संक्रमण।matrix.I
(गुणा) उलटे self
का प्रतिलोम देता है।matrix.A
self
को एकndarray
वस्तु के रूप में लौटाएं।
चेतावनी
मैट्रिक्स ऑब्जेक्ट्स क्रमशः, गुणा-गुणा और मैट्रिक्स पावर होने के लिए, '*' और पावर, '**' से अधिक की सवारी करते हैं। यदि आपका उप-वर्ग उप-वर्गों को स्वीकार कर सकता है और आप आधार-वर्ग सरणियों में परिवर्तित नहीं होते हैं, तो आपको यह सुनिश्चित करने के लिए कि आप सभी इनपुट के लिए सही संचालन कर रहे हैं, ufuncs का गुणा और शक्ति का उपयोग करना चाहिए।
मैट्रिक्स क्लास, ndarray का पायथन उपवर्ग है और इसे ndarray के अपने उपवर्ग का निर्माण करने के लिए एक संदर्भ के रूप में उपयोग किया जा सकता है।
मैट्रिसेस को अन्य मैट्रिसेस, स्ट्रिंग्स और कुछ और से बनाया जा सकता है, जिसे
ndarray
बदला जा सकता है।
"मैट" नाम न्यूपी में "मैट्रिक्स" के लिए एक उपनाम है।
matrix
(डेटा [, dtype, copy])
|
किसी सरणी-जैसी ऑब्जेक्ट से या डेटा की स्ट्रिंग से मैट्रिक्स लौटाता है। |
asmatrix
(डेटा [, dtype])
|
मैट्रिक्स के रूप में इनपुट की व्याख्या करें। |
bmat
(obj [, ldict, gdict])
|
एक स्ट्रिंग, नेस्टेड अनुक्रम, या सरणी से एक मैट्रिक्स ऑब्जेक्ट बनाएँ। |
उदाहरण 1: एक स्ट्रिंग से मैट्रिक्स निर्माण
>>> a=mat('1 2 3; 4 5 3') >>> print (a*a.T).I [[ 0.2924 -0.1345] [-0.1345 0.0819]]
उदाहरण 2: नेस्टेड अनुक्रम से मैट्रिक्स निर्माण
>>> mat([[1,5,10],[1.0,3,4j]]) matrix([[ 1.+0.j, 5.+0.j, 10.+0.j], [ 1.+0.j, 3.+0.j, 0.+4.j]])
उदाहरण 3: एक सरणी से मैट्रिक्स निर्माण
>>> mat(random.rand(3,3)).T matrix([[ 0.7699, 0.7922, 0.3294], [ 0.2792, 0.0101, 0.9219], [ 0.3398, 0.7571, 0.8197]])
मेमोरी-मैप की गई फ़ाइल सरणियाँ
मेमोरी-मैप की गई फाइलें, पूरी फाइल को मेमोरी में पढ़े बिना, नियमित लेआउट के साथ एक बड़ी फाइल के छोटे सेगमेंट को पढ़ने और / या संशोधित करने के लिए उपयोगी होती हैं। Ndarray का एक सरल उपवर्ग सरणी के डेटा बफर के लिए एक मेमोरी-मैप्ड फ़ाइल का उपयोग करता है। छोटी फ़ाइलों के लिए, संपूर्ण फ़ाइल को मेमोरी में पढ़ने का ओवर-हेड आमतौर पर महत्वपूर्ण नहीं होता है, हालांकि मेमोरी मैपिंग का उपयोग करने वाली बड़ी फ़ाइलों के लिए काफी संसाधनों को बचाया जा सकता है।
मेमोरी-मैप्ड-फ़ाइल सरणियों में एक अतिरिक्त विधि होती है (इसके अलावा जो वे
.flush()
से विरासत में मिली हैं):
.flush()
जिसे उपयोगकर्ता द्वारा मैन्युअल रूप से कॉल किया जाना चाहिए ताकि यह सुनिश्चित हो सके कि सरणी में कोई भी परिवर्तन वास्तव में डिस्क पर लिखा हो।
memmap
|
डिस्क पर बाइनरी फ़ाइल में संग्रहीत सरणी में मेमोरी-मैप बनाएं। |
.flush() () | सरणी में डिस्क पर फ़ाइल में कोई भी परिवर्तन लिखें। |
उदाहरण:
>>> a = memmap('newfile.dat', dtype=float, mode='w+', shape=1000) >>> a[10] = 10.0 >>> a[30] = 30.0 >>> del a >>> b = fromfile('newfile.dat', dtype=float) >>> print b[10], b[30] 10.0 30.0 >>> a = memmap('newfile.dat', dtype=float) >>> print a[10], a[30] 10.0 30.0
चरित्र सरणियाँ (
numpy.char
)
यह भी देखें
ध्यान दें
chararray
के साथ पीछे की संगतता के लिए
chararray
वर्ग मौजूद है, यह नए विकास के लिए अनुशंसित नहीं है।
Numpy 1.4 से शुरू, अगर किसी को स्ट्रिंग्स के सरणियों की आवश्यकता होती है, तो उसे
dtype
object_
,
string_
या
unicode_
सरणियों का उपयोग करने की सलाह दी
unicode_
, और तेजी से
numpy.char
स्ट्रिंग ऑपरेशनों के लिए
numpy.char
मॉड्यूल में फ्री फ़ंक्शंस का उपयोग किया जाता है।
ये
string_
प्रकार या
unicode_
प्रकार के
unicode_
।
ये सरणियाँ
ndarray
से विरासत में मिली हैं, लेकिन विशेष रूप से
+
(, प्रसारण) तत्व-दर-तत्व आधार पर
+
,
*
, और
%
को परिभाषित करती हैं।
ये ऑपरेशन वर्ण प्रकार के मानक
ndarray
पर उपलब्ध नहीं हैं।
इसके अलावा,
chararray
में मानक
string
(और
unicode
) के सभी तरीके हैं, उन्हें तत्व-दर-तत्व के आधार पर निष्पादित किया जाता है।
शायद एक करैरा बनाने का सबसे आसान तरीका है स्व.व्यू
self.view(chararray)
का उपयोग करना, जहां
स्व
str या यूनिकोड डेटा-प्रकार का एक प्रकार है।
हालाँकि,
chararray
कंस्ट्रक्टर का उपयोग करके या
numpy.char.array
फ़ंक्शन के माध्यम से एक वर्ण भी बनाया जा सकता है:
chararray
(आकार [, आइटम, यूनिकोड,…])
|
स्ट्रिंग और यूनिकोड मूल्यों की सरणियों पर एक सुविधाजनक दृश्य प्रदान करता है। |
numpy.char.array (obj [, itemsize,…]) |
एक
chararray
बनाएँ।
|
Str डेटा-टाइप के मानक ndarray के साथ एक और अंतर यह है कि chararray Numarray द्वारा पेश की गई विशेषता को विरासत में मिला है कि सरणी में किसी भी तत्व के अंत में व्हाइट-स्पेस आइटम पुनर्प्राप्ति और तुलना संचालन पर ध्यान नहीं दिया जाएगा।
रिकॉर्ड सरणियाँ (
numpy.rec
)
यह भी देखें
रिकॉर्ड सरणियाँ (numpy.rec) , डेटा प्रकार दिनचर्या , डेटा प्रकार ऑब्जेक्ट (dtype) बनाना ।
NumPy
recarray
वर्ग प्रदान करता है जो एक संरचित सरणी के क्षेत्रों को विशेषताओं के रूप में एक्सेस करने की अनुमति देता है, और इसी स्केलर डेटा प्रकार ऑब्जेक्ट
record
।
recarray
|
एक ndarray का निर्माण करें जो विशेषताओं का उपयोग करके फ़ील्ड एक्सेस की अनुमति देता है। |
record
|
एक डेटा-टाइप स्केलर जो फ़ीचर लुकअप के रूप में फ़ील्ड एक्सेस की अनुमति देता है। |
नकाबपोश सरणियाँ (
numpy.ma
)
यह भी देखें
मानक कंटेनर वर्ग
पिछड़ी अनुकूलता के लिए और एक मानक "कंटेनर" वर्ग के रूप में, न्यूमेरिक से UserArray को NumPy पर लाया गया है और
numpy.lib.user_array.container
नाम दिया
numpy.lib.user_array.container
। कंटेनर वर्ग एक पायथन वर्ग है जो अपना आत्म-गुण है एक ndarray है।
मल्टीपल इनहेरिटेंस संभवतया numpy.lib.user_array.container के साथ ndarray की तुलना में आसान है और इसलिए यह डिफ़ॉल्ट रूप से शामिल है।
यह अपने अस्तित्व का उल्लेख करने से परे यहां प्रलेखित नहीं है, क्योंकि आपको अगर आप कर सकते हैं सीधे ndarray वर्ग का उपयोग करने के लिए प्रोत्साहित किया जाता है।
numpy.lib.user_array.container
(डेटा [,…])
|
आसान कई-विरासत के लिए मानक कंटेनर-क्लास। |
ऐरे इटरेटर
सरणी प्रसंस्करण के लिए Iterators एक शक्तिशाली अवधारणा है। अनिवार्य रूप से, पुनरावृत्तियां एक सामान्यीकृत लूप के लिए लागू होती हैं। यदि माइटर एक इट्रेटर ऑब्जेक्ट है, तो पायथन कोड:
for val in myiter: ... some code involving val ...
val = myiter.next()
बार-बार जब तक
StopIteration
को पुनरावृत्तिकर्ता द्वारा उठाया नहीं जाता है।
एक सरणी पर पुनरावृति करने के कई तरीके हैं जो उपयोगी हो सकते हैं: डिफ़ॉल्ट पुनरावृत्ति, फ्लैट पुनरावृत्ति, और
-डिमेटिक एन्यूमरेशन।
डिफ़ॉल्ट पुनरावृत्ति
एक ndarray ऑब्जेक्ट का डिफ़ॉल्ट पुनरावृत्ति एक अनुक्रम प्रकार का डिफ़ॉल्ट पायथन पुनरावृत्ति है। इस प्रकार, जब ऐरे ऑब्जेक्ट को ही इटरेटर के रूप में उपयोग किया जाता है। डिफ़ॉल्ट व्यवहार इसके बराबर है:
for i in range(arr.shape[0]): val = arr[i]
यह डिफ़ॉल्ट पुनरावृत्ति आयाम के एक उप-सरणी का चयन करता है
सरणी से।
यह पुनरावर्ती एल्गोरिदम को परिभाषित करने के लिए एक उपयोगी निर्माण हो सकता है।
पूरे सरणी पर लूप करने के लिए आवश्यक है
के लिए-छोरों।
>>> a = arange(24).reshape(3,2,4)+10 >>> for val in a: ... print 'item:', val item: [[10 11 12 13] [14 15 16 17]] item: [[18 19 20 21] [22 23 24 25]] item: [[26 27 28 29] [30 31 32 33]]
सपाट पुनरावृत्ति
ndarray.flat
|
सरणी पर एक 1-डी पुनरावृत्ति। |
जैसा कि पहले उल्लेख किया गया है, ndarray ऑब्जेक्ट्स की फ्लैट विशेषता सी-शैली सन्निहित क्रम में पूरे सरणी पर चक्रित होने वाली एक पुनरावृत्ति लौटाती है।
>>> for i, val in enumerate(a.flat): ... if i%5 == 0: print i, val 0 10 5 15 10 20 15 25 20 30
यहाँ, मैंने बिल्ट-इन एन्यूमरेट इटरेटर का उपयोग किया है, इटरेटर इंडेक्स को वापस करने के साथ-साथ वैल्यू को भी।
एन-आयामी गणना
ndenumerate
(
ndenumerate
)
|
बहुआयामी सूचकांक पुनरावृत्ति। |
कभी-कभी पुनरावृत्ति करते समय एन-आयामी सूचकांक प्राप्त करना उपयोगी हो सकता है। Ndenumerate iterator इसे प्राप्त कर सकता है।
>>> for i, val in ndenumerate(a): ... if sum(i)%5 == 0: print i, val (0, 0, 0) 10 (1, 1, 3) 25 (2, 0, 3) 29 (2, 1, 2) 32
प्रसारण के लिए Iterator
broadcast
|
एक ऐसी वस्तु का निर्माण करें जो प्रसारण की नकल करती है। |
प्रसारण की सामान्य अवधारणा भी
broadcast
इटैलर का उपयोग करके पायथन से उपलब्ध है।
यह वस्तु लेता है
इनपुट्स के रूप में ऑब्जेक्ट्स और एक इट्रेटर लौटाता है जो प्रसारण परिणाम में इनपुट अनुक्रम तत्वों में से प्रत्येक को प्रदान करने वाले ट्यूपल को लौटाता है।
>>> for val in broadcast([[1,0],[2,3]],[0,1]): ... print val (1, 0) (0, 1) (2, 0) (3, 1)