मैं NumPy में एक खाली सरणी / मैट्रिक्स कैसे बनाऊं?

Question

मैं इस बात का पता नहीं लगा सकता कि किसी सरणी या मैट्रिक्स का उपयोग किस तरह से किया जाए कि मैं सामान्य रूप से एक सूची का उपयोग करूं। मैं एक खाली सरणी (या मैट्रिक्स) बनाना चाहता हूं और फिर एक बार में एक कॉलम (या पंक्ति) जोड़ सकता हूं।

फिलहाल ऐसा करने का एकमात्र तरीका है:

mat = None
for col in columns:
    if mat is None:
        mat = col
    else:
        mat = hstack((mat, col))

जबकि अगर यह एक सूची होती, तो मैं कुछ इस तरह से करता:

list = []
for item in data:
    list.append(item)

क्या NumPy सरणियों या मैट्रिस के लिए उस तरह के अंकन का उपयोग करने का एक तरीका है ?

Answer 1

आपके पास NumPy को कुशलतापूर्वक उपयोग करने के लिए गलत मानसिक मॉडल है। NumPy सरणियों को मेमोरी के सन्निहित ब्लॉक में संग्रहीत किया जाता है। यदि आप मौजूदा सरणी में पंक्तियों या स्तंभों को जोड़ना चाहते हैं, तो पूरे सरणी को मेमोरी के एक नए ब्लॉक में कॉपी करने की आवश्यकता होती है, जिससे नए तत्वों को संग्रहीत करने के लिए अंतराल का निर्माण होता है। यह बहुत अक्षम है अगर एक सरणी बनाने के लिए बार-बार किया जाता है।

पंक्तियों को जोड़ने के मामले में, आपका सबसे अच्छा शर्त एक ऐसा सरणी बनाना है जो आपके डेटा सेट के रूप में बड़ा होगा और फिर इसमें पंक्ति-दर-पंक्ति डेटा जोड़ें:

>>> import numpy
>>> a = numpy.zeros(shape=(5,2))
>>> a
array([[ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.]])
>>> a[0] = [1,2]
>>> a[1] = [2,3]
>>> a
array([[ 1.,  2.],
   [ 2.,  3.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.]])

Comments

यदि आपको शून्य को शून्य करने की आवश्यकता नहीं है, तो numpy.empty () भी है।

— जनाब

शून्य () पर शून्य () का उपयोग करने का क्या लाभ है?

— Zach

यदि आप इसे सीधे अपने डेटा के साथ प्रारंभ करने जा रहे हैं, तो आप इसे शून्य करने की लागत को बचा सकते हैं।

— मार्कोरसॉवी

@maracorossi का .empty()अर्थ है कि कोई भी कोशिकाओं में यादृच्छिक मान पा सकता है, लेकिन सरणी को उदाहरण के साथ जल्दी बनाया जाता है .zeros()?

— user3085931

@ user3085931 हाँ!

— नाथन

Answer 2

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

जैसे

mylist = []
for item in data:
    mylist.append(item)
mat = numpy.array(mylist)

itemएक सूची, एक सरणी या कोई पुनरावृत्ति हो सकती है, जब तक कि प्रत्येक itemमें तत्वों की संख्या समान हो।
इस विशेष मामले में ( dataमैट्रिक्स कॉलम पकड़े हुए कुछ चलने योग्य है) आप बस उपयोग कर सकते हैं

mat = numpy.array(data)

(यह भी ध्यान दें कि listएक चर नाम के रूप में उपयोग करना संभवतः अच्छा अभ्यास नहीं है क्योंकि यह उस नाम से अंतर्निहित प्रकार को मास्क करता है, जिससे कीड़े हो सकते हैं।)

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

यदि किसी कारण से आप वास्तव में एक खाली सरणी बनाना चाहते हैं, तो आप बस उपयोग कर सकते हैं numpy.array([]), लेकिन यह शायद ही उपयोगी है!

Comments

क्या मैटलैब वालों से बुनियादी रूप से अलग एरियर / मैट्रिस हैं?

— लेवेस्क नोव

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

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

Answer 3

NumPy में एक खाली बहुआयामी सरणी बनाने के लिए (जैसे कि m*nआपके मैट्रिक्स को संग्रहीत करने के लिए एक 2D सरणी ), अगर आपको पता नहीं है mकि आप कितनी पंक्तियों में जोड़ेंगे और कम्प्यूटेशनल लागत के बारे में परवाह नहीं करेंगे, तो स्टीफन सिमंस ने उल्लेख किया (अर्थात पुन: निर्माण प्रत्येक संलग्न) में सरणी, आप 0 के आयाम है जो करने के लिए आप के लिए संलग्न करना चाहते हैं निचोड़ कर सकते हैं: X = np.empty(shape=[0, n])।

इस तरह आप उदाहरण के लिए उपयोग कर सकते हैं (यहाँ m = 5जो हम मानते हैं कि हम खाली मैट्रिक्स बनाते समय नहीं जानते थे, और n = 2):

import numpy as np

n = 2
X = np.empty(shape=[0, n])

for i in range(5):
    for j  in range(2):
        X = np.append(X, [[i, j]], axis=0)

print X

जो आपको देगा:

[[ 0.  0.]
 [ 0.  1.]
 [ 1.  0.]
 [ 1.  1.]
 [ 2.  0.]
 [ 2.  1.]
 [ 3.  0.]
 [ 3.  1.]
 [ 4.  0.]
 [ 4.  1.]]

