दो एक आयामी NumPy सरणियों को समेटना

Question

मैं NumPy में दो सरल एक आयामी सरणियाँ है । मैं उन्हें numpy.concatenate का उपयोग करके समवर्ती करने में सक्षम होना चाहिए । लेकिन मुझे नीचे दिए गए कोड के लिए यह त्रुटि मिली:

TypeError: केवल लंबाई -1 सरणियों को पायथन स्केलर में परिवर्तित किया जा सकता है

कोड

import numpy
a = numpy.array([1, 2, 3])
b = numpy.array([5, 6])
numpy.concatenate(a, b)

क्यों?

Comments

यदि आप एक अक्ष के साथ उन्हें (एक सरणी में) संक्षिप्त करना चाहते हैं , तो उपयोग करें np.concatenat(..., axis)। यदि आप उन्हें लंबवत स्टैक करना चाहते हैं, तो उपयोग करें np.vstack। यदि आप उन्हें (कई सरणियों में) क्षैतिज रूप से स्टैक करना चाहते हैं, तो उपयोग करें np.hstack। (यदि आप उन्हें गहराई-वार यानी तेह 3 आयाम, उपयोग करना चाहते हैं np.dstack)। ध्यान दें कि उत्तरार्द्ध पांडा के समान हैंpd.concat

— 2

Answer 1

लाइन होनी चाहिए:

numpy.concatenate([a,b])

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

से NumPy प्रलेखन :

numpy.concatenate((a1, a2, ...), axis=0)

एक साथ सरणियों के अनुक्रम में शामिल हों।

यह bअक्ष पैरामीटर के रूप में आपकी व्याख्या करने की कोशिश कर रहा था , यही वजह है कि उसने शिकायत की कि यह इसे एक अदिश में नहीं बदल सकता है।

Comments

धन्यवाद! बस जिज्ञासु - इसके पीछे तर्क क्या है?

— user391339

@ user391339, क्या होगा यदि आप तीन सरणियों को संक्षिप्त करना चाहते हैं? यह अनुक्रम अनुक्रम लेने में अधिक उपयोगी है, अगर यह सिर्फ दो सरणियाँ लेता है।

— विंस्टन इर्वर्ट

@InstonEwert इस मुद्दे को मानते हुए कि यह दो तर्कों के लिए कठिन नहीं है, आप इसे पसंद करते हैं numpy.concatenate(a1, a2, a3)या numpy.concatenate(*[a1, a2, a3])चाहें तो इसका उपयोग कर सकते हैं। पाइथन का द्रव पर्याप्त है कि अंतर पर्याप्त से अधिक कॉस्मेटिक महसूस कर रहा है, लेकिन यह अच्छा है जब एपीआई सुसंगत है (उदाहरण के लिए चर संख्या तर्क सूचियों को लेने वाले सभी सुस्पष्ट कार्यों को स्पष्ट अनुक्रम की आवश्यकता होती है)।

— जिम के।

@JimK। अक्ष पैरामीटर का क्या होगा?

— विंस्टन इवर्ट

चीजों को समाप्‍त मानने के लिए सभी स्थितिगत मानदंड हैं, आप अक्ष को कीवर्ड तर्क के रूप में रख सकते हैं def concatx(*sequences, **kwargs))। यह आदर्श नहीं है क्योंकि आप इस तरह से हस्ताक्षर में स्पष्ट रूप से कीवर्ड आर्ग्स का नाम नहीं दे सकते हैं, लेकिन वर्कअराउंड हैं।

— जिम के।

Answer 2

1D सरणियों को समाप्‍त करने के लिए कई संभावनाएं हैं, उदाहरण के लिए,

numpy.r_[a, a],
numpy.stack([a, a]).reshape(-1),
numpy.hstack([a, a]),
numpy.concatenate([a, a])

वे सभी विकल्प बड़े सरणियों के लिए समान रूप से तेज़ हैं; छोटे लोगों के लिए, concatenateएक मामूली बढ़त है:

साजिश perfplot के साथ बनाया गया था :

import numpy
import perfplot

perfplot.show(
    setup=lambda n: numpy.random.rand(n),
    kernels=[
        lambda a: numpy.r_[a, a],
        lambda a: numpy.stack([a, a]).reshape(-1),
        lambda a: numpy.hstack([a, a]),
        lambda a: numpy.concatenate([a, a]),
    ],
    labels=["r_", "stack+reshape", "hstack", "concatenate"],
    n_range=[2 ** k for k in range(19)],
    xlabel="len(a)",
)

