एक सुन्न सरणी इनिशियलाइज़ करें

Question

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

a = []
for i in range(5):
    a.append(i)

मैं एक समान सरणी के साथ कुछ समान करना चाहता हूं। मैं vstack, concatenate आदि के बारे में जानता हूँ। हालाँकि, ऐसा लगता है कि इनको इनपुट के रूप में दो संख्यात्मक सरणियों की आवश्यकता है। मुझे क्या चाहिए:

big_array # Initially empty. This is where I don't know what to specify
for i in range(5):
    array i of shape = (2,4) created.
    add to big_array

big_arrayएक आकार होना चाहिए (10,4)। यह कैसे करना है?

---

संपादित करें:

मैं निम्नलिखित स्पष्टीकरण जोड़ना चाहता हूं। मुझे पता है कि मैं इसे परिभाषित कर सकता हूं big_array = numpy.zeros((10,4))और फिर इसे भर सकता हूं । हालांकि, इसके लिए अग्रिम में big_array के आकार को निर्दिष्ट करने की आवश्यकता होती है। मैं इस मामले में आकार जानता हूं, लेकिन अगर मैं नहीं करूं तो क्या होगा? जब हम .appendअजगर में सूची का विस्तार करने के लिए फ़ंक्शन का उपयोग करते हैं , तो हमें पहले से इसका अंतिम आकार जानने की आवश्यकता नहीं है। मुझे आश्चर्य हो रहा है कि क्या छोटे एरे से एक बड़ा सरणी बनाने के लिए कुछ समान मौजूद है, जो खाली सरणी से शुरू होता है।

Comments

