NumPy 1.14 - The N-dimensional array (ndarray)

एन-आयामी सरणी (ndarray)




numpy

एन-आयामी सरणी (ndarray)

एक ndarray एक ही प्रकार और आकार की वस्तुओं का एक (आमतौर पर निश्चित आकार) बहुआयामी कंटेनर है। किसी सरणी में आयाम और आइटम की संख्या उसके shape से परिभाषित होती shape , जो एन पॉजिटिव पूर्णांकों का एक समूह है जो प्रत्येक आयाम के आकार को निर्दिष्ट करता है। सरणी में आइटम का प्रकार एक अलग डेटा-प्रकार ऑब्जेक्ट (dtype) द्वारा निर्दिष्ट किया गया है, जिनमें से एक प्रत्येक ndray के साथ जुड़ा हुआ है।

पाइथन में अन्य कंटेनर ऑब्जेक्ट्स की तरह, एक ndarray की सामग्री को सरणी को अनुक्रमित ( या उपयोग करके, उदाहरण के लिए, एन पूर्णांक), और ndarray के तरीकों और विशेषताओं के माध्यम से एक्सेस और संशोधित किया जा सकता है।

अलग-अलग ndarray एक ही डेटा साझा कर सकते हैं, ताकि एक ndarray किए गए परिवर्तन दूसरे में दिखाई दे सकें। अर्थात्, एक ndarray दूसरे ndarray के लिए एक "दृश्य" हो सकता है, और जिस डेटा का वह उल्लेख कर रहा है, उसे "आधार" ndarray द्वारा ध्यान रखा जाता है। ndarrays पाइथन strings या buffer या array इंटरफेस को लागू करने वाली वस्तुओं के स्वामित्व वाली मेमोरी के दृश्य भी हो सकते हैं।

उदाहरण

4 x बाइट पूर्णांक तत्वों से बना 2 x 3 आकार का 2-आयामी सरणी:

>>> x = np.array([[1, 2, 3], [4, 5, 6]], np.int32)
>>> type(x)
<type 'numpy.ndarray'>
>>> x.shape
(2, 3)
>>> x.dtype
dtype('int32')

सरणी को पायथन कंटेनर जैसे सिंटैक्स का उपयोग करके अनुक्रमित किया जा सकता है:

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]

उदाहरण के लिए टुकड़ा करने की क्रिया सरणी के दृश्य उत्पन्न कर सकते हैं:

>>> y = x[:,1]
>>> y
array([2, 5])
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array([9, 5])
>>> x
array([[1, 9, 3],
       [4, 5, 6]])

सरणियों का निर्माण

नई सरणियों का निर्माण ऐरे सृजन रूटीन में विस्तृत रूटीन का उपयोग करके किया जा सकता है, और निम्न-स्तर के ndarray निर्माण ndarray का उपयोग करके भी किया जा सकता है:

ndarray (आकार [, dtype, बफर, ऑफसेट,…]) एक सरणी ऑब्जेक्ट निश्चित-आकार की वस्तुओं के एक बहुआयामी, सजातीय सरणी का प्रतिनिधित्व करता है।

अनुक्रमण सारणी

array[selection] एक विस्तारित पायथन स्लाइसिंग सिंटैक्स, array[selection] का उपयोग करके अनुक्रमित किया जा सकता है। इसी तरह के सिंटैक्स का उपयोग संरचित सरणी में फ़ील्ड तक पहुँचने के लिए भी किया जाता है।

यह भी देखें

ऐरे इंडेक्सिंग

एक ndarray की आंतरिक मेमोरी लेआउट

क्लास ndarray की एक आवृत्ति में कंप्यूटर मेमोरी (किसी सरणी, या किसी अन्य ऑब्जेक्ट के स्वामित्व) का एक सन्निहित एक आयामी खंड होता है, जो एक अनुक्रमण योजना के साथ संयुक्त होता है जो ब्लॉक में एक आइटम के स्थान में एन पूर्णांक को मैप करता है। जिन श्रेणियों में सूचकांक भिन्न हो सकते हैं वे सरणी के shape द्वारा निर्दिष्ट किए जाते हैं। प्रत्येक आइटम कितने बाइट्स लेता है और बाइट्स की व्याख्या कैसे की जाती है यह सरणी से जुड़े डेटा-प्रकार ऑब्जेक्ट द्वारा परिभाषित किया गया है।

