In diesem Lernprogramm erfahren Sie, wie Sie NumPy reshape() verwenden, 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 dabei, es einfach zu machen. In den nächsten Minuten lernen Sie die Syntax zur Verwendung von reshape() und auch zum Umformen von Arrays in andere Dimensionen.
Inhaltsverzeichnis
Was ist Reshaping 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 kommt die Umformung ins Spiel.
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 NumPy-Installationsanleitung an.
Sie können jetzt fortfahren und NumPy unter dem Alias np importieren, 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.
- newshape ist die Form des neuen Arrays. Es kann entweder eine ganze Zahl oder ein Tupel sein.
- Wenn newshape eine Ganzzahl ist, ist das zurückgegebene Array eindimensional.
- order 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-ähnliche Indizierung (beginnend mit 1). Und ‚A‘ liest die Elemente entweder in C-ähnlicher oder Fortran-ähnlicher Reihenfolge ein, abhängig vom Speicherlayout des Arrays arr.
Was gibt np.reshape() also zurück?
Es gibt nach Möglichkeit eine umgestaltete Ansicht des ursprünglichen Arrays zurück. Andernfalls wird eine Kopie des Arrays zurückgegeben.
In der obigen Zeile haben wir erwähnt, dass NumPy reshape() versuchen würde, wann immer möglich eine Ansicht zurückzugeben. Andernfalls wird eine Kopie zurückgegeben. Lassen Sie uns nun die Unterschiede zwischen einer Ansicht und einer Kopie besprechen.
Anzeigen vs. Kopieren von NumPy-Arrays
Wie der Name schon sagt, ist copy eine Kopie des ursprünglichen Arrays. Und alle Änderungen, die an der Kopie vorgenommen werden, wirken sich nicht auf das ursprüngliche Array aus.
Auf der anderen Seite bezieht sich Ansicht 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 arr1 mit 12 Elementen in ein 2D-Array der Form (4,3) umformen. Nennen wir dies 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 np.reshape() zu übergeben, können Sie auch die Methode .reshape() für das ursprüngliche Array aufrufen.
Sie können dir(arr1) ausführen, und es listet alle möglichen Methoden und Attribute auf, die Sie für das Array-Objekt arr1 verwenden können.
dir(arr1) # Output [ ... ... 'reshape' ... .. ]
In der obigen Codezelle können Sie sehen, dass .reshape() eine gültige Methode ist, die für das vorhandene NumPy-Array arr1 verwendet werden kann.
▶️ 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 das Basisattribut für das zurückgegebene Array aufrufen.
- Wenn das Array eine Kopie ist, ist das Basisattribut None.
- Wenn das Array eine Ansicht ist, ist das Basisattribut 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, gibt das Basisattribut von arr3 das ursprüngliche Array zurück. Dies bedeutet, dass wir eine Ansicht des ursprünglichen Arrays erhalten haben.
#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 arr1 in ein 3D-Array umformen.
Verwenden Sie NumPy reshape(), um 1D-Arrays in 3D-Arrays umzuformen
Um arr1 in ein 3D-Array umzuformen, setzen wir die gewünschten Dimensionen auf (1, 4, 3).
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 den gleichen 12 Elementen wie das ursprüngliche Array arr1 erstellt.
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 debuggen 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 -1 verwenden, 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 glätten
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 dieses img_arr und drucken Sie das reduzierte Array flat_arr aus.
- Drucken Sie zur Überprüfung auch die Formen von img_arr und flat_arr aus.
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 sehen Sie, dass flat_arr ein 1D-Vektor von Pixelwerten mit 9 Elementen ist.
Zusammenfassung👩🏫
Es ist Zeit, schnell zu überprüfen, was wir gelernt haben.
- Verwenden Sie np.reshape(arr, newshape), um arr in die in newshape angegebene Form umzuformen. newshape ist ein Tupel, das die Dimensionen des umgeformten Arrays angibt.
- Verwenden Sie alternativ arr.reshape(d0, d1, …, dn), um arr in die Form d0 x d1 x … x dn umzuformen
- Überprüfen Sie, ob d0 * d1 * …* dn = N, die Anzahl der Elemente im ursprünglichen Array, um Wertfehler während der Umformung zu vermeiden.
- Verwenden Sie -1 für höchstens eine Dimension in der neuen Form, wenn Sie möchten, dass die Dimension automatisch abgeleitet wird.
- Schließlich können Sie arr.reshape(-1) verwenden, um das Array zu glätten.
Nachdem Sie nun wissen, wie NumPy reshape() verwendet wird, erfahren Sie, wie die NumPy-Funktion linspace() funktioniert.
Sie können die Codebeispiele im Jupyter-Notebook ausprobieren, wenn Sie möchten. Wenn Sie nach anderen Entwicklungsumgebungen suchen, sehen Sie sich unseren Leitfaden zu Jupyter-Alternativen an.