दिलचस्प पोस्ट
मैं मोंगोडीबी में Node.js का उपयोग कर कर्सर का उपयोग कैसे कर सकता हूं? संदर्भ प्रकार के लिए sizeof () समकक्ष? एकाधिक डेटाबेस पर इकाई ढांचे का उपयोग करना क्या रेज़र के साथ एक सामान्य @ हाल्पर विधि बनाना संभव है? नवीनतम गैर-एनए मूल्य के साथ एनएएस की जगह संरचना के लिए सूचक सूचक सी टाइप किया हुआ खिड़की। विकल्प विकल्प Matplotlib में गैर- ASCII वर्ण सी ++ 11 में बदलावों को किस प्रकार से बदल दिया जाता है? CSS के साथ स्वरूपण संख्या (दशमलव स्थान, हजारों विभाजक, आदि) Gradle बिल्ड टूल का उपयोग करके एंड्रॉइड स्टूडियो में ओपनसीवी का उपयोग कैसे करें? PHP कोड रिफैक्टरिंग के लिए उपकरण फ़ाइल को स्विफ्ट में कैसे डाउनलोड करें? फाइलें डाउनलोड करें और उन्हें स्थानीय रूप से फोनगैप / jQuery मोबाइल एंड्रॉइड और आईओएस एप्स के साथ स्टोर करें रिकर्सिव समूह सदस्यता (सक्रिय निर्देशिका) सी # का उपयोग कर खोजें

कैसे एक numpy सरणी में एक अतिरिक्त कॉलम जोड़ने के लिए

चलो कहना है कि मेरे पास एक numpy array a :

 a = np.array([[1,2,3], [2,3,4]]) 

और मैं सरणी को पाने के लिए शून्य के एक स्तंभ को जोड़ना चाहूंगा:

 b = np.array([[1,2,3,0], [2,3,4,0]]) 

मैं यह कैसे आसानी से numpy में कर सकता हूँ?

Solutions Collecting From Web of "कैसे एक numpy सरणी में एक अतिरिक्त कॉलम जोड़ने के लिए"

मुझे लगता है कि एक और सीधा समाधान और बूट करने के लिए तेज़ी से निम्न कार्य करना है:

 import numpy as np N = 10 a = np.random.rand(N,N) b = np.zeros((N,N+1)) b[:,:-1] = a 

और समय:

 In [23]: N = 10 In [24]: a = np.random.rand(N,N) In [25]: %timeit b = np.hstack((a,np.zeros((a.shape[0],1)))) 10000 loops, best of 3: 19.6 us per loop In [27]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a 100000 loops, best of 3: 5.62 us per loop 

np.r_[ ... ] और np.c_[ ... ] vstack और hstack लिए उपयोगी विकल्प हैं, गोल के बजाय () वर्ग कोष्ठक के साथ
कुछ उदाहरण:

 : import numpy as np : N = 3 : A = np.eye(N) : np.c_[ A, np.ones(N) ] # add a column array([[ 1., 0., 0., 1.], [ 0., 1., 0., 1.], [ 0., 0., 1., 1.]]) : np.c_[ np.ones(N), A, np.ones(N) ] # or two array([[ 1., 1., 0., 0., 1.], [ 1., 0., 1., 0., 1.], [ 1., 0., 0., 1., 1.]]) : np.r_[ A, [A[1]] ] # add a row array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.], [ 0., 1., 0.]]) : # not np.r_[ A, A[1] ] : np.r_[ A[0], 1, 2, 3, A[1] ] # mix vecs and scalars array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.]) : np.r_[ A[0], [1, 2, 3], A[1] ] # lists array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.]) : np.r_[ A[0], (1, 2, 3), A[1] ] # tuples array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.]) : np.r_[ A[0], 1:4, A[1] ] # same, 1:4 == arange(1,4) == 1,2,3 array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.]) 

(राउंड के बजाय स्क्वायर ब्रैकेट [] का कारण यह है कि अजगर का विस्तार स्क्वायर जैसे 1: 4 में होता है – ओवरलोडिंग के चमत्कार।)

numpy.append उपयोग करें:

 >>> a = np.array([[1,2,3],[2,3,4]]) >>> a array([[1, 2, 3], [2, 3, 4]]) >>> z = np.zeros((2,1), dtype=int64) >>> z array([[0], [0]]) >>> np.append(a, z, axis=1) array([[1, 2, 3, 0], [2, 3, 4, 0]]) 

सवाल लिखते समय मैं एक तरह से आया, hstack का उपयोग कर

 b = np.hstack((a, np.zeros((a.shape[0], 1), dtype=a.dtype))) 

कोई अन्य (अधिक सुरुचिपूर्ण समाधान) स्वागत है!

मुझे लगता है:

 np.column_stack((a, zeros(shape(a)[0]))) 

अधिक सुरुचिपूर्ण है

मुझे जो सबसे अधिक आकर्षक लगता है वह निम्नलिखित है:

 b = np.insert(a, 3, values=0, axis=1) # insert values before column 3 

