Numpy - पायथन, सरणी, numpy में सरणी में एकल तत्व जोड़ें

मेरे पास एक सुपीरियर सरणी है:

[1, 2, 3]

मैं एक सरणी बनाना चाहता हूँ:

[1, 2, 3, 1]

यही है, मैं पहले तत्व को सरणी के अंत में जोड़ना चाहता हूं।

मैंने स्पष्ट करने की कोशिश की है:

np.concatenate((a, a[0]))

लेकिन मैं एक त्रुटि कह रहा हूँ ValueError: arrays must have same number of dimensions

मैं यह नहीं समझता - सरणियाँ दोनों सिर्फ 1d सरणियाँ हैं।

उत्तर:

उत्तर № 1 के लिए 81

मुझे लगता है कि तत्व जोड़ने के लिए उचित विधि का उपयोग करना अधिक सामान्य है:

numpy.append(a, a[0])

जवाब के लिए 11 № 2

a[0] एक सरणी नहीं है, यह पहला तत्व है a और इसलिए कोई आयाम नहीं है।

उपयोग करने का प्रयास करें a[0:1] इसके बजाय, जो पहले तत्व को वापस करेगा a किसी एक आइटम सरणी के अंदर।


उत्तर के लिए 7 № 3

इसे इस्तेमाल करे

np.concatenate((a, np.array([a[0]]))

http://docs.scipy.org/doc/numpy/reference/generated/numpy.concatenate.html

समवर्ती को दोनों तत्वों को सरणी की आवश्यकता होती है, हालांकि एक [0] एक सरणी नहीं है। यही कारण है कि यह काम नहीं करता है।


जवाब के लिए 4 № 4
t = np.array([2, 3])
t = np.append(t, [4])

जवाब के लिए 3 № 5

यह थोड़ा ओवरकिल हो सकता है, लेकिन मैं हमेशा इसका उपयोग करता हूं np.take किसी भी रैप-अराउंड इंडेक्सिंग के लिए कार्य:

>>> a = np.array([1, 2, 3])
>>> np.take(a, range(0, len(a)+1), mode="wrap")
array([1, 2, 3, 1])

>>> np.take(a, range(-1, len(a)+1), mode="wrap")
array([3, 1, 2, 3, 1])

जवाब के लिए 0 № 6

हम कहते हैं a=[1,2,3] और आप चाहते हैं कि यह हो [1,2,3,1]

आप अंतर्निहित एपेंड फ़ंक्शन का उपयोग कर सकते हैं

np.append(a,1)

यहां 1 एक इंट है, यह एक स्ट्रिंग हो सकता है और यह एरे में तत्वों से संबंधित हो सकता है या नहीं भी हो सकता है। प्रिंटों: [1,2,3,1]


उत्तर के लिए 0 № 7

यह आदेश,

numpy.append(a, a[0])

परिवर्तन नहीं करता है a सरणी। हालाँकि, यह एक नया संशोधित सरणी देता है। तो अगर a तब संशोधन की आवश्यकता होती है

a = numpy.append(a,a[0])

उपयोग किया जाना चाहिए।


जवाब के लिए 0 № 8

जब केवल एक बार या एक बार हर बार और फिर से प्रयोग करके np.append आपकी सरणी ठीक होनी चाहिए।इस दृष्टिकोण का दोष यह है कि मेमोरी को हर बार पूरी तरह से नए सरणी के लिए आवंटित किया जाता है जिसे इसे कहा जाता है। जब एक महत्वपूर्ण मात्रा में नमूनों के लिए एक सरणी बढ़ती है, तो सरणी को पूर्व-आवंटित करना बेहतर होगा (यदि कुल आकार ज्ञात हो) या किसी सूची में संलग्न करना और बाद में एक सरणी में परिवर्तित करना।

का उपयोग करते हुए np.append:

b = np.array([0])
for k in range(int(10e4)):
b = np.append(b, k)
1.2 s ± 16.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

बाद में सरणी में परिवर्तित अजगर सूची का उपयोग करना:

d = [0]
for k in range(int(10e4)):
d.append(k)
f = np.array(d)
13.5 ms ± 277 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

पूर्व-आबंटित संख्या:

e = np.zeros((n,))
for k in range(n):
e[k] = k
9.92 ms ± 752 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

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

85.1 ms ± 561 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

संबंधित सवाल
सबसे लोकप्रिय