संयोग से आपका पहला कोड नमूना बड़े करीने से और संक्षेप में एक सूची समझ के रूप में लिखा जा सकता है [i for i in range(5)]:। (समान रूप से: list(range(5))हालांकि, यह एक

— विरोधाभासी

क्या समाधान आपके लिए काम किया? मैं ठीक उसी तरह से कुछ करने की कोशिश कर रहा हूं, जैसे x = numpy.array()हम किसी सूची में करते हैं y = []; लेकिन यह काम नहीं किया

— kRazzy आर

Answer 1

numpy.zeros

दिए गए आकार और प्रकार की एक नई सरणी लौटाएं, शून्य से भरा।

या

numpy.ones

दिए गए आकार और प्रकार की एक नई सरणी लौटाएं, जो लोगों से भरी हुई हैं।

या

numpy.empty

प्रविष्टियों को आरंभ किए बिना, दिए गए आकार और प्रकार का एक नया सरणी लौटाएं।

---

हालाँकि, जिस मानसिकता के आधार पर हम किसी सूची में तत्वों को जोड़कर एक सरणी का निर्माण करते हैं, वह बहुत अधिक संख्या में उपयोग नहीं की जाती है, क्योंकि यह कम कुशल है (सुन्न डेटाटाइप्स अंतर्निहित सी सरणियों के बहुत करीब हैं)। इसके बजाय, आपको सरणी को उस आकार में प्रचारित करना चाहिए जिसकी आपको आवश्यकता है, और फिर पंक्तियों में भरें। आप का उपयोग कर सकते हैं numpy.appendयदि आप, हालांकि।

Comments

मुझे पता है कि मैं big_array = numpy.zeros सेट कर सकता हूं और फिर बनाई गई छोटी सरणियों से इसे भर सकता हूं। हालाँकि, इससे मुझे अग्रिम में big_array के आकार को निर्दिष्ट करने की आवश्यकता होती है। वहाँ सूची समारोह के .append की तरह कुछ भी नहीं है जहाँ मैं पहले से आकार निर्दिष्ट नहीं है। धन्यवाद!

— २१:३० पर क्यूरियस २ लेर

@ Curious2learn। नहीं, Numpy में Append जैसा कुछ भी नहीं है। ऐसे कार्य हैं जो नए सरणियों को बनाकर उन्हें व्यवस्थित या समतल करते हैं, लेकिन वे जोड़-तोड़ करके ऐसा नहीं करते हैं। यह इस तरह से है क्योंकि डेटा संरचनाएं सेट-अप हैं। Numpy सरणियों को अधिक कॉम्पैक्ट रूप से स्टोर वैल्यू में सक्षम होने के कारण तेजी से बनाया जाता है, लेकिन उन्हें इस गति को प्राप्त करने के लिए निश्चित आकार की आवश्यकता होती है। पायथन सूचियों को गति और आकार की कीमत पर अधिक लचीला बनाया गया है।

— जस्टिन पील

@ गंभीर: ठीक है, वहाँ एक appendखस्ता है। यह सिर्फ इतना है कि यह कम प्रचारित नहीं है (इस मामले में, बहुत कम कुशल है, क्योंकि appendहर बार पूरे सरणी को कॉपी करता है), इसलिए यह एक मानक तकनीक नहीं है।

— कैट्रील

यदि np.emptyसरणी का केवल भाग मानों से भरा हो तो क्या होगा ? शेष "खाली" वस्तुओं के बारे में क्या?

— ली

आप केवल चौड़ाई (जैसे के लिए आवश्यक पता है पता है np.concatenate()), तो आप के साथ प्रारंभ कर सकते हैं: np.empty((0, some_width))। 0, इसलिए आपका पहला एरे कचरा नहीं होगा।

— न्यूमेससंगिस

Answer 2

जिस तरह से मैं आमतौर पर एक नियमित सूची बनाकर करता हूं, फिर उसमें अपना सामान जोड़ देता हूं, और अंत में सूची को एक सुपीरियर एरे में बदल देता हूं:

import numpy as np
big_array = [] #  empty regular list
for i in range(5):
    arr = i*np.ones((2,4)) # for instance
    big_array.append(arr)
big_np_array = np.array(big_array)  # transformed to a numpy array

बेशक आपकी अंतिम वस्तु निर्माण कदम पर मेमोरी में दो बार जगह लेती है, लेकिन अजगर सूची में शामिल होना बहुत तेज है, और np.array () का उपयोग करके निर्माण भी है।

Comments

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

— ट्रेक

Answer 3

1.8 1.8 में पेश किया गया:

numpy.full

दिए गए आकार और प्रकार का एक नया सरणी भरें, fill_value से भरा।

उदाहरण:

>>> import numpy as np
>>> np.full((2, 2), np.inf)
array([[ inf,  inf],
       [ inf,  inf]])
>>> np.full((2, 2), 10)
array([[10, 10],
       [10, 10]])

Answer 4

अजगर के लिए ऐरे एनालॉग

a = []
for i in range(5):
    a.append(i)

है:

import numpy as np

a = np.empty((0))
for i in range(5):
    a = np.append(a, i)

Comments

@ निचलोल्टज: empty((0))एक सुरीली सरणी को आरंभीकृत करता है।

— एडोब

np.empty ((0)) में कोष्ठक निरर्थक हैं।

— सिजमन रोजविस्की

Answer 5

numpy.fromiter() आप क्या देख रहे हैं:

big_array = numpy.fromiter(xrange(5), dtype="int")

यह जनरेटर के भावों के साथ भी काम करता है, जैसे:

big_array = numpy.fromiter( (i*(i+1)/2 for i in xrange(5)), dtype="int" )

यदि आपको पहले से सरणी की लंबाई पता है, तो आप इसे वैकल्पिक 'गिनती' तर्क के साथ निर्दिष्ट कर सकते हैं।

Comments

मैं वास्तव में timeit भागा, और मुझे लगता है कि np.fromiter () np.array () की तुलना में धीमा हो सकता है। timeit ("np.array (i for i in xrange (100))", setup = "आयात खसरा as np", संख्या = 10000) -> 0.02539992332458496, बनाम timeit ("np .fromiter (i) के लिए मैं xrange () 100)), dtype = पूर्णांक) ", सेटअप =" एन पी के रूप में आयात numpy ", संख्या = 10000) -> .13351011276245117

— hlin117

Answer 6

आप सरणी कंप्यूटिंग करते समय यथासंभव स्पष्ट छोरों से बचना चाहते हैं, क्योंकि यह कंप्यूटिंग के उस रूप से गति को कम करता है। एक सुन्न सरणी को इनिशियलाइज़ करने के कई तरीके हैं। यदि आप चाहते हैं कि यह शून्य से भरा हो, तो जैसा कि katrielalex ने कहा:

big_array = numpy.zeros((10,4))

संपादित करें: यह आप किस प्रकार का अनुक्रम बना रहे हैं? आपको अलग-अलग सुन्न कार्यों की जांच करनी चाहिए, जो सरणियों का निर्माण करते हैं, जैसे numpy.linspace(start, stop, size)(समान रूप से स्थान संख्या), या numpy.arange(start, stop, inc)। जहां संभव हो, ये कार्य स्पष्ट लूप में समान कार्य करने की तुलना में एरियर्स को काफी तेजी से बढ़ाएंगे

Answer 7

एक विशिष्ट मैट्रिक्स के साथ एक सुदूर सरणी को आरंभीकृत करने के लिए:

import numpy as np

mat = np.array([[1, 1, 0, 0, 0],
                [0, 1, 0, 0, 1],
                [1, 0, 0, 1, 1],
                [0, 0, 0, 0, 0],
                [1, 0, 1, 0, 1]])

print mat.shape
print mat

उत्पादन:

(5, 5)
[[1 1 0 0 0]
 [0 1 0 0 1]
 [1 0 0 1 1]
 [0 0 0 0 0]
 [1 0 1 0 1]]

Answer 8

अपने पहले सरणी उदाहरण के उपयोग के लिए,

a = numpy.arange(5)

Big_array को इनिशियलाइज़ करने के लिए, उपयोग करें

big_array = numpy.zeros((10,4))

यह मानता है कि आप शून्य के साथ आरंभ करना चाहते हैं, जो बहुत विशिष्ट है, लेकिन कई और तरीके हैं, जो अरपी में एक सरणी को आरंभीकृत करने के लिए हैं ।

संपादित करें: यदि आप अग्रिम में big_array के आकार को नहीं जानते हैं, तो आम तौर पर सबसे पहले ऐप्पल का उपयोग करके पायथन सूची बनाना सबसे अच्छा है, और जब आपके पास सूची में सब कुछ एकत्र हो, तो इस सूची का उपयोग करके एक अफीम सरणी में परिवर्तित करें numpy.array(mylist)। इसका कारण यह है कि सूचियाँ बहुत कुशलता से और तेज़ी से बढ़ने के लिए होती हैं, जबकि numpy.concatenate बहुत ही अकुशल होगा क्योंकि सुन्न सरणियाँ आसानी से आकार नहीं बदलती हैं। लेकिन एक बार जब सब कुछ एक सूची में एकत्र हो जाता है, और आप अंतिम सरणी आकार जानते हैं, तो एक सुव्यवस्थित सरणी का कुशलता से निर्माण किया जा सकता है।

Answer 9

मैं पहले आकार को परिभाषित करने का सुझाव दूंगा। फिर मूल्यों को सम्मिलित करने के लिए उस पर पुनरावृति।

big_array= np.zeros(shape = ( 6, 2 ))
for it in range(6):
    big_array[it] = (it,it) # For example

>>>big_array

array([[ 0.,  0.],
       [ 1.,  1.],
       [ 2.,  2.],
       [ 3.,  3.],
       [ 4.,  4.],
       [ 5.,  5.]])

Answer 10

जब भी आप निम्न स्थिति में हों:

a = []
for i in range(5):
    a.append(i)

और आप कुछ ऐसा ही चाहते हैं, कई पिछले जवाबों ने इसे करने के तरीके बताए हैं, लेकिन जैसा कि @katrielalex ने बताया कि ये तरीके कुशल नहीं हैं। ऐसा करने का कुशल तरीका यह है कि आप एक लंबी सूची बनाएं और फिर लंबी सूची बनाने के बाद उसे वैसे ही आकार में बदल दें। उदाहरण के लिए, मान लें कि मैं किसी फ़ाइल से कुछ पंक्तियाँ पढ़ रहा हूँ और प्रत्येक पंक्ति में संख्याओं की एक सूची है और मैं आकार की एक संख्या (प्रत्येक पंक्ति में वेक्टर की लंबाई, पढ़ी जाने वाली पंक्तियों की लंबाई) का निर्माण करना चाहता हूँ। यहाँ है कि मैं इसे और अधिक कुशलता से कैसे करूंगा:

long_list = []
counter = 0
with open('filename', 'r') as f:
    for row in f:
        row_list = row.split()
        long_list.extend(row_list)
        counter++
#  now we have a long list and we are ready to reshape
result = np.array(long_list).reshape(counter, len(row_list)) #  desired numpy array

Answer 11

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

big_array = numpy.empty(10, 4)
for i in range(5):
    array_i = numpy.random.random(2, 4)
    big_array[2 * i:2 * (i + 1), :] = array_i

इस तरह, आप संपूर्ण परिणाम सरणी के साथ प्रचार करते हैं numpy.empty और पंक्तियों में भरते हैं जैसे कि आप अनुक्रमित असाइनमेंट का उपयोग करते हुए जाते हैं।

यह आपके द्वारा दिए गए उदाहरण के emptyबजाय प्रचार करने के लिए पूरी तरह से सुरक्षित है zerosक्योंकि आप गारंटी दे रहे हैं कि आपके द्वारा बनाई गई विखंडू के साथ पूरी सरणी भरी जाएगी।

Answer 12

हो सकता है कि ऐसा कुछ आपकी आवश्यकताओं के अनुरूप हो।

import numpy as np

N = 5
res = []

for i in range(N):
    res.append(np.cumsum(np.ones(shape=(2,4))))

res = np.array(res).reshape((10, 4))
print(res)

जो निम्न आउटपुट उत्पन्न करता है

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