insert का एक फायदा यह है कि यह आपको सरणी के भीतर अन्य स्थानों पर कॉलम (या पंक्तियों) को सम्मिलित करने की अनुमति देता है। इसके अलावा एक एकल मूल्य डालने के बजाय आप पूरी तरह से एक सदिश सम्मिलित कर सकते हैं, उदाहरण के लिए अंतिम कॉलम को दोहराएं:

 b = np.insert(a, insert_index, values=a[:,2], axis=1) 

जिससे होता है:

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

समय के लिए, जोशएडेल के समाधान से insert हो सकता है धीमा:

 In [1]: N = 10 In [2]: a = np.random.rand(N,N) In [3]: %timeit b = np.hstack((a,np.zeros((a.shape[0],1)))) 100000 loops, best of 3: 7.5 us per loop In [4]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a 100000 loops, best of 3: 2.17 us per loop In [5]: %timeit b = np.insert(a, 3, values=0, axis=1) 100000 loops, best of 3: 10.2 us per loop 

मैं भी इस सवाल में दिलचस्पी थी और की गति की तुलना में

 numpy.c_[a, a] numpy.stack([a, a]).T numpy.vstack([a, a]).T numpy.ascontiguousarray(numpy.stack([a, a]).T) numpy.ascontiguousarray(numpy.vstack([a, a]).T) numpy.column_stack([a, a]) numpy.concatenate([a[:,None], a[:,None]], axis=1) numpy.concatenate([a[None], a[None]], axis=0).T 

जो सभी किसी भी इनपुट वेक्टर के लिए a ही काम करते हैं a । बढ़ते समय के लिए:

यहां छवि विवरण दर्ज करें

ध्यान दें कि सभी vstack रूपों (विशेष रूप से / vstack / vstack ) सभी निकटवर्ती रूपों की तुलना में अंततः तेज़ हैं। column_stack (इसकी स्पष्टता और गति के लिए) एक अच्छा विकल्प प्रतीत होता है यदि आपको column_stack आवश्यकता होती है


साजिश को पुन: उत्पन्न करने के लिए कोड:

 import numpy import perfplot perfplot.show( setup=lambda n: numpy.random.rand(n), kernels=[ lambda a: numpy.c_[a, a], lambda a: numpy.ascontiguousarray(numpy.stack([a, a]).T), lambda a: numpy.ascontiguousarray(numpy.vstack([a, a]).T), lambda a: numpy.column_stack([a, a]), lambda a: numpy.concatenate([a[:, None], a[:, None]], axis=1), lambda a: numpy.ascontiguousarray(numpy.concatenate([a[None], a[None]], axis=0).T), lambda a: numpy.stack([a, a]).T, lambda a: numpy.vstack([a, a]).T, lambda a: numpy.concatenate([a[None], a[None]], axis=0).T, ], labels=[ 'c_', 'ascont(stack)', 'ascont(vstack)', 'column_stack', 'concat', 'ascont(concat)', 'stack (non-cont)', 'vstack (non-cont)', 'concat (non-cont)' ], n_range=[2**k for k in range(20)], xlabel='len(a)', logx=True, logy=True, ) 

np.concatenate भी काम करता है

 >>> a = np.array([[1,2,3],[2,3,4]]) >>> a array([[1, 2, 3], [2, 3, 4]]) >>> z = np.zeros((2,1)) >>> z array([[ 0.], [ 0.]]) >>> np.concatenate((a, z), axis=1) array([[ 1., 2., 3., 0.], [ 2., 3., 4., 0.]]) 

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

 In [1]: import numpy as np In [2]: N = 10000 In [3]: a = np.ones((N,N)) In [4]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a 1 loops, best of 3: 492 ms per loop In [5]: %timeit b = np.empty((a.shape[0],a.shape[1]+1)); b[:,:-1] = a; b[:,-1] = np.zeros((a.shape[0],)) 1 loops, best of 3: 407 ms per loop 

M को मानते हुए (100,3) ndarray और y एक (100,) ndarray append का उपयोग निम्नानुसार किया जा सकता है:

 M=numpy.append(M,y[:,None],1) 

उपयोग करने के लिए चाल है

 y[:, None] 

यह y को एक (100, 1) 2 डी सरणी में कनवर्ट करता है।

 M.shape 

अब देता है

 (100, 4) 

पार्टी के लिए थोड़ी देर हो चुकी है, लेकिन कोई भी इस उत्तर को अभी तक नहीं लिखा है, इसलिए पूर्णता की खातिर: आप इसे एक सादे पायथन सरणी पर सूची की समझ के साथ कर सकते हैं:

 source = a.tolist() result = [row + [0] for row in source] b = np.array(result) 

मेरे मामले में, मुझे उन लोगों के एक स्तंभ को एक संकीर्ण सरणी में जोड़ना पड़ा

 X = array([ 6.1101, 5.5277, ... ]) X.shape => (97,) X = np.concatenate((np.ones((m,1), dtype=np.int), X.reshape(m,1)), axis=1) 

X.shape => (97, 2) के बाद

 array([[ 1. , 6.1101], [ 1. , 5.5277], ...