NumPy 1.14 - numpy.newaxis

Indexing




numpy

Indexing

ndarrays को मानक Python x[obj] सिंटैक्स का उपयोग करके अनुक्रमित किया जा सकता है, जहाँ x सरणी है और चयन को obj । तीन तरह के इंडेक्सिंग उपलब्ध हैं: फील्ड एक्सेस, बेसिक स्लाइसिंग, एडवांस्ड इंडेक्सिंग। जो होता है वह obj पर निर्भर करता है।

ध्यान दें

पायथन में, x[(exp1, exp2, ..., expN)] x[exp1, exp2, ..., expN] ; उत्तरार्द्ध पूर्व के लिए सिंटैक्टिक चीनी है।

बेसिक स्लिंग और इंडेक्सिंग

बेसिक स्लाइसिंग, पाइथन की एन कॉन्सेप्ट को स्लाइस करने की बेसिक अवधारणा को बढ़ाता है। बेसिक स्लाइसिंग तब होती है जब obj एक slice ऑब्जेक्ट ( start:stop:step द्वारा निर्मित start:stop:step नोटेशन ब्रैकेट्स के अंदर), एक पूर्णांक, या स्लाइस ऑब्जेक्ट्स और पूर्णांकों का एक टपल होता है। newaxis और newaxis ऑब्जेक्ट्स को newaxis जा सकता है। न्यूमेरिक में एक सामान्य उपयोग के साथ पिछड़े संगत बने रहने के लिए, यदि चयन ऑब्जेक्ट किसी भी गैर-ndarray अनुक्रम (जैसे कि एक list ) में slice ऑब्जेक्ट्स, newaxis ऑब्जेक्ट या newaxis ऑब्जेक्ट है, तो मूल स्लाइसिंग शुरू की newaxis है, लेकिन इसके लिए नहीं पूर्णांक सरणियाँ या अन्य एम्बेडेड अनुक्रम।

एन पूर्णांकों के साथ अनुक्रमण का सबसे सरल मामला एक सरणी स्केलर को संबंधित आइटम का प्रतिनिधित्व करता है। पाइथन की तरह, सभी सूचकांक शून्य-आधारित हैं: i -th इंडेक्स के लिए n_i मान्य श्रेणी है 0 \ le n_i <d_i कहा पे d_i सरणी के आकार का i -th तत्व है। ऋणात्मक सूचकांकों को सरणी के अंत से गणना के रूप में व्याख्या की जाती है ( यानी , यदि n_i <० , इसका मतलब n_i + d_i )।

बुनियादी स्लाइसिंग द्वारा उत्पन्न सभी सरणियाँ हमेशा मूल सरणी के views होते हैं।

