In Entwicklung | Zuletzt aktualisiert am: 26. April 2022

Cloudways bietet verwaltetes Cloud-Hosting für Unternehmen jeder Größe zum Hosten einer Website oder komplexer Webanwendungen.

NumPy reshape(): Wie man NumPy-Arrays in Python umformt

By Bala Priya C

In diesem Tutorial lernen Sie die Verwendung NumPy-Umformung() um NumPy-Arrays umzuformen, ohne die ursprünglichen Daten zu ändern.

Wenn Sie mit Numpy-Arrays arbeiten, möchten Sie möglicherweise häufig ein vorhandenes Array in ein Array mit anderen Dimensionen umformen. Dies kann besonders nützlich sein, wenn Sie Daten in mehreren Schritten transformieren.

Und NumPy reshape() hilft Ihnen, es einfach zu tun. In den nächsten Minuten lernen Sie die zu verwendende Syntax kennen reshape(), und auch Arrays auf andere Dimensionen umformen.

Was ist Umformen in NumPy-Arrays?

Wenn Sie mit NumPy-Arrays arbeiten, möchten Sie möglicherweise zuerst ein eindimensionales Zahlenarray erstellen. Und formen Sie es dann in ein Array mit der gewünschten Dimension um.

Dies ist besonders hilfreich, wenn die Dimensionen des neuen Arrays anfangs nicht bekannt sind oder während der Ausführung abgeleitet werden. Oder es ist auch möglich, dass ein bestimmter Datenverarbeitungsschritt eine bestimmte Form der Eingabe erfordert.

Hier ist wo Umformung kommt in handliches.

Betrachten Sie beispielsweise die folgende Abbildung. Wir haben einen Vektor – ein eindimensionales Array aus 6 Elementen. Und wir können es in Arrays von Formen 2×3, 3×2, 6×1 und so weiter umformen.

▶️ Um den Beispielen in diesem Tutorial folgen zu können, müssen Python und NumPy installiert sein. Wenn Sie NumPy noch nicht haben, sehen Sie sich unsere an NumPy-Installationsanleitung.

Sie können jetzt fortfahren und NumPy unter dem Alias importieren np, indem Sie Folgendes ausführen: import numpy as np.

Fahren wir fort, um die Syntax im nächsten Abschnitt zu lernen.

Syntax von NumPy reshape()

Hier ist die Syntax zur Verwendung von NumPy reshape():

np.reshape(arr, newshape, order = 'C'|'F'|'A')

arr ist ein beliebiges gültiges NumPy-Array-Objekt. Hier ist es das umzuformende Array.
neue Form ist die Form des neuen Arrays. Es kann entweder eine ganze Zahl oder ein Tupel sein.
Wann neue Form eine Ganzzahl ist, ist das zurückgegebene Array eindimensional.
Auftrag bezieht sich auf die Reihenfolge, in der Sie die Elemente des umzuformenden Arrays einlesen möchten.
Der Standardwert ist 'C', was bedeutet, dass die Elemente des ursprünglichen Arrays in einer C-ähnlichen Indizierungsreihenfolge gelesen werden (beginnend mit 0)
'F' steht für Fortran-like indexing (beginnend mit 1). Und 'EIN' liest die Elemente entweder in C-ähnlicher oder Fortran-ähnlicher Reihenfolge ein, abhängig vom Speicherlayout des Arrays arr.

Also was macht np.reshape() Rückkehr?
Es kehrt zurück umgestaltete Ansicht des ursprünglichen Arrays, falls möglich. Andernfalls wird a zurückgegeben Kopieren des Arrays.

In der obigen Zeile haben wir erwähnt, dass NumPy reshape() würde versuchen, a zurückzugeben view wenn möglich. Andernfalls wird a zurückgegeben Kopieren. Lassen Sie uns nun die Unterschiede zwischen einer Ansicht und einer Kopie besprechen.

Anzeigen vs. Kopieren von NumPy-Arrays

Wie der Name andeutet, Kopieren ist eine Kopie des ursprünglichen Arrays. Und alle an der Kopie vorgenommenen Änderungen werden übernommen nicht betroffen das ursprüngliche Array.

