Hängen Sie ein NumPy-Array an ein NumPy-Array an

Ich habe ein numpy_array. So etwas wie [ a b c ].

Und dann möchte ich es an ein anderes NumPy-Array anhängen (genau wie wir eine Liste von Listen erstellen). Wie erstellen wir ein Array von NumPy-Arrays, die NumPy-Arrays enthalten?

Ich habe ohne Glück versucht, Folgendes zu tun

>>> M = np.array([])
>>> M
array([], dtype=float64)
>>> M.append(a,axis=0)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'numpy.ndarray' object has no attribute 'append'
>>> a
array([1, 2, 3])

In [1]: import numpy as np

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

In [3]: b = np.array([[9, 8, 7], [6, 5, 4]])

In [4]: np.concatenate((a, b))
Out[4]: 
array([[1, 2, 3],
       [4, 5, 6],
       [9, 8, 7],
       [6, 5, 4]])

oder dieses:

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

In [2]: b = np.array([4, 5, 6])

In [3]: np.vstack((a, b))
Out[3]: 
array([[1, 2, 3],
       [4, 5, 6]])

Nun, die Fehlermeldung sagt schon alles: NumPy-Arrays haben keine append()Methode. Es gibt jedoch eine kostenlose Funktion numpy.append():

numpy.append(M, a)

Dadurch wird ein neues Array erstellt, anstatt Man Ort und Stelle zu mutieren . Beachten Sie, dass bei der Verwendung numpy.append()beide Arrays kopiert werden. Sie erhalten Code mit besserer Leistung, wenn Sie NumPy-Arrays mit fester Größe verwenden.

Sie können verwenden numpy.append()...

import numpy

B = numpy.array([3])
A = numpy.array([1, 2, 2])
B = numpy.append( B , A )

print B

> [3 1 2 2]

Dadurch werden keine zwei separaten Arrays erstellt, sondern zwei Arrays an ein eindimensionales Array angehängt.

Sven sagte alles, sei nur sehr vorsichtig wegen der automatischen Typanpassungen, wenn Append aufgerufen wird.

In [2]: import numpy as np

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

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

In [5]: c = np.array(['a','b','c'])

In [6]: np.append(a,b)
Out[6]: array([ 1.,  2.,  3.,  1.,  2.,  3.])

In [7]: a.dtype
Out[7]: dtype('int64')

In [8]: np.append(a,c)
Out[8]: 
array(['1', '2', '3', 'a', 'b', 'c'], 
      dtype='|S1')

Wie Sie anhand des Inhalts sehen, ging der dtype von int64 zu float32 und dann zu S1

Ich habe diesen Link gefunden, als ich nach etwas etwas anderem gesucht habe, wie man Array-Objekte an ein leeres numpy-Array anfügt, aber alle Lösungen auf dieser Seite ohne Erfolg ausprobiert.

Dann fand ich diese Frage und Antwort: Wie man eine neue Zeile zu einem leeren Numpy-Array hinzufügt

Das Wesentliche hier:

Der Weg, um das gewünschte Array zu "starten", ist:

arr = np.empty((0,3), int)

Dann können Sie verketten verwenden, um Zeilen wie folgt hinzuzufügen:

arr = np.concatenate( ( arr, [[x, y, z]] ) , axis=0)

Siehe auch https://docs.scipy.org/doc/numpy/reference/generated/numpy.concatenate.html

Tatsächlich kann man immer eine gewöhnliche Liste von Numpy-Arrays erstellen und später konvertieren.

In [1]: import numpy as np

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

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

In [4]: l = [a]

In [5]: l.append(b)

In [6]: l = np.array(l)

In [7]: l.shape
Out[7]: (2, 2, 2)

In [8]: l
Out[8]: 
array([[[1, 2],
        [3, 4]],

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

Ich hatte das gleiche Problem und konnte die Antwort von @Sven Marnach sowieso nicht kommentieren (nicht genug Wiederholung, meine Güte, ich erinnere mich, als Stackoverflow zum ersten Mal gestartet wurde ...).

Hinzufügen einer Liste von Zufallszahlen zu einer 10 x 10-Matrix.

myNpArray = np.zeros([1, 10])
for x in range(1,11,1):
    randomList = [list(np.random.randint(99, size=10))]
    myNpArray = np.vstack((myNpArray, randomList))
myNpArray = myNpArray[1:]

Mit np.zeros () wird ein Array mit 1 x 10 Nullen erstellt.

array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

Anschließend wird mit np.random eine Liste mit 10 Zufallszahlen erstellt und randomList zugewiesen. Die Schleife stapelt es 10 hoch. Wir müssen nur daran denken, den ersten leeren Eintrag zu entfernen.

myNpArray

array([[31., 10., 19., 78., 95., 58.,  3., 47., 30., 56.],
       [51., 97.,  5., 80., 28., 76., 92., 50., 22., 93.],
       [64., 79.,  7., 12., 68., 13., 59., 96., 32., 34.],
       [44., 22., 46., 56., 73., 42., 62.,  4., 62., 83.],
       [91., 28., 54., 69., 60., 95.,  5., 13., 60., 88.],
       [71., 90., 76., 53., 13., 53., 31.,  3., 96., 57.],
       [33., 87., 81.,  7., 53., 46.,  5.,  8., 20., 71.],
       [46., 71., 14., 66., 68., 65., 68., 32.,  9., 30.],
       [ 1., 35., 96., 92., 72., 52., 88., 86., 94., 88.],
       [13., 36., 43., 45., 90., 17., 38.,  1., 41., 33.]])

Also in einer Funktion:

def array_matrix(random_range, array_size):
    myNpArray = np.zeros([1, array_size])
    for x in range(1, array_size + 1, 1):
        randomList = [list(np.random.randint(random_range, size=array_size))]
        myNpArray = np.vstack((myNpArray, randomList))
    return myNpArray[1:]

ein 7 x 7 Array mit Zufallszahlen 0 - 1000

array_matrix(1000, 7)

array([[621., 377., 931., 180., 964., 885., 723.],
       [298., 382., 148., 952., 430., 333., 956.],
       [398., 596., 732., 422., 656., 348., 470.],
       [735., 251., 314., 182., 966., 261., 523.],
       [373., 616., 389.,  90., 884., 957., 826.],
       [587., 963.,  66., 154., 111., 529., 945.],
       [950., 413., 539., 860., 634., 195., 915.]])

Wenn ich Ihre Frage verstehe, ist hier eine Möglichkeit. Angenommen, Sie haben:

a = [4.1, 6.21, 1.0]

Also hier ist ein Code ...

def array_in_array(scalarlist):
    return [(x,) for x in scalarlist]

Was dazu führt:

In [72]: a = [4.1, 6.21, 1.0]

In [73]: a
Out[73]: [4.1, 6.21, 1.0]

In [74]: def array_in_array(scalarlist):
   ....:     return [(x,) for x in scalarlist]
   ....: 

In [75]: b = array_in_array(a)

In [76]: b
Out[76]: [(4.1,), (6.21,), (1.0,)]

Versuchen Sie diesen Code:

import numpy as np

a1 = np.array([])

n = int(input(""))

for i in range(0,n):
    a = int(input(""))
    a1 = np.append(a, a1)
    a = 0

print(a1)

Sie können auch Array anstelle von "a" verwenden.