सूचियों और सरणियों के साथ numpy सरणी अनुक्रमण

Question

मेरे पास है:

>>> a 
array([[1, 2], 
     [3, 4]]) 

>>> type(l), l # list of scalers 
(<type 'list'>, [0, 1]) 

>>> type(i), i # a numpy array 
(<type 'numpy.ndarray'>, array([0, 1])) 

>>> type(j), j # list of numpy arrays 
(<type 'list'>, [array([0, 1]), array([0, 1])]) 

जब मैं

>>> a[l] # Case 1, l is a list of scalers 

कर रहा

array([[1, 2], 
     [3, 4]]) 

जिसका अर्थ है अनुक्रमण 0 अक्ष पर केवल हुआ मिलता है।

लेकिन मैं

array([1, 4]) 

जिसका अर्थ है अनुक्रमण अक्ष 0 और अक्ष 1 साथ हुआ मिलता है जब मैं

>>> a[j] # Case 2, j is a list of numpy arrays 

है।

प्रश्न 1: जब अनुक्रमण के लिए उपयोग किया जाता है, तो स्केलर्स की सूची और numpy arrays की सूची के उपचार में कोई अंतर क्यों है? (केस 1 बनाम केस 2)। केस 2 में, मैं अनुक्रमण केवल अक्ष 0 के साथ हुआ देख सकते हैं और

array([[[1,2], 
      [3,4]], 

     [[1,2], 
     [3,4]]]) 

पाने के लिए उम्मीद कर रही थी अब, जब बजाय

>>> j1 = np.array(j) # numpy array of arrays 

परिणाम के नीचे इंगित करता है कि अनुक्रमण केवल साथ हुआ सरणियों के numpy सरणी का उपयोग कर अक्ष 0 (अपेक्षित रूप से)

>>> a[j1] Case 3, j1 is a numpy array of numpy arrays 
array([[[1, 2], 
     [3, 4]], 

     [[1, 2], 
     [3, 4]]]) 

Q2: जब अनुक्रमण के लिए उपयोग किया जाता है, यही कारण है कि NumPy सरणी की सूची और के उपचार में एक अंतर है n numpy arrays की अजीब सरणी? (केस 2 बनाम केस 3)

Answer 1

केस 1, a[l] वास्तव में a[(l,)] है जो a[(l, slice(None))] तक फैला हुआ है। यही है, सूची l के साथ पहले आयाम को अनुक्रमणित करना, और स्वत: पीछे : टुकड़ा। इंडेक्स को __getitem__ में एक टुपल के रूप में पास किया जाता है, और अतिरिक्त () भ्रम के बिना जोड़ा जा सकता है।

केस 2, a[j] को a[array([0, 1]), array([0, 1]] या a[(array(([0, 1]), array([0, 1])] के रूप में माना जाता है। दूसरे शब्दों में, अनुक्रमण वस्तुओं के एक tuple के रूप में, एक प्रति आयाम। यह a[0,0] और a[1,1] लौटने पर समाप्त होता है।

केस 3, a[j1]a[(j1, slice(None))] है, जो पहले आयाम में j1 अनुक्रमणिका लागू कर रहा है।

केस 2 किसी भी विसंगति का थोड़ा सा है। आपका अंतर्ज्ञान मान्य है, लेकिन ऐतिहासिक कारणों से, सरणी की सूची (या सूचियों की सूची) को सरणी के टुपल के रूप में व्याख्या किया जाता है।

इस पर अन्य SO प्रश्नों पर चर्चा की गई है, और मुझे लगता है कि यह दस्तावेज है। लेकिन हाथ से मैं उन संदर्भों को नहीं ढूंढ सकता।

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

---

numpy array indexing: list index and np.array index give different result

यह तो सवाल ही इस मुद्दे पर छू लेती है, हालांकि क्या हो रहा है @ user2357112 द्वारा एक टिप्पणी में एक कोड लिंक में दफनाया गया है की स्पष्ट बयान।

अनुक्रमण तरह Case3 मजबूर कर का एक और तरीका, 2 आयाम टुकड़ा स्पष्ट करना, a[j,:]

In [166]: a[j] 
Out[166]: array([1, 4]) 
In [167]: a[j,:] 
Out[167]: 
array([[[1, 2], 
     [3, 4]], 

     [[1, 2], 
     [3, 4]]]) 

(मैं अक्सर अनुगामी : भले ही यह आवश्यक नहीं है शामिल हैं। यह यह मेरे लिए स्पष्ट करता है, और पाठकों, हम कितने आयामों के साथ काम कर रहे हैं।)

Answer 2

ए 1: l की संरचना j जैसी नहीं है।

l केवल एक आयाम है जबकि j दो-आयाम है। यदि आप उनमें से एक को बदलते हैं:

# l = [0, 1]         # just one dimension! 
l = [[0, 1], [0, 1]]       # two dimensions 
j = [np.array([0,1]), np.array([0, 1])]  # two dimensions 

उनके समान व्यवहार है।

ए 2: वही, केस 2 और केस 3 में सरणी की संरचना समान नहीं है।