स्मृति का एक खंड स्वाभाविक रूप से 1-आयामी है, और 1-आयामी ब्लॉक में एन -डायमेंशनल सरणी के आइटम की व्यवस्था के लिए कई अलग-अलग योजनाएं हैं। NumPy लचीला है, और ndarray ऑब्जेक्ट्स किसी भी अनुक्रमणित अनुक्रमण योजना को समायोजित कर सकते हैं। एक तार योजना में, एन-आयामी सूचकांक (n_0, n_1, ..., n_ {N-1}) ऑफसेट (बाइट्स में) से मेल खाती है:

n _ {\ _ mathrm {ऑफसेट}} = \ sum_ {k = 0} ^ {N-1} s_k n_k

सरणी से जुड़े मेमोरी ब्लॉक की शुरुआत से। यहाँ, s_k पूर्णांक हैं जो सरणी के strides को निर्दिष्ट करते हैं। column-major ऑर्डर (उदाहरण के लिए, फोरट्रान भाषा में और मैटलैब में ) और row-major ऑर्डर (सी में इस्तेमाल किया गया) स्कीम केवल विशिष्ट प्रकार की स्ट्रैंड्ड स्कीम हैं, और मेमोरी के अनुरूप होते हैं जिन्हें स्ट्राइड्स द्वारा संबोधित किया जा सकता है:

s_k ^ {\ _ mathrm {कॉलम}} = \ mathrm {आइटम करें} \ prod_ {j = 0} ^ {k-1} d_j, \ quad s_k ^ {\ _ mathrm {row}} = = mathrm {आइटम करें} \ prod_ { j = k + 1} ^ {N-1} d_j

कहा पे d_j = self.shape[j]

सी और फोरट्रान दोनों ऑर्डर contiguous , यानी एकल-खंड , मेमोरी लेआउट, जिसमें मेमोरी ब्लॉक के प्रत्येक भाग को सूचकांकों के कुछ संयोजन द्वारा पहुँचा जा सकता है।

हालांकि सी-स्टाइल और फोरट्रान-शैली के सन्निहित सरणी, जिसमें संबंधित झंडे सेट हैं, को उपरोक्त तारों के साथ संबोधित किया जा सकता है, वास्तविक स्ट्राइड्स अलग हो सकते हैं। यह दो मामलों में हो सकता है:

  1. यदि self.shape[k] == 1 तो किसी भी कानूनी सूचकांक index[k] == 0 । इसका मतलब है कि ऑफसेट के लिए सूत्र में n_k = 0 और इस तरह s_k n_k = 0 और का मूल्य s_k = self.strides[k] मनमाना है।
  2. यदि किसी सरणी में कोई तत्व नहीं है ( self.size == 0 ) कोई कानूनी सूचकांक नहीं है और self.size == 0 उपयोग कभी नहीं किया जाता है। बिना किसी तत्व के किसी भी सरणी को C- शैली और फोरट्रान-शैली सन्निहित नहीं माना जा सकता है।

बिंदु 1. का अर्थ है कि self और self.squeeze() हमेशा एक ही संदर्भ और संरेखित झंडे का मूल्य होता है। इसका मतलब यह भी है कि एक उच्च आयामी सरणी एक ही समय में सी-स्टाइल और फोरट्रान-शैली सन्निहित हो सकती है।

यदि सभी तत्वों के लिए मेमोरी ऑफ़सेट हो जाती है और आधार ऑफ़सेट अपने आप में एक self.itemsize हो जाता है, तो self.itemsize को self.itemsize

ध्यान दें

अंक (1) और (2) अभी तक डिफ़ॉल्ट रूप से लागू नहीं किए गए हैं। NumPy 1.8.0 से शुरुआत करते हुए, उन्हें केवल तभी लागू किया जाता है जब पर्यावरण चर NPY_RELAXED_STRIDES_CHECKING=1 को परिभाषित किया गया था जब NumPy बनाया गया था। आखिरकार यह डिफ़ॉल्ट हो जाएगा।