Auf der anderen Seite, view bezieht sich einfach auf die umgeformte Ansicht des ursprünglichen Arrays. Das bedeutet, dass jede Änderung, die an der Ansicht vorgenommen wird, sich auch auf das ursprüngliche Array auswirkt und umgekehrt.

Verwenden Sie NumPy reshape(), um 1D-Arrays in 2D-Arrays umzuformen

# 1. Beginnen wir mit der Erstellung des Beispielarrays mit np.arange().

Wir brauchen ein Array von 12 Zahlen, von 1 bis 12, genannt arr1. Da die Funktion NumPy arange() den Endpunkt standardmäßig ausschließt, setzen Sie den Stoppwert auf 13.

Lassen Sie uns nun die obige Syntax verwenden und umformen arr1 mit 12 Elementen in eine 2D-Formanordnung (4,3). Nennen wir das arr2 mit 4 Zeilen und 3 Spalten.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr2 = np.reshape(arr1,(4,3))
print("\nReshaped array:")
print(arr2)

Werfen wir einen Blick auf die ursprünglichen und umgeformten Arrays.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

Anstatt das Array als Argument zu übergeben np.reshape(), Sie können auch anrufen .reshape() Methode auf dem ursprünglichen Array.

Du kannst rennen dir(arr1), und es werden alle möglichen Methoden und Attribute aufgelistet, die Sie für das Array-Objekt verwenden können arr1.

dir(arr1)

# Output 
[
...
...
'reshape'
...
..
]

In der obigen Codezelle können Sie das sehen .reshape() ist eine gültige Methode, die für das vorhandene NumPy-Array verwendet werden kann arr1.

▶️ Sie können also auch die folgende vereinfachte Syntax verwenden, um NumPy-Arrays umzuformen.

arr.reshape(d0,d1,...,dn)

# where:

# d0, d1,..,dn are the dimensions of the reshaped array

# d0 * d1 * ...* dn = N, the number of elements in arr

Lassen Sie uns für den Rest dieses Tutorials diese Syntax in unseren Beispielen verwenden.

# 2. Lassen Sie uns versuchen, unseren 12-Elemente-Vektor in ein 12 x 1-Array umzuformen.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr3 = arr1.reshape(12,1)
print("\nReshaped array:")
print(arr3)

In der Ausgabe unten können Sie sehen, dass das Array nach Bedarf umgeformt wurde.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]]

❔ Wie überprüfen wir also, ob wir eine Kopie oder Ansicht erhalten haben?

Um dies zu überprüfen, können Sie die anrufen base -Attribut im zurückgegebenen Array.

Wenn das Array eine Kopie ist, wird die base Attribut wird sein None.
Wenn das Array eine Ansicht ist, wird die base Das Attribut ist das ursprüngliche Array.

Lassen Sie uns dies schnell überprüfen.

arr3.base
# Output
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

Wie Sie sehen können, base Attribut von arr3 gibt das ursprüngliche Array zurück. Dies bedeutet, dass wir eine erhalten haben view des ursprünglichen Arrays.

# 3. Versuchen wir nun, den Vektor in ein anderes gültiges 2 x 6-Array umzuformen.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr4 = arr1.reshape(2,6)
print("\nReshaped array:")
print(arr4)

Und hier ist die Ausgabe:

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]

Lassen Sie uns im nächsten Abschnitt umformen arr1 in ein 3D-Array.

Verwenden Sie NumPy reshape(), um 1D-Arrays in 3D-Arrays umzuformen

Umzugestalten arr1 zu einem 3D-Array, lassen Sie uns die gewünschten Dimensionen auf (1, 4, 3) setzen.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr3D = arr1.reshape(1,4,3)
print("\nReshaped array:")
print(arr3D)

Wir haben jetzt ein 3D-Array mit denselben 12 Elementen wie das ursprüngliche Array erstellt arr1.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]]

So beheben Sie Wertfehler während der Umformung

Wenn Sie sich an die Syntax erinnern, ist die Umformung nur gültig, wenn das Produkt der Dimensionen gleich der Anzahl der Elemente im Array ist.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr2D = arr1.reshape(4,4)
print("\nReshaped array:")
print(arr2D)

Hier versuchen Sie, ein 12-Element-Array in ein 4×4-Array mit 16 Elementen umzuformen. Der Interpreter gibt einen Wertfehler aus, wie unten gezeigt.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]
-----------------------------------------------------------
ValueError                                
Traceback (most recent call last)
<ipython-input-11-63552bcc8c37> in <module>()
      6 
      7 # Reshape array