Comments

विकल्प सभी उपयोग करते हैं np.concatenate। वे सिर्फ हाथ से पहले विभिन्न तरीकों से इनपुट सूची की मालिश करते हैं। np.stackउदाहरण के लिए सभी इनपुट सरणियों के लिए एक अतिरिक्त आयाम जोड़ता है। उनके स्रोत कोड को देखें। केवल concatenateसंकलित है।

— हंपुलज

सिर्फ @hpaulj की टिप्पणी में जोड़ने के लिए - सभी बार सारणियों के आकार बढ़ने के कारण अभिसरण हो जाता है क्योंकि np.concatenateइनपुट की प्रतियां बनाता है। यह स्मृति और समय की लागत तब इनपुट को 'मालिश' करने में लगने वाले समय से अधिक हो जाती है।

— n1k31t4

Answer 3

पहले पैरामीटर को concatenateस्वयं को संक्षिप्त करने के लिए सरणियों का क्रम होना चाहिए :

numpy.concatenate((a,b)) # Note the extra parentheses.

Answer 4

"Isatenate" के संक्षिप्त रूप का उपयोग करने के लिए एक वैकल्पिक ist जो "r _ [...]" या "c _ [...]" है, जैसा कि नीचे दिए गए उदाहरण कोड में दिखाया गया है (देखें http://wiki.scipy.org ( अतिरिक्त जानकारी के लिए NumPy_for_Matlab_Users ):

%pylab
vector_a = r_[0.:10.] #short form of "arange"
vector_b = array([1,1,1,1])
vector_c = r_[vector_a,vector_b]
print vector_a
print vector_b
print vector_c, '\n\n'

a = ones((3,4))*4
print a, '\n'
c = array([1,1,1])
b = c_[a,c]
print b, '\n\n'

a = ones((4,3))*4
print a, '\n'
c = array([[1,1,1]])
b = r_[a,c]
print b

print type(vector_b)

जिसके परिणामस्वरूप:

[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
[1 1 1 1]
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.  1.  1.  1.  1.] 


[[ 4.  4.  4.  4.]
 [ 4.  4.  4.  4.]
 [ 4.  4.  4.  4.]] 

[[ 4.  4.  4.  4.  1.]
 [ 4.  4.  4.  4.  1.]
 [ 4.  4.  4.  4.  1.]] 


[[ 4.  4.  4.]
 [ 4.  4.  4.]
 [ 4.  4.  4.]
 [ 4.  4.  4.]] 

[[ 4.  4.  4.]
 [ 4.  4.  4.]
 [ 4.  4.  4.]
 [ 4.  4.  4.]
 [ 1.  1.  1.]]

Comments

vector_b = [1,1,1,1] #short form of "array", यह बिल्कुल सही नहीं है। वेक्टर_ब एक मानक पायथन सूची प्रकार होगा। Numpy हालांकि सभी इनपुट्स को numpy.array प्रकार होने के लिए मजबूर करने के बजाय दृश्यों को स्वीकार करने में काफी अच्छा है।

— हेंस ओवेन ने

तुम सही कह रहे हो, मैंने गलती की थी। मैंने अपने स्रोत कोड के साथ-साथ परिणाम को भी सही किया।

— सेमीजॉन मोसेन्सर

Answer 5

यहाँ और अधिक कर रहे हैं का उपयोग करके ऐसा करने के लिए दृष्टिकोण numpy.ravel(), numpy.array()इस तथ्य का उपयोग -1 डी सरणियों सादा तत्वों में पैक किया जा सकता है:

# we'll utilize the concept of unpacking
In [15]: (*a, *b)
Out[15]: (1, 2, 3, 5, 6)

# using `numpy.ravel()`
In [14]: np.ravel((*a, *b))
Out[14]: array([1, 2, 3, 5, 6])

# wrap the unpacked elements in `numpy.array()`
In [16]: np.array((*a, *b))
Out[16]: array([1, 2, 3, 5, 6])

Answer 6

सुन्न डॉक्स से कुछ और तथ्य :

सिंटेक्स के साथ numpy.concatenate((a1, a2, ...), axis=0, out=None)

रोष-वार संघनन के लिए अक्ष = 0 कॉलम-वार संघनन के लिए = 1

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

# Appending below last row
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])

# Appending after last column
>>> np.concatenate((a, b.T), axis=1)    # Notice the transpose
array([[1, 2, 5],
       [3, 4, 6]])

# Flattening the final array
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])

मुझे उम्मीद है यह मदद करेगा !