आप जाँच सकते हैं कि क्या यह विकल्प सक्षम किया गया था जब np.ones((10,1), order='C').flags.f_contiguous के मान को np.ones((10,1), order='C').flags.f_contiguous आपका NumPy बनाया गया था। यदि यह True , तो आपके NumPy ने रिलैक्सेड स्ट्रिंग्स चेकिंग सक्षम किया है।

चेतावनी

यह आमतौर पर यह नहीं रखता है कि self.strides[-1] == self.itemsize सी-शैली सन्निहित सरणियों के लिए self.strides[0] == self.itemsize

नए ndarray में डेटा row-major (C) क्रम में है, जब तक कि अन्यथा निर्दिष्ट नहीं किया जाता है, लेकिन उदाहरण के लिए, मूल सरणी स्लाइसिंग अक्सर एक अलग योजना में views पैदा करता है।

ध्यान दें

NumPy में कई एल्गोरिदम मनमाने ढंग से तार सरणियों पर काम करते हैं। हालांकि, कुछ एल्गोरिदम को एकल-खंड सरणियों की आवश्यकता होती है। जब इस तरह के एल्गोरिदम में अनियमित रूप से स्ट्रिंग सरणी पास की जाती है, तो एक प्रतिलिपि स्वचालित रूप से बन जाती है।

ऐरे गुण

सरणी विशेषताएँ उस जानकारी को दर्शाती हैं जो सरणी के लिए आंतरिक है। आम तौर पर, अपनी विशेषताओं के माध्यम से एक सरणी तक पहुँचने से आपको नई सरणी बनाने के बिना सरणी के आंतरिक गुणों को प्राप्त करने और कभी-कभी सेट करने की अनुमति मिलती है। उजागर विशेषताएँ एक सरणी के मुख्य भाग हैं और उनमें से केवल कुछ ही नए सरणी बनाए बिना सार्थक रूप से रीसेट किए जा सकते हैं। प्रत्येक विशेषता की जानकारी नीचे दी गई है।

मेमोरी लेआउट

निम्नलिखित विशेषताओं में सरणी के मेमोरी लेआउट के बारे में जानकारी है:

ndarray.flags सरणी के मेमोरी लेआउट के बारे में जानकारी।
shape सरणी आयामों का टपल।
strides किसी सरणी को ट्रेस करते समय प्रत्येक आयाम में कदम रखने के लिए बाइट्स का ट्यूपल।
ndarray.ndim सरणी आयामों की संख्या।
ndarray.data सरणी के डेटा की शुरुआत की ओर इशारा करते हुए पायथन बफर ऑब्जेक्ट।
ndarray.size सरणी में तत्वों की संख्या।
ndarray.itemsize बाइट्स में एक सरणी तत्व की लंबाई।
ndarray.nbytes सरणी के तत्वों द्वारा खपत कुल बाइट्स।
ndarray.base बेस ऑब्जेक्ट अगर मेमोरी किसी अन्य ऑब्जेक्ट से है।

डाटा प्रकार

सरणी से संबंधित डेटा प्रकार ऑब्जेक्ट dtype विशेषता में पाया जा सकता है:

dtype सरणी के तत्वों का डेटा-प्रकार।

अन्य विशेषताएँ

ndarray.T Self.transpose () के रूप में भी, सिवाय इसके कि अगर self.ndim <2 वापस आ गया है।
ndarray.real सरणी का वास्तविक हिस्सा।
ndarray.imag सरणी का काल्पनिक हिस्सा।
ndarray.flat सरणी पर एक 1-डी पुनरावृत्ति।
ndarray.ctypes Ctypes मॉड्यूल के साथ सरणी के इंटरैक्शन को सरल बनाने के लिए एक ऑब्जेक्ट।

एरियर इंटरफ़ेस

यह भी देखें

array

__array_interface__ सरणी इंटरफ़ेस का पायथन-साइड
__array_struct__ सरणी इंटरफ़ेस का सी-साइड

ctypes विदेशी फ़ंक्शन इंटरफ़ेस

