मानक सरणी उपवर्ग

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) बन जाता है, और फिर invokes obj.__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 की समान विशेषताएँ और विधियाँ हैं। मैट्रिक्स ऑब्जेक्ट्स के छह महत्वपूर्ण अंतर हैं, हालांकि, जब आप मैट्रिसेस का उपयोग करते हैं तो अप्रत्याशित परिणाम हो सकते हैं, लेकिन उनसे एरियर्स की तरह कार्य करने की अपेक्षा करें:

1. मैट्रिक्स ऑब्जेक्ट्स को एक स्ट्रिंग संकेतन का उपयोग करके बनाया जा सकता है, जिसमें मैटलैब-शैली के सिंटैक्स की अनुमति होती है जहां रिक्त स्थान अलग-अलग कॉलम और अर्धविराम (';') अलग-अलग पंक्तियों में होते हैं।
2. मैट्रिक्स ऑब्जेक्ट हमेशा दो-आयामी होते हैं। इसके दूरगामी निहितार्थ हैं, उस m.ravel () में अभी भी दो आयामी (पहले आयाम में 1 के साथ) और आइटम का चयन दो-आयामी ऑब्जेक्ट देता है ताकि अनुक्रम व्यवहार सरणियों की तुलना में मौलिक रूप से भिन्न हो।
3. मैट्रिक्स ऑब्जेक्ट मैट्रिक्स-गुणन होने के लिए कई गुना अधिक सवारी करते हैं। सुनिश्चित करें कि आप इसे उन कार्यों के लिए समझते हैं जिन्हें आप मैट्रिस प्राप्त करना चाहते हैं। विशेष रूप से इस तथ्य के प्रकाश में कि asanyarray (m) एक मैट्रिक्स है जब m एक मैट्रिक्स है।
4. मैट्रिक्स की वस्तुएं एक शक्ति को बढ़ाने के लिए मैट्रिक्स पर वस्तुओं की सवारी करती हैं। एक फ़ंक्शन के अंदर शक्ति का उपयोग करने के बारे में एक ही चेतावनी जो इस तथ्य के लिए एक सरणी ऑब्जेक्ट प्राप्त करने के लिए asanyarray (…) का उपयोग करता है।
5. मैट्रिक्स ऑब्जेक्ट्स का डिफ़ॉल्ट __array_priority__ 10.0 है, और इसलिए ndarrays के साथ मिश्रित ऑपरेशन हमेशा मैट्रिस का उत्पादन करते हैं।

6. मैट्रिसेस में विशेष गुण होते हैं जो गणना को आसान बनाते हैं। य़े हैं

   matrix.T	मैट्रिक्स का संक्रमण लौटाता है।
   matrix.H	रिटर्न (जटिल) संयुग्म self संक्रमण।
   matrix.I	(गुणा) उलटे self का प्रतिलोम देता है।
   matrix.A	self को एक ndarray वस्तु के रूप में लौटाएं।

मैट्रिक्स क्लास, 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 )

ये 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 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)