अनुक्रम स्लाइसिंग के मानक नियम प्रति-आयाम आधार पर बुनियादी स्लाइसिंग पर लागू होते हैं (एक स्टेप इंडेक्स का उपयोग करके)। याद रखने के लिए कुछ उपयोगी अवधारणाओं में शामिल हैं:

  • बेसिक स्लाइस सिंटैक्स i:j:k जहाँ मैं शुरुआती इंडेक्स है, j स्टॉपिंग इंडेक्स है, और k स्टेप है ( कश्मीर \ neq0 )। यह m तत्वों का चयन करता है (इसी आयाम में) सूचकांक मानों के साथ, i + k ,…, i + (m - 1) k m = q + (r \ neq0) और q और r भागफल और j को विभाजित करके प्राप्त किए गए शेष हैं - i by k : j - i = qk + r , ताकि i + (m - 1) k <j

    उदाहरण

    >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> x[1:7:2]
    array([1, 3, 5])
    
  • नकारात्मक i और j की व्याख्या n + i और n + j के रूप में की जाती है जहाँ n तत्सम आयाम में तत्वों की संख्या होती है। नेगेटिव k स्टेपिंग को छोटे सूचकांकों की ओर ले जाता है।

    उदाहरण

    >>> x[-2:10]
    array([8, 9])
    >>> x[-3:3:-1]
    array([7, 6, 5, 4])
    
  • मान लें कि आयाम में तत्वों की संख्या कटा हुआ है। फिर, अगर मुझे इसे ka 0 के लिए 0 और n - 1 के लिए 0 से डिफॉल्ट नहीं दिया जाता है। यदि j को k> 0 और n-1 को k <0 के लिए n डिफॉल्ट नहीं दिया जाता है। यदि k को यह डिफॉल्ट नहीं दिया जाता है तो 1. नोट करें कि :: समान है : और इस अक्ष के साथ सभी सूचकांकों का चयन करें।

    उदाहरण

    >>> x[5:]
    array([5, 6, 7, 8, 9])
    
  • यदि चयन टपल में वस्तुओं की संख्या N से कम है, तो : किसी भी बाद के आयामों के लिए मान लिया जाता है।

    उदाहरण

    >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
    >>> x.shape
    (2, 3, 1)
    >>> x[1:2]
    array([[[4],
            [5],
            [6]]])
    
  • Ellipsis की संख्या तक विस्तार किया गया : x.ndim के समान लंबाई के एक चयन टपल बनाने के लिए आवश्यक वस्तुओं। केवल एक एकल दीर्घवृत्त मौजूद हो सकता है।

    उदाहरण

    >>> x[...,0]
    array([[1, 2, 3],
           [4, 5, 6]])
    
  • चयन ट्यूपल में प्रत्येक newaxis ऑब्जेक्ट एक इकाई-लंबाई आयाम द्वारा परिणामी चयन के आयामों का विस्तार करने का कार्य करता है। जोड़ा गया आयाम चयन newaxis में newaxis ऑब्जेक्ट की स्थिति है।

    उदाहरण

    >>> x[:,np.newaxis,:,:].shape
    (2, 1, 3, 1)
    
  • पूर्णांक, i , समान मान लौटाता है जैसे i:i+1 लौटे हुए ऑब्जेक्ट की आयामीता को छोड़कर 1. 1 से घटाया जाता है। विशेष रूप से, p -th तत्व के साथ एक चयन ट्यूपल (और अन्य सभी प्रविष्टियाँ:) रिटर्न आयाम N - 1 के साथ संगत उप-सरणी। यदि एन = 1 है, तो लौटी हुई वस्तु एक सरणी स्केलर है। इन वस्तुओं को स्केलर्स में समझाया गया है।
  • यदि चयन टपल में सभी प्रविष्टियाँ हैं : p -th प्रविष्टि को छोड़कर जो एक स्लाइस ऑब्जेक्ट i:j:k , तो दिए गए सरणी में आयाम N है , जो तत्वों के पूर्णांक अनुक्रमण द्वारा लौटाए गए उप-सरणियों को समाहित करके i , k + है। ,…, I + (m - 1) k <j ,
  • एक से अधिक नॉन के साथ बेसिक स्लाइसिंग - स्लाइसिंग टुपल में एंट्री, एक ही नॉन- : एंट्री का उपयोग करते हुए बार-बार स्लाइसिंग के अनुप्रयोग की तरह कार्य करता है, जहां नॉन- : एंट्री को क्रमिक रूप से लिया जाता है (अन्य सभी नॉन- एंट्री के साथ : । इस प्रकार, x[ind1,...,ind2,:] x[ind1][...,ind2,:] तरह कार्य करता है।

    चेतावनी

    उन्नत अनुक्रमण के लिए उपरोक्त सही नहीं है।

  • आप सरणी में मान सेट करने के लिए स्लाइसिंग का उपयोग कर सकते हैं, लेकिन (सूचियों के विपरीत) आप सरणी को कभी नहीं बढ़ा सकते हैं। x[obj] = value में सेट होने वाले मान का आकार x[obj] = value के समान आकार में (प्रसारण योग्य) होना चाहिए।

ध्यान दें

याद रखें कि स्लाइसिंग ट्यूपल को हमेशा obj के रूप में बनाया जा सकता है और x[obj] नोटेशन में उपयोग किया जाता है। निर्माण में स्लाइस ऑब्जेक्ट का उपयोग [start:stop:step] नोटेशन के स्थान पर किया जा सकता है। उदाहरण के लिए, x[1:10:5,::-1] को obj = (slice(1,10,5), slice(None,None,-1)); x[obj] रूप में भी लागू किया जा सकता है obj = (slice(1,10,5), slice(None,None,-1)); x[obj] obj = (slice(1,10,5), slice(None,None,-1)); x[obj] । यह जेनेरिक कोड के निर्माण के लिए उपयोगी हो सकता है जो मनमाने आयाम के सरणियों पर काम करता है।

numpy.newaxis

लंबाई के एक अक्ष बनाने के लिए सभी स्लाइसिंग ऑपरेशंस में newaxis ऑब्जेक्ट का उपयोग किया जा सकता है। newaxis 'कोई नहीं' के लिए एक उपनाम है, और इसी परिणाम के साथ 'कोई नहीं' का उपयोग किया जा सकता है।

उन्नत अनुक्रमण

उन्नत अनुक्रमण तब चालू हो जाता है जब चयन ऑब्जेक्ट, obj , एक नॉन-टपल अनुक्रम ऑब्जेक्ट, एक ndarrays (डेटा प्रकार पूर्णांक या बूल का), या कम से कम एक अनुक्रम ऑब्जेक्ट या ndarray (डेटा प्रकार पूर्णांक या बूल) के साथ एक tuple है। उन्नत अनुक्रमण के दो प्रकार हैं: पूर्णांक और बूलियन।

उन्नत अनुक्रमण हमेशा डेटा की एक प्रति लौटाता है (मूल स्लाटिंग के साथ विपरीत जो एक views लौटाता है)।

चेतावनी

उन्नत अनुक्रमण की परिभाषा का अर्थ है कि x[(1,2,3),] x[(1,2,3)] तुलना में मौलिक रूप से भिन्न है। उत्तरार्द्ध x[1,2,3] बराबर है जो मूल चयन को ट्रिगर करेगा जबकि पूर्व उन्नत अनुक्रमण को ट्रिगर करेगा। यह समझना सुनिश्चित करें कि ऐसा क्यों होता है।

यह भी पहचानें कि x[[1,2,3]] एडवांस इंडेक्सिंग को ट्रिगर करेगा, जबकि x[[1,2,slice(None)]] बेसिक स्लिंगिंग को ट्रिगर करेगा।

पूर्णांक अनुक्रमणिका

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

विशुद्ध रूप से पूर्णांक सरणी अनुक्रमण

जब अनुक्रमणिका में कई पूर्णांक सरणियाँ होती हैं, तो अनुक्रमित होने वाले सरणी में आयाम होते हैं, अनुक्रमण सीधे आगे होता है, लेकिन स्लाइसिंग से अलग होता है।

उन्नत सूचकांक हमेशा एक के रूप में broadcast और broadcast होते हैं:

result[i_1, ..., i_M] == x[ind_1[i_1, ..., i_M], ind_2[i_1, ..., i_M],
                           ..., ind_N[i_1, ..., i_M]]

ध्यान दें कि परिणाम आकृति समान (प्रसारण) अनुक्रमण सरणी आकृतियों के ind_1, ..., ind_N

उदाहरण

प्रत्येक पंक्ति से, एक विशिष्ट तत्व का चयन किया जाना चाहिए। पंक्ति इंडेक्स सिर्फ [0, 1, 2] और कॉलम इंडेक्स संबंधित पंक्ति को चुनने के लिए तत्व को निर्दिष्ट करता है, यहाँ [0, 1, 0] । दोनों को एक साथ उपयोग करके कार्य को उन्नत अनुक्रमण के उपयोग से हल किया जा सकता है:

>>> x = np.array([[1, 2], [3, 4], [5, 6]])
>>> x[[0, 1, 2], [0, 1, 0]]
array([1, 4, 5])

ऊपर दी गई बुनियादी स्लाइसिंग के समान व्यवहार प्राप्त करने के लिए, प्रसारण का उपयोग किया जा सकता है। फ़ंक्शन ix_ इस प्रसारण के साथ मदद कर सकता है। यह एक उदाहरण के साथ सबसे अच्छा समझा जाता है।

उदाहरण

4x3 सरणी से कोने तत्वों को उन्नत अनुक्रमण का उपयोग करके चुना जाना चाहिए। इस प्रकार सभी तत्व जिनके लिए कॉलम [0, 2] से एक है और पंक्ति [0, 3] से एक है [0, 3] को चुने जाने की आवश्यकता है। उन्नत अनुक्रमण का उपयोग करने के लिए सभी तत्वों को स्पष्ट रूप से चुनने की आवश्यकता है। पहले बताई गई विधि का उपयोग करके लिख सकते हैं:

>>> x = array([[ 0,  1,  2],
...            [ 3,  4,  5],
...            [ 6,  7,  8],
...            [ 9, 10, 11]])
>>> rows = np.array([[0, 0],
...                  [3, 3]], dtype=np.intp)
>>> columns = np.array([[0, 2],
...                     [0, 2]], dtype=np.intp)
>>> x[rows, columns]
array([[ 0,  2],
       [ 9, 11]])

हालाँकि, चूंकि ऊपर दिए गए अनुक्रमणिका सरणियाँ बस खुद को दोहराते हैं, इसलिए प्रसारण को सरल बनाया जा सकता है (इसे सरल बनाने के लिए rows[:, np.newaxis] + columns जैसे rows[:, np.newaxis] + columns तुलना करें।

>>> rows = np.array([0, 3], dtype=np.intp)
>>> columns = np.array([0, 2], dtype=np.intp)
>>> rows[:, np.newaxis]
array([[0],
       [3]])
>>> x[rows[:, np.newaxis], columns]
array([[ 0,  2],
       [ 9, 11]])

फ़ंक्शन ix_ का उपयोग करके भी यह प्रसारण प्राप्त किया जा सकता है:

>>> x[np.ix_(rows, columns)]
array([[ 0,  2],
       [ 9, 11]])

ध्यान दें कि np.ix_ कॉल के बिना, केवल विकर्ण तत्वों का चयन किया जाएगा, जैसा कि पिछले उदाहरण में उपयोग किया गया था। यह अंतर कई उन्नत अनुक्रमित के साथ अनुक्रमण के बारे में याद रखने के लिए सबसे महत्वपूर्ण बात है।

उन्नत और बुनियादी अनुक्रमण का संयोजन

जब सूचकांक में कम से कम एक टुकड़ा ( np.newaxis , दीर्घवृत्त ( ... ) या np.newaxis होता है (या सरणी में अधिक आयाम हैं जहां उन्नत अनुक्रमित हैं), तो व्यवहार अधिक जटिल हो सकता है। यह प्रत्येक उन्नत सूचकांक तत्व के लिए अनुक्रमण परिणाम को समेटने जैसा है

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

उदाहरण

>>> x[1:2, 1:3]
array([[4, 5]])
>>> x[1:2, [1, 2]]
array([[4, 5]])

स्थिति को समझने का सबसे आसान तरीका परिणाम आकार के संदर्भ में सोचना हो सकता है। अनुक्रमण ऑपरेशन के दो भाग हैं, मूल अनुक्रमण द्वारा पूर्णांक (पूर्णांक को छोड़कर) और उन्नत अनुक्रमण भाग से उप-भाग को परिभाषित किया गया है। सूचकांक संयोजन के दो मामलों को प्रतिष्ठित करने की आवश्यकता है:

  • उन्नत सूचकांक एक स्लाइस, एलिप्सिस या न्यूमैक्सिस द्वारा अलग किए जाते हैं। उदाहरण के लिए x[arr1, :, arr2]
  • उन्नत सूचकांक सभी एक दूसरे के बगल में हैं। उदाहरण के लिए x[..., arr1, arr2, :] लेकिन x[arr1, :, 1] नहीं x[arr1, :, 1] चूंकि 1 इस संबंध में एक उन्नत सूचकांक है।

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

उदाहरण

मान लीजिए कि x.shape (10,20,30) है और ind एक (2,3,4) है, इंडेक्सिंग intp ऐरे, तो result = x[...,ind,:] :: result = x[...,ind,:] का आकार है (10,2,3) , 4,30) क्योंकि (20,) - आकार के उप-स्थान को (2,3,4) -प्रकाशित अनुक्रमित उप-भाग के साथ बदल दिया गया है। अगर हम (२ , ३, ४ ) के उप-भाग को आइ-जे, k लूप करते हैं, तो result[...,i,j,k,:] = x[...,ind[i,j,k],:] । यह उदाहरण x.take(ind, axis=-2) के समान परिणाम देता है।

उदाहरण

मान लें कि x.shape (10,20,30,40,50) है और मान लें कि ind_1 और ind_2 को आकार (2,3,4) में प्रसारित किया जा सकता है। तब x[:,ind_1,ind_2] का आकार (10,2,3,4,40,50) है क्योंकि X से (20,30) आकार के उप-स्थान को (2,3,4) से उप-स्थान से बदल दिया गया है सूचकांकों। हालाँकि, x[:,ind_1,:,ind_2] का आकार (2,3,4,10,30,50) है क्योंकि अनुक्रमणिका उप-स्थान में छोड़ने के लिए कोई भी अस्पष्ट स्थान नहीं है, इस प्रकार यह शुरू में ही निपट जाता है। हमेशा वांछित कहीं भी उप-चाल को स्थानांतरित करने के लिए .transpose() का उपयोग करना संभव है। ध्यान दें कि इस उदाहरण का उपयोग करके दोहराया नहीं जा सकता है।

बूलियन सरणी अनुक्रमण

यह उन्नत अनुक्रमण तब होता है जब obj बूलियन प्रकार का एक सरणी ऑब्जेक्ट होता है, जैसे कि तुलना ऑपरेटरों से वापस किया जा सकता है। एक एकल बूलियन इंडेक्स सरणी व्यावहारिक रूप से x[obj.nonzero()] समान है, जहां, जैसा कि ऊपर वर्णित है, obj.nonzero() एक पूर्णांक obj.ndim (पूर्णांक obj.ndim ) पूर्णांक इंडेक्स obj.ndim के obj के True तत्वों को दर्शाता है। हालाँकि, यह तेज है जब obj.shape == x.shape

यदि obj.ndim == x.ndim , x[obj] एक 1-आयामी सरणी देता है जो x के तत्वों से भरा होता है जो obj के True मूल्यों के अनुरूप होता है। खोज क्रम row-major , सी-शैली होगा। यदि obj में x की सीमा के बाहर मौजूद प्रविष्टियों पर True मान है, तो एक इंडेक्स एरर उठाया जाएगा। यदि obj x से छोटा है, तो इसे False साथ भरने के समान है।

उदाहरण

इसके लिए एक सामान्य उपयोग मामला वांछित तत्व मूल्यों के लिए फ़िल्टरिंग है। उदाहरण के लिए, एक सरणी से सभी प्रविष्टियों का चयन करना चाह सकते हैं जो NaN नहीं हैं:

>>> x = np.array([[1., 2.], [np.nan, 3.], [np.nan, np.nan]])
>>> x[~np.isnan(x)]
array([ 1.,  2.,  3.])

या सभी नकारात्मक तत्वों में एक निरंतर जोड़ना चाहते हैं:

>>> x = np.array([1., -1., -2., 3])
>>> x[x < 0] += 20
>>> x
array([  1.,  19.,  18.,   3.])

सामान्य तौर पर यदि एक सूचकांक में बूलियन सरणी शामिल है, तो परिणाम एक ही स्थिति में obj.nonzero() डालने और ऊपर वर्णित पूर्णांक सरणी अनुक्रमण तंत्र का उपयोग करने के समान होगा। x[ind_1, boolean_array, ind_2] x[(ind_1,) + boolean_array.nonzero() + (ind_2,)]

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

उदाहरण

एक सरणी से, उन सभी पंक्तियों का चयन करें जो दो या दो के बराबर होती हैं:

>>> x = np.array([[0, 1], [1, 1], [2, 2]])
>>> rowsum = x.sum(-1)
>>> x[rowsum <= 2, :]
array([[0, 1],
       [1, 1]])

लेकिन अगर rowsum दो आयाम होंगे:

>>> rowsum = x.sum(-1, keepdims=True)
>>> rowsum.shape
(3, 1)
>>> x[rowsum <= 2, :]    # fails
IndexError: too many indices
>>> x[rowsum <= 2]
array([0, 1])

अतिरिक्त आयाम के कारण केवल पहला तत्व देने वाला अंतिम। इस उदाहरण को समझने के लिए rowsum.nonzero() तुलना करें।

कई बूलियन अनुक्रमण सरणियों या एक पूर्णांक अनुक्रमण सरणी के साथ बूलियन के संयोजन को सबसे अच्छी तरह से obj.nonzero() सादृश्य के साथ समझा जा सकता है। फ़ंक्शन ix_ बूलियन सरणियों का भी समर्थन करता है और बिना किसी आश्चर्य के काम करेगा।

उदाहरण

एक समान संख्या तक जोड़ने वाली सभी पंक्तियों का चयन करने के लिए बूलियन इंडेक्सिंग का उपयोग करें। उसी समय कॉलम 0 और 2 को एक उन्नत पूर्णांक सूचकांक के साथ चुना जाना चाहिए। इसके साथ ix_ फ़ंक्शन का उपयोग किया जा सकता है:

>>> x = array([[ 0,  1,  2],
...            [ 3,  4,  5],
...            [ 6,  7,  8],
...            [ 9, 10, 11]])
>>> rows = (x.sum(-1) % 2) == 0
>>> rows
array([False,  True, False,  True])
>>> columns = [0, 2]
>>> x[np.ix_(rows, columns)]
array([[ 3,  5],
       [ 9, 11]])

np.ix_ कॉल के बिना या केवल विकर्ण तत्वों का चयन किया जाएगा।

या बिना np.ix_ (पूर्णांक सरणी उदाहरणों की तुलना करें):

>>> rows = rows.nonzero()[0]
>>> x[rows[:, np.newaxis], columns]
array([[ 3,  5],
       [ 9, 11]])

विस्तृत नोट

ये कुछ विस्तृत नोट हैं, जो दिन-प्रतिदिन के अनुक्रमण (किसी विशेष क्रम में) के लिए महत्व के नहीं हैं:

  • मूल NumPy अनुक्रमण प्रकार intp और डिफ़ॉल्ट पूर्णांक सरणी प्रकार से भिन्न हो सकता है। intp किसी भी सरणी को सुरक्षित रूप से अनुक्रमित करने के लिए सबसे छोटा डेटा प्रकार है; उन्नत अनुक्रमण के लिए यह अन्य प्रकारों की तुलना में तेज़ हो सकता है।
  • उन्नत असाइनमेंट के लिए, पुनरावृत्ति क्रम के लिए सामान्य रूप से कोई गारंटी नहीं है। इसका मतलब यह है कि यदि कोई तत्व एक से अधिक बार सेट किया गया है, तो अंतिम परिणाम की भविष्यवाणी करना संभव नहीं है।
  • एक खाली (ट्यूपल) सूचकांक एक शून्य स्केल सरणी में पूर्ण स्केलर सूचकांक है। x[()] एक स्केलर लौटाता है यदि x शून्य आयामी है और एक दृश्य अन्यथा। दूसरी ओर x[...] हमेशा एक दृश्य देता है।
  • यदि एक शून्य आयामी सरणी सूचकांक में मौजूद है और यह पूर्ण पूर्णांक सूचकांक है तो परिणाम एक स्केलर होगा न कि एक शून्य आयामी सरणी। (उन्नत अनुक्रमण ट्रिगर नहीं किया गया है।)
  • जब एक दीर्घवृत्त ( ... ) मौजूद है, लेकिन उसका कोई आकार नहीं है (अर्थात शून्य को प्रतिस्थापित करता है) तो परिणाम अभी भी हमेशा एक सरणी होगा। एक दृश्य यदि कोई उन्नत सूचकांक मौजूद नहीं है, अन्यथा एक प्रति।
  • बूलियन सरणियों के लिए nonzero शून्य आयामी बूलियन सरणियों के लिए पकड़ नहीं है।
  • जब एक उन्नत अनुक्रमण ऑपरेशन के परिणाम में कोई तत्व नहीं होता है, लेकिन एक इंडेक्स सीमा से बाहर होता है, तो IndexError उठाया जाता है या नहीं, अपरिभाषित है (जैसे x[[], [123]] 123 सीमाओं के बाहर होने के साथ)।
  • जब असाइनमेंट के दौरान एक कास्टिंग त्रुटि होती है (उदाहरण के लिए एक अनुक्रम का उपयोग करके स्ट्रिंग के अनुक्रम का उपयोग करके), सरणी को असाइन किया जा रहा अनपेक्षित रूप से आंशिक रूप से अद्यतन स्थिति में समाप्त हो सकता है। हालाँकि, यदि कोई अन्य त्रुटि (जैसे कि सीमा सूचकांक से बाहर) होती है, तो सरणी अपरिवर्तित रहेगी।
  • एक उन्नत अनुक्रमण परिणाम का मेमोरी लेआउट प्रत्येक अनुक्रमण ऑपरेशन के लिए अनुकूलित है और कोई विशेष मेमोरी ऑर्डर ग्रहण नहीं किया जा सकता है।
  • एक उपवर्ग (विशेष रूप से जो इसके आकार में हेरफेर करता है) का उपयोग करते समय, डिफ़ॉल्ट ndarray.__setitem__ व्यवहार बुनियादी अनुक्रमण के लिए __getitem__ को कॉल __getitem__ , लेकिन उन्नत अनुक्रमण के लिए नहीं। ऐसे उपवर्ग के लिए डेटा पर बेस क्लास ndarray.__setitem__ साथ ndarray.__setitem__ को कॉल करना बेहतर हो सकता है। यह किया जाना चाहिए यदि उपवर्ग __getitem__ विचारों को वापस नहीं करता है।

फील्ड एक्सेस

यदि ndarrays ऑब्जेक्ट एक संरचित सरणी है, तो सरणी के फ़ील्ड को स्ट्रिंग, शब्दकोश-जैसे सरणी को अनुक्रमित करके एक्सेस किया जा सकता है।

इंडेक्सिंग x['field-name'] ऐरे को एक नया views देता है, जो एक्स के समान आकार का होता है (सिवाय जब फ़ील्ड सब-एरे होता है) लेकिन डेटा टाइप x.dtype['field-name'] और निर्दिष्ट क्षेत्र में डेटा का केवल हिस्सा होता है। इस तरह से रिकॉर्ड सरणी स्केलर को "अनुक्रमित" किया जा सकता है।

संरचित सरणी में अनुक्रमण को फ़ील्ड नामों की सूची के साथ भी किया जा सकता है, जैसे x[['field-name1','field-name2']] । वर्तमान में यह एक नया सरणी देता है जिसमें सूची में निर्दिष्ट फ़ील्ड में मानों की एक प्रति है। NumPy 1.7 के अनुसार, एक प्रति लौटाने को एक दृश्य वापस करने के पक्ष में पदावनत किया जा रहा है। एक प्रति अभी के लिए लौटा दी जाएगी, लेकिन कॉपी लिखते समय FutureWarning जारी किया जाएगा। यदि आप वर्तमान व्यवहार पर निर्भर करते हैं, तो हम सुझाए गए सरणी को स्पष्ट रूप से कॉपी करने का सुझाव देते हैं, अर्थात x [['फ़ील्ड-नेम 1', 'फ़ील्ड-नेम 2'] का उपयोग करें। कॉपी ()। यह NumPy के भूत और भविष्य दोनों संस्करणों के साथ काम करेगा।

यदि एक्सेस फ़ील्ड एक उप-सरणी है, तो परिणाम के आकार में उप-सरणी के आयामों को जोड़ दिया जाता है।

उदाहरण

>>> x = np.zeros((2,2), dtype=[('a', np.int32), ('b', np.float64, (3,3))])
>>> x['a'].shape
(2, 2)
>>> x['a'].dtype
dtype('int32')
>>> x['b'].shape
(2, 2, 3, 3)
>>> x['b'].dtype
dtype('float64')

फ्लैट Iterator अनुक्रमण

x.flat एक x.flat लौटाता है जो संपूर्ण सरणी पर (सी-सन्निहित शैली में अंतिम अनुक्रमणिका सबसे तेज़ बदलती है) से पुनरावृति करेगा। जब तक चयन ऑब्जेक्ट टुप नहीं होता है, तब तक इस स्लाटर ऑब्जेक्ट को बेसिक स्लाइसिंग या एडवांस्ड इंडेक्सिंग का उपयोग करके अनुक्रमित किया जा सकता है। यह इस तथ्य से स्पष्ट होना चाहिए कि x.flat 1-आयामी दृश्य है। इसका उपयोग 1-आयामी सी-स्टाइल-फ्लैट सूचक के साथ पूर्णांक अनुक्रमण के लिए किया जा सकता है। किसी भी दिए गए सरणी का आकार इसलिए पूर्णांक अनुक्रमण वस्तु का आकार है।