ndarray.ctypes Ctypes मॉड्यूल के साथ सरणी के इंटरैक्शन को सरल बनाने के लिए एक ऑब्जेक्ट।

ऐरे तरीके

एक ndarray ऑब्जेक्ट में कई विधियाँ होती हैं जो किसी न किसी फ़ैशन में सरणी पर या उसके साथ काम करती हैं, आमतौर पर एक सरणी परिणाम लौटाती हैं। इन विधियों को संक्षेप में नीचे समझाया गया है। (प्रत्येक विधि के डॉकस्ट्रिंग में अधिक पूर्ण विवरण है।)

निम्नलिखित विधियों के लिए भी numpy में समान कार्य हैं: all , any , argmax , argmax , argmin , argpartition , argsort , clip , compress , copy , cumprod , cumsum , diagonal , imag , max , mean , min , nonzero , partition prod , ptp , put , ravel , real , repeat , searchsorted , round , searchsorted , searchsorted , squeeze , std , sum , swapaxes , take , trace , transpose , var

रूपांतरण रूपांतरण

ndarray.item (* args) एक सरणी के एक तत्व को एक मानक पायथन स्केलर पर कॉपी करें और इसे वापस करें।
ndarray.tolist () सरणी को एक (संभवतः नेस्टेड) ​​सूची के रूप में लौटाएं।
ndarray.itemset (* args) स्केलर को एक सरणी में डालें (यदि संभव हो तो स्केलर को सरणी के dtype पर डाला जाता है)
ndarray.tostring ([आदेश]) सरणी में कच्चे डेटा बाइट्स वाले पायथन बाइट्स का निर्माण करें।
ndarray.tobytes ([आदेश)) सरणी में कच्चे डेटा बाइट्स वाले पायथन बाइट्स का निर्माण करें।
ndarray.tofile (fid [, sep, format]) फ़ाइल को पाठ या बाइनरी (डिफ़ॉल्ट) के रूप में लिखें।
ndarray.dump (फ़ाइल) निर्दिष्ट फ़ाइल में सरणी का एक अचार डंप करें।
ndarray.dumps () सरणी के अचार को एक स्ट्रिंग के रूप में लौटाता है।
ndarray.astype (dtype [, ऑर्डर, कास्टिंग,…]) सरणी की प्रतिलिपि, एक निर्दिष्ट प्रकार के लिए डाली गई।
ndarray.byteswap ([inplace]) सरणी तत्वों के बाइट्स स्वैप करें
ndarray.copy ([आदेश)) सरणी की एक प्रति लौटाएं।
ndarray.view ([dtype, type]) उसी डेटा के साथ सरणी का नया दृश्य।
ndarray.getfield (dtype [, ऑफसेट]) एक निश्चित प्रकार के रूप में दिए गए सरणी के एक क्षेत्र को लौटाता है।
ndarray.setflags ([लिखें, संरेखित करें, Uic]) सरणी के झंडे सेट करें, क्रमशः, (WRITEBACKIFCOPY और UPDATEIFCOPY) क्रमशः।
ndarray.fill (मान) एक स्केलर मान के साथ सरणी भरें।

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

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

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

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

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

ndarray.take (सूचकांक [, अक्ष, बाहर, मोड]) दिए गए सूचकांकों में तत्वों से निर्मित एक सरणी लौटें।
ndarray.put (सूचकांक, मूल्य [, मोड]) सूचकांक में सभी n लिए a.flat[n] = values[n] सेट करें।
ndarray.repeat (दोहराता [, अक्ष]) किसी सरणी के तत्वों को दोहराएं।
ndarray.choose (विकल्प [, बाहर, मोड]) विकल्पों के एक सेट से एक नई सरणी बनाने के लिए एक इंडेक्स सरणी का उपयोग करें।
ndarray.sort ([अक्ष, प्रकार, आदेश]) एक सरणी, जगह में सॉर्ट करें।
ndarray.argsort ([अक्ष, प्रकार, आदेश]) इस सरणी को सॉर्ट करने वाले सूचकांकों को लौटाता है।
ndarray.partition ( ndarray.partition [, axis, kind, order]) सरणी में तत्वों को इस तरह से पुनर्व्यवस्थित करता है कि kth स्थिति में तत्व का मूल्य उस स्थिति में होता है, जो क्रमबद्ध सरणी में होता है।
ndarray.argpartition ( ndarray.argpartition [, axis, kind, order]) इस सरणी को विभाजित करने वाले सूचकांकों को लौटाता है।
ndarray.searchsorted (v [, पक्ष, सॉर्टर]) आदेश प्राप्त करने के लिए सूचकांकों को खोजें जहां v के तत्वों को एक में डाला जाना चाहिए।
ndarray.nonzero () उन तत्वों के सूचकांकों को लौटाएं जो गैर-शून्य हैं।
ndarray.compress (स्थिति [, अक्ष, बाहर]) दिए गए अक्ष के साथ इस सरणी के चयनित स्लाइस लौटें।
ndarray.diagonal ([ऑफ़सेट, एक्सिस 1, एक्सिस 2]) निर्दिष्ट विकर्ण वापस करें।