----> 8 arr2 = arr1.reshape(4,4)
      9 print("\nReshaped array:")
     10 print(arr2)

ValueError: cannot reshape array of size 12 into shape (4,4)

Um solche Fehler zu vermeiden, können Sie verwenden -1 um die Form für eine der Dimensionen automatisch abzuleiten – basierend auf der Gesamtzahl der Elemente.

Wenn Sie beispielsweise n – 1 Dimensionen im Voraus kennen, können Sie mit -1 auf die n-te Dimension im umgeformten Array schließen.

Wenn Sie ein Array mit 24 Elementen haben und es in ein 3D-Array umformen möchten. Angenommen, Sie benötigen 3 Zeilen und 4 Spalten. Sie können den Wert -1 entlang der dritten Dimension übergeben.

import numpy as np

arr1 = np.arange(1,25)
print("Original array, before reshaping:\n")
print(arr1)

# Reshape array
arr_res = arr1.reshape(4,3,-1)
print("\nReshaped array:")
print(arr_res)
print(f"Shape of arr_res:{arr_res.shape}")

Wenn Sie die Form des Shape-Arrays untersuchen, können Sie sehen, dass das umgeformte Array entlang der dritten Dimension eine Form von 2 hat.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12 
13 14 15 16 17 18 19 20 21 22 23 24]

Reshaped array:
[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]

 [[13 14]
  [15 16]
  [17 18]]

 [[19 20]
  [21 22]
  [23 24]]]
Shape of arr_res:(4, 3, 2)

Dies ist besonders hilfreich beim Abflachen eines Arrays. Und das erfahren Sie im nächsten Abschnitt.

Verwenden Sie NumPy reshape(), um ein Array zu reduzieren

Es gibt Zeiten, in denen Sie von N-dimensionalen Arrays zu einem abgeflachten Array zurückkehren müssen. Angenommen, Sie möchten ein Bild in einen langen Pixelvektor glätten.

Lassen Sie uns ein einfaches Beispiel mit den folgenden Schritten codieren:

Generieren Sie ein 3 x 3-Graustufen-Bildarray, img_arr– mit Pixeln im Bereich von 0 bis 255.
Als nächstes glätten Sie dies img_arr und drucke das abgeflachte Array aus, flat_arr.
Drucken Sie auch die Formen aus img_arr und flat_arr verifizieren.

img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f"Shape of img_arr: {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f"Shape of flat_arr: {flat_arr.shape}")

Hier ist die Ausgabe.

[[195 145  77]
 [ 63 193 223]
 [215  43  36]]
Shape of img_arr: (3, 3)

[195 145  77  63 193 223 215  43  36]
Shape of flat_arr: (9,)

In der obigen Codezelle können Sie das sehen flat_arr ist ein 1D-Vektor von Pixelwerten mit 9 Elementen.

Zusammenfassung👩‍🏫

Es ist Zeit, schnell zu überprüfen, was wir gelernt haben.

Nutzen Sie den np.reshape(arr, newshape) umzugestalten arr in die in angegebene Form neue Form. neue Form ist ein Tupel, das die Dimensionen des umgeformten Arrays angibt.
Alternativ verwenden arr.reshape(d0, d1, …, dn) umzugestalten arr in Form sein d0 x d1 x … x dn
Überprüfen Sie, ob d0 * d1 * …* dn = N, die Anzahl der Elemente im ursprünglichen Array, um Wertfehler während der Umformung zu vermeiden.
Nutzen Sie den -1 für höchstens eine Bemaßung in der neuen Form, wenn Sie möchten, dass die Bemaßung automatisch abgeleitet wird.
Schließlich können Sie verwenden arr.reshape(-1) um das Array zu glätten.

Nachdem Sie nun wissen, wie Sie NumPy reshape() verwenden, erfahren Sie, wie die NumPy Linspace() Funktion funktioniert.

Sie können die Codebeispiele in ausprobieren Jupyter Notizbuch wenn du willst. Wenn Sie nach anderen Entwicklungsumgebungen suchen, sehen Sie sich unseren Leitfaden an Jupyter-Alternativen.

Veröffentlicht in