NumPy सरणी से पंक्ति-वार तत्वों का चयन कैसे करें?

Question

मैं इस numpy सरणी

dd= [[foo 0.567 0.611] 
    [bar 0.469 0.479] 
    [noo 0.220 0.269] 
    [tar 0.480 0.508] 
    [boo 0.324 0.324]] 

की तरह एक सरणी कैसे foo का चयन करके और 0.567 0.611 एक सिंगलटन के रूप में तैरता के रूप में हो रही सरणी के माध्यम से एक पाश होगा। तब चयन बार और 0.469 0.479 एक सिंगलटन के रूप में तैरता के रूप में हो रही है .....

मैं

dv= dd[:,1] 

'foo' का उपयोग करके वेक्टर सूची के रूप में पहली तत्व मिल सकता है, और 'बार' तत्वों अज्ञात चर नहीं हैं, वे बदल सकते हैं।

यदि तत्व स्थिति में है तो मैं कैसे बदलूं [1]?

[[0.567 foo2 0.611] 
    [0.469 bar2 0.479] 
    [0.220 noo2 0.269] 
    [0.480 tar2 0.508] 
    [0.324 boo2 0.324]] 

Answer 1

आप अपने सवाल पर NumPy टैग डाल दिया है, तो मैं ' मान लेंगे कि आप NumPy वाक्यविन्यास चाहते हैं, जो मेरे सामने जवाब का उपयोग नहीं करता है।

यदि वास्तव में आप NumPy का उपयोग करना चाहते हैं, तो संभवतः आप अपने सरणी में तार नहीं चाहते हैं, अन्यथा आपको स्ट्रिंग्स के रूप में अपनी फ्लोट का प्रतिनिधित्व करना होगा।

आप के लिए क्या देख रहे हैं पंक्ति करके 2D सरणी के तत्वों का उपयोग (और पहले स्तंभ को बाहर) को NumPy वाक्य रचना है।

वाक्य रचना है: अपने Question-- में

M[row_index,1:]  # selects all but 1st col from row given by 'row_index' 

डब्ल्यू/आर/दूसरे परिदृश्य टी का चयन गैर सन्निकट स्तंभ:

M[row_index,[0,2]]  # selects 1st & 3rd cols from row given by 'row_index' 

में छोटे जटिलता आपका प्रश्न यह है कि आप row_index के लिए एक स्ट्रिंग का उपयोग करना चाहते हैं, इसलिए स्ट्रिंग को निकालना आवश्यक है (ताकि आप फ्लोट्स की 2 डी न्यूमपी सरणी बना सकें), उन्हें संख्यात्मक के साथ बदलें पंक्ति सूचियों और फिर संख्यात्मक पंक्ति सूचकों साथ तार मैप करने के लिए एक लुक-अप तालिका बनाने:

>>> import numpy as NP 
>>> # create a look-up table so you can remove the strings from your python nested list, 
>>> # which will allow you to represent your data as a 2D NumPy array with dtype=float 
>>> keys 
     ['foo', 'bar', 'noo', 'tar', 'boo'] 
>>> values # 1D index array comprised of one float value for each unique string in 'keys' 
     array([0., 1., 2., 3., 4.]) 
>>> LuT = dict(zip(keys, values)) 

>>> # add an index to data by inserting 'values' array as first column of the data matrix 
>>> A = NP.hstack((vals, A)) 
>>> A 
     NP.array([ [ 0., .567, .611], 
        [ 1., .469, .479], 
        [ 2., .22, .269], 
        [ 3., .48, .508], 
        [ 4., .324, .324] ]) 

>>> # so now to look up an item, by 'key': 
>>> # write a small function to perform the look-ups: 
>>> def select_row(key): 
     return A[LuT[key],1:] 

>>> select_row('foo') 
     array([ 0.567, 0.611]) 

>>> select_row('noo') 
     array([ 0.22 , 0.269]) 

अपने प्रश्न में दूसरे परिदृश्य: क्या हुआ अगर सूचकांक कॉलम परिवर्तन?

>>> # e.g., move index to column 1 (as in your Q) 
>>> A = NP.roll(A, 1, axis=1) 
>>> A 
     array([[ 0.611, 1. , 0.567], 
      [ 0.479, 2. , 0.469], 
      [ 0.269, 3. , 0.22 ], 
      [ 0.508, 4. , 0.48 ], 
      [ 0.324, 5. , 0.324]]) 

>>> # the original function is changed slightly, to select non-adjacent columns: 
>>> def select_row2(key): 
     return A[LuT[key],[0,2]] 

>>> select_row2('foo') 
     array([ 0.611, 0.567]) 

Answer 2

पहले, पहले तत्वों की वेक्टर है

dv = dd[:,0] 

(अजगर है 0 अनुक्रमित)

दूसरा, सरणी चलने के लिए (और एक dict में दुकान, उदाहरण के लिए) आप लिखें:

dc = {} 
ind = 0 # this corresponds to the column with the names 
for row in dd: 
    dc[row[ind]] = row[1:]