हिसाब

इनमें से कई विधियां अक्ष नामक एक तर्क लेती हैं। ऐसे मामलो मे,

  • यदि अक्ष कोई नहीं है (डिफ़ॉल्ट), तो सरणी को 1-डी सरणी के रूप में माना जाता है और ऑपरेशन पूरे सरणी पर किया जाता है। यह व्यवहार भी डिफ़ॉल्ट है यदि स्व 0 आयामी सरणी या सरणी स्केलर है। (एक सरणी स्केलर प्रकार / वर्गों फ्लोट 32, फ्लोट64, आदि का एक उदाहरण है, जबकि 0-आयामी सरणी एक ndarray उदाहरण है जिसमें ठीक एक सरणी स्केलर होता है।)
  • यदि अक्ष एक पूर्णांक है, तो दिए गए अक्ष पर ऑपरेशन किया जाता है (प्रत्येक 1-डी सबरे के लिए जो दिए गए अक्ष के साथ बनाया जा सकता है)।

अक्ष तर्क का उदाहरण

3 x 3 x 3 आकार का एक 3-आयामी सरणी, इसके तीन अक्षों में से प्रत्येक पर अभिव्यक्त हुआ

>>> x
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],
       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]],
       [[18, 19, 20],
        [21, 22, 23],
        [24, 25, 26]]])
>>> x.sum(axis=0)
array([[27, 30, 33],
       [36, 39, 42],
       [45, 48, 51]])
>>> # for sum, axis is the first keyword, so we may omit it,
>>> # specifying only its value
>>> x.sum(0), x.sum(1), x.sum(2)
(array([[27, 30, 33],
        [36, 39, 42],
        [45, 48, 51]]),
 array([[ 9, 12, 15],
        [36, 39, 42],
        [63, 66, 69]]),
 array([[ 3, 12, 21],
        [30, 39, 48],
        [57, 66, 75]]))

पैरामीटर dtype उस डेटा प्रकार को निर्दिष्ट करता है जिस पर एक कमी ऑपरेशन (जैसे संक्षेप) होना चाहिए। डिफ़ॉल्ट कम डेटा प्रकार स्वयं के डेटा प्रकार के समान है। अतिप्रवाह से बचने के लिए, बड़े डेटा प्रकार का उपयोग करके कटौती करने के लिए उपयोगी हो सकता है।

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

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

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

ndarray पर अंकगणितीय और तुलनात्मक संचालन को तत्व-वार संचालन के रूप में परिभाषित किया गया है, और आमतौर पर परिणाम के रूप में ndarray वस्तुओं का उत्पादन होता है।