Comments

यह उस ओपी से पूछे गए प्रश्न का उत्तर होना चाहिए, जिस उपयोग के मामले में आप पहले से ही # तीर नहीं जानते हैं, या मामले को संभालना चाहते हैं कि 0 पंक्तियाँ हैं

— Spcogg दूसरा

Answer 4

मैंने इसे बहुत देखा क्योंकि मुझे अपने एक स्कूल प्रोजेक्ट में एक सेट के रूप में एक numpy.array का उपयोग करने की आवश्यकता थी और मुझे खाली शुरू करने की आवश्यकता थी ... मुझे स्टैक ओवरफ्लो पर यहां कोई प्रासंगिक उत्तर नहीं मिला, इसलिए मैंने शुरू किया कुछ करते हुए।

# Initialize your variable as an empty list first
In [32]: x=[]
# and now cast it as a numpy ndarray
In [33]: x=np.array(x)

परिणाम होगा:

In [34]: x
Out[34]: array([], dtype=float64)

इसलिए आप सीधे एक np सरणी को इनिशियलाइज़ कर सकते हैं:

In [36]: x= np.array([], dtype=np.float64)

आशा है कि ये आपकी मदद करेगा।

Comments

यह सरणियों के लिए काम नहीं करता है, जैसा कि सवाल है, लेकिन यह वैक्टर के लिए उपयोगी हो सकता है।

— दिव्यकाल

a=np.array([])डिफ़ॉल्ट रूप से लगता हैfloat64

— P i

Answer 5

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

>>> from numpy import *
>>> a = array([10,20,30])
>>> append(a, [[1,2,3]], axis=0)
array([[10, 20, 30],      
       [1, 2, 3]])

कॉलम के लिए:

>>> append(a, [[15],[15]], axis=1)
array([[10, 20, 30, 15],      
       [1, 2, 3, 15]])

---

EDIT
बेशक, जैसा कि अन्य उत्तरों में बताया गया है, जब तक कि आप मैट्रिक्स / एरे पर कुछ प्रोसेसिंग (एक्स। उलटा) नहीं कर रहे हैं, जब भी आप इस पर कुछ जोड़ेंगे, मैं सिर्फ एक सूची बनाऊंगा, इसे जोड़ूंगा और फिर इसे एक में बदल दूंगा सरणी।

Answer 6

यदि आप सरणी के अंतिम आकार को बिल्कुल नहीं जानते हैं, तो आप इस तरह से सरणी के आकार को बढ़ा सकते हैं:

my_arr = numpy.zeros((0,5))
for i in range(3):
    my_arr=numpy.concatenate( ( my_arr, numpy.ones((1,5)) ) )
print(my_arr)

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

• सूचना 0पहली पंक्ति में।
• numpy.appendएक और विकल्प है। यह पुकारता है numpy.concatenate।

Answer 7

आप इसे किसी भी प्रकार के एरे को बनाने के लिए लगा सकते हैं, जैसे शून्य:

a = range(5)
a = [i*0 for i in a]
print a 
[0, 0, 0, 0, 0]

Comments

यदि आप शुद्ध अजगर में ऐसा करना चाहते हैं, a= [0] * 5तो इसका सरल उपाय

— Makers_F

Answer 8

यहाँ कुछ वर्कअराउंड बनाने के लिए numpys को Lists की तरह दिखना है

np_arr = np.array([])
np_arr = np.append(np_arr , 2)
np_arr = np.append(np_arr , 24)
print(np_arr)

OUTPUT: सरणी ([2., 24.])

Answer 9

आप इसके लिए क्या उपयोग कर रहे हैं, इसके आधार पर, आपको डेटा प्रकार ( 'dtype' देखें ) निर्दिष्ट करने की आवश्यकता हो सकती है ।

उदाहरण के लिए, 8-बिट मान (मोनोक्रोम छवि के रूप में उपयोग के लिए उपयुक्त) का 2 डी सरणी बनाने के लिए)

myarray = numpy.empty(shape=(H,W),dtype='u1')

RGB छवि के लिए, आकृति में रंग चैनलों की संख्या शामिल करें: shape=(H,W,3)

आप numpy.zerosउपयोग करने के बजाय शून्य-प्रारंभिककरण पर भी विचार कर सकते हैं numpy.empty। नोट यहाँ देखें ।

Answer 10

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

ur_list = []
for col in columns:
    ur_list.append(list(col))

mat = np.matrix(ur_list)

Answer 11

मुझे लगता है कि आप इस तरह खाली शून्य सारणी बना सकते हैं:

>>> import numpy as np
>>> empty_array= np.zeros(0)
>>> empty_array
array([], dtype=float64)
>>> empty_array.shape
(0,)

यह प्रारूप उपयोगी है जब आप लूप में संख्यात्मक सरणी को जोड़ना चाहते हैं।

Answer 12

अपने आकार को परिभाषित किए बिना एक खाली NumPy सरणी बनाने के लिए रास्ता है:

1।

arr = np.array([]) 

पसंदीदा। कारण आपको पता है कि आप इसे सुन्न के रूप में उपयोग कर रहे हैं।

2।

arr = []
# and use it as numpy. append to it or etc..

NumPy इसे बिना अतिरिक्त के np.ndarray प्रकार के बाद में रूपांतरित करता है [] dimionsion।