अंकगणितीय ऑपरेशनों में से प्रत्येक ( + , - , * , / , // , % , divmod() , ** या pow() , << , >> , >> , & , ^ , | , ~ ) और तुलनाओं ( == ,, < , > , <= , >= ; != ) NumPy में संबंधित सार्वभौमिक फ़ंक्शन (या ufunc लिए ufunc ) के बराबर है। अधिक जानकारी के लिए, यूनिवर्सल फ़ंक्शंस पर अनुभाग देखें।

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

ndarray.__lt__ ($ स्वयं, मूल्य, /) स्व <मान लौटाएं।
ndarray.__le__ ($ स्व, मूल्य, /) स्व <= मान लौटाएं।
ndarray.__gt__ ($ स्व, मूल्य, /) स्व> मान लौटाएं।
ndarray.__ge__ ($ स्व, मूल्य, /) स्व लौटें = = मान।
ndarray.__eq__ ($ स्व, मूल्य, /) स्व == मान लौटाएँ।
ndarray.__ne__ ($ स्व, मूल्य, /) स्व लौटें! = मान।

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

ndarray.__nonzero__

ध्यान दें

किसी सरणी का सत्य-मूल्य परीक्षण ndarray.__nonzero__ आमंत्रित करता है, जो एक त्रुटि उठाता है यदि सरणी में तत्वों की संख्या 1 से अधिक है, क्योंकि ऐसे सरणियों का सत्य मान अस्पष्ट है। ndarray.any और ndarray.all बजाय ऐसे मामलों में क्या मतलब है के बारे में स्पष्ट होने के लिए उपयोग करें। (यदि तत्वों की संख्या 0 है, तो सरणी False मूल्यांकन करती है।)

एकतरफा संचालन:

ndarray.__neg__ ($ स्वयं, /) -Self
ndarray.__pos__ ($ स्व, /) + आत्म
ndarray.__abs__ (स्व)
ndarray.__invert__ ($ स्वयं, /) ~ आत्म

अंकगणित:

ndarray.__add__ ($ स्वयं, मूल्य, /) स्व + मान लौटाएं।
ndarray.__sub__ ($ स्व, मूल्य, /) स्व-मूल्य लौटाएं।
ndarray.__mul__ ($ स्व, मूल्य, /) स्व * मान लौटाएं।
ndarray.__div__
ndarray.__truediv__ ($ स्व, मूल्य, /) स्व / मान लौटाएं।
ndarray.__floordiv__ ($ स्वयं, मूल्य, /) स्व / मान लौटाएं।
ndarray.__mod__ ($ स्व, मूल्य, /) स्व% मान लौटाओ।
ndarray.__divmod__ ($ स्व, मूल्य, /) रिटर्न डिमॉड (स्व, मूल्य)।
ndarray.__pow__ ($ स्वयं, मूल्य [, mod]) रिटर्न पॉव (स्व, मूल्य, मॉड)।
ndarray.__lshift__ ($ स्व, मूल्य, /) स्व वापस लौटें << मूल्य।
ndarray.__rshift__ ($ स्व, मूल्य, /) स्व लौटें >> मान।
ndarray.__and__ ($ स्व, मूल्य, /) स्व और मान लौटाएं।
ndarray.__or__ ($ स्व, मूल्य, /) स्व लौटें। मूल्य
ndarray.__xor__ ($ स्व, मूल्य, /) स्व ^ मान लौटाएं।

ध्यान दें

  • pow किसी भी तीसरे तर्क को चुपचाप नजरअंदाज कर दिया जाता है, क्योंकि अंतर्निहित ufunc केवल दो तर्क लेता है।
  • तीन डिवीजन ऑपरेटर सभी परिभाषित हैं; div डिफ़ॉल्ट रूप से सक्रिय है, truediv सक्रिय है जब __future__ विभाजन प्रभाव में है।
  • क्योंकि ndarray एक अंतर्निहित प्रकार है (C में लिखा गया है), __r{op}__ विशेष तरीके सीधे परिभाषित नहीं हैं।
  • सरणियों के लिए कई अंकगणितीय विशेष विधियों को लागू करने के लिए कहे गए कार्यों को set_numeric_ops का उपयोग करके संशोधित किया जा सकता है।

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

ndarray.__iadd__ ($ स्व, मूल्य, /) स्व + वापसी = मान।
ndarray.__isub__ ($ स्वयं, मूल्य, /) स्व लौटें = मान।
ndarray.__imul__ ($ स्वयं, मूल्य, /) स्व * वापसी = मान।
ndarray.__idiv__
ndarray.__itruediv__ ($ स्वयं, मूल्य, /) स्व / = मान लौटाएं।
ndarray.__ifloordiv__ ($ स्व, मूल्य, /) स्व वापस लौटें // = मूल्य।
ndarray.__imod__ ($ स्वयं, मूल्य, /) स्व% = मान लौटाएं।
ndarray.__ipow__ ($ स्वयं, मूल्य, /) स्व ** वापसी = मान।
ndarray.__ilshift__ ($ स्व, मूल्य, /) स्व वापस लौटें << = मूल्य।
ndarray.__irshift__ ($ स्व, मूल्य, /) स्व लौटें >> = मान।
ndarray.__iand__ ($ स्व, मूल्य, /) स्व & = मान लौटाएं।
ndarray.__ior__ ($ स्वयं, मूल्य, /) स्व लौटें = मूल्य।
ndarray.__ixor__ ($ स्व, मूल्य, /) स्व ^ वापसी = मान।

चेतावनी

जगह के संचालन में दो ऑपरेंड के डेटा प्रकार द्वारा तय की गई सटीकता का उपयोग करके गणना करेंगे, लेकिन परिणाम को चुपचाप नीचे कर देगा (यदि आवश्यक हो) तो यह सरणी में वापस फिट हो सकता है। इसलिए, मिश्रित सटीक गणनाओं के लिए, A {op}= B A = A {op} B से भिन्न हो सकता है। उदाहरण के लिए, मान लें कि a = ones((3,3)) । फिर, a += 3j a = a + 3j से भिन्न होता a = a + 3j : जबकि वे दोनों एक ही संगणना करते हैं, a += 3 परिणाम को वापस a में फिट करने के लिए a = a + 3j देता a , जबकि a = a + 3j पुनः नाम को बांध देता है a परिणाम।

मैट्रिक्स गुणन:

ndarray.__matmul__ ($ स्व, मूल्य, /) स्व @ मान लौटाएं।

ध्यान दें

मैट्रिक्स ऑपरेटरों @ और @= को PEP465 के बाद पायथन 3.5 में पेश किया गया था। NumPy 1.10.0 का परीक्षण उद्देश्यों के लिए @ का प्रारंभिक कार्यान्वयन है। आगे के दस्तावेज matmul दस्तावेज में पाए जा सकते हैं।

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

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

ndarray.__copy__ () उपयोग किया जाता है अगर copy.copy एक सरणी पर कहा जाता है।
ndarray.__deepcopy__ ((मेमो,…) उपयोग किया जाता है अगर copy.deepcopy एक सरणी पर कहा जाता है।
ndarray.__reduce__ () अचार के लिए।
ndarray.__setstate__ (राज्य, /) अनप्लगिंग के लिए।

मूल अनुकूलन:

ndarray.__new__ ($ प्रकार, * args, ** kwargs) एक नई वस्तु बनाएं और वापस करें।
ndarray.__array__ (…) यदि dtype नहीं दिया गया है या dtype सरणी के वर्तमान dtype से भिन्न है, तो dtype नहीं दिया गया है या प्रदान किए गए डेटा प्रकार का एक नया सरणी, स्वयं के लिए एक नया संदर्भ देता है।
ndarray.__array_wrap__ (…)

कंटेनर अनुकूलन: ( अनुक्रमण देखें)

ndarray.__len__ ($ स्वयं, /) वापसी लेन (स्व)।
ndarray.__getitem__ ($ स्वयं, कुंजी, /) स्व लौटें [कुंजी]।
ndarray.__setitem__ ($ स्वयं, कुंजी, मूल्य, /) मूल्य के लिए स्व [कुंजी] सेट करें।
ndarray.__contains__ ($ स्व, कुंजी, /) शामिल है स्व में वापसी कुंजी।

रूपांतरण; संचालन complex , int , long , float , oct और hex । वे केवल उन सरणियों पर काम करते हैं जिनमें उनमें एक तत्व होता है और उपयुक्त स्केलर को वापस करता है।

ndarray.__int__ (स्व)
ndarray.__long__
ndarray.__float__ (स्व)
ndarray.__oct__
ndarray.__hex__

स्ट्रिंग प्रतिनिधित्व:

ndarray.__str__ ($ स्वयं, /) वापस लौटना (स्व)।
ndarray.__repr__ ($ स्वयं, /) वापसी (स्वयं)।