So erstellen Sie eine Website oder ein Blog im Jahr 2020 - Kostenlose und einfache Anleitung zum Erstellen einer Website

wie man NumPy-Arrays in Python umformt

In diesem Tutorial erfahren Sie, wie Sie es verwenden NumPy reshape() um NumPy-Arrays umzuformen, ohne die Originaldaten zu ändern.

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

Und NumPy reshape() hilft Ihnen dabei, dies ganz einfach zu tun. In den nächsten Minuten lernen Sie die Syntax für die Verwendung von reshape() kennen und lernen auch, Arrays in andere Dimensionen umzuformen.

Was ist Umformung in NumPy-Arrays?

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

Dies ist besonders nützlich, wenn die Abmessungen des neuen Arrays zunächst nicht bekannt sind oder während der Ausführung abgeleitet werden. Oder es kann auch sein, dass ein bestimmter Datenverarbeitungsschritt eine bestimmte Form der Eingabe erfordert.

das ist wo Reorganisation Es kommt sehr gut an.

Betrachten Sie beispielsweise die folgende Abbildung. Wir haben einen Vektor: ein eindimensionales Array aus 6 Elementen. Und wir können es in 2×3-, 3×2-, 6×1-Formanordnungen usw. umformen.

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

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

Lassen Sie uns im nächsten Abschnitt mit dem Erlernen der Syntax fortfahren.

NumPy-Syntax-Reshape()

Dies 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 die Matrix, die umgestaltet werden soll.
  • neuer Weg ist die Form der neuen Matrix. Es kann eine Ganzzahl oder ein Tupel sein.
  • Wann neuer Weg eine Ganzzahl ist, ist das zurückgegebene Array eindimensional.
  • Befehl bezieht sich auf die Reihenfolge, in der Sie die umzugestaltenden Array-Elemente lesen möchten.
  • Der Standardwert ist ‘C’, Dies bedeutet, dass die Elemente des ursprünglichen Arrays in einer C-ähnlichen Indexierungsreihenfolge gelesen werden (beginnend mit 0).
  • ‘F’ bedeutet Fortran-ähnliche Indizierung (beginnend mit 1). UND ‘ZU’ Liest Elemente in ähnlicher Reihenfolge wie C oder Fortran, abhängig vom Speicherlayout des Arrays Arr.

Was gibt np.reshape() zurück?

gibt a zurück umgestaltete Ansicht wenn möglich aus der Originalmatrix. Andernfalls wird a zurückgegeben Kopieren aus der Matrix

In der vorherigen Zeile haben wir erwähnt, dass NumPy reshape() versuchen würde, a zurückzugeben Sicht wenn es möglich ist. Andernfalls wird a zurückgegeben Kopieren. Lassen Sie uns mit der Diskussion der Unterschiede zwischen einer Ansicht und einer Kopie fortfahren.

Siehe vs. Kopieren Sie NumPy-Arrays

Wie der Name schon sagt, Kopieren Es ist eine Kopie des ursprünglichen Arrays. Und alle an der Kopie vorgenommenen Änderungen gelten für das ursprüngliche Array.

Außerdem, Sicht es bezieht sich lediglich auf die umgestaltete Ansicht des ursprünglichen Arrays. Das bedeutet, dass sich alle an der Ansicht vorgenommenen Änderungen auch auf das ursprüngliche Array auswirken und umgekehrt.

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

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

Wir benötigen ein Array mit 12 Zahlen, 1 bis 12, namens arr1. Da die NumPy-Funktion arange() den Endpunkt standardmäßig ausschließt, legen Sie den Stoppwert auf 13 fest.

Nun verwenden wir die obige Syntax und formen arr1 mit 12 Elementen in ein 2D-Array der Form (4,3) um. 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 Original- und umgestalteten Stempel.

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 an 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 werden alle möglichen Methoden und Attribute aufgelistet, die Sie für das Array-Objekt arr1 verwenden können.

dir(arr1)

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

In der Codezelle oben können Sie sehen, dass .reshape() eine gültige Methode zur Verwendung auf dem vorhandenen NumPy-Array arr1 ist.

▶️ 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

Für den Rest dieses Tutorials verwenden wir diese Syntax in unseren Beispielen.

#2. Versuchen wir, unseren 12-Elemente-Vektor in eine 12 x 1-Matrix 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 umgestaltet 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 eine Ansicht erhalten haben?

Um dies zu überprüfen, können Sie das Basisattribut des zurückgegebenen Arrays aufrufen.

  • Wenn es sich bei dem Array um eine Kopie handelt, lautet das Basisattribut None.
  • Wenn es sich bei dem Array um eine Ansicht handelt, ist das Basisattribut das ursprüngliche Array.

Lassen Sie uns das 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 der ursprünglichen Matrix erhalten haben.

#3. Versuchen wir nun, den Vektor in eine andere gültige 2 x 6-Matrix 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]]

Im nächsten Abschnitt verwandeln wir arr1 in ein 3D-Array.

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

Um arr1 in ein 3D-Array umzuformen, legen wir die gewünschten Abmessungen auf (1, 4, 3) fest.

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 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 beheben Sie Wertfehler während der Umgestaltung

Wenn Sie sich an die Syntax erinnern, ist die Umformung nur dann 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-Elemente-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)
 in ()
      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 automatisch die Form einer der Dimensionen basierend auf der Gesamtzahl der Elemente abzuleiten.

Wenn Sie beispielsweise n – 1 Dimensionen im Voraus kennen, können Sie mit -1 auf die n-te Dimension in der umgeformten Matrix 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 Formarrays untersuchen, können Sie erkennen, dass das umgeformte Array in der dritten Dimension die Form 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 nützlich, um eine Matrix abzuflachen. 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 reduzieren.

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

  • Erzeugen Sie eine 3 x 3-Graustufenbildmatrix, img_arr, mit Pixeln im Bereich von 0 bis 255.
  • Als nächstes reduzieren Sie dieses img_arr und drucken das reduzierte Array flat_arr.
  • Drucken Sie zur Überprüfung auch die Formulare 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 der Ausweg.

[[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 Codezelle oben können Sie sehen, dass flat_arr ein 1D-Vektor aus Pixelwerten mit 9 Elementen ist.

Zusammenfassend👩‍🏫

Es ist an der Zeit, das Gelernte kurz zu wiederholen.

  • Tragen np.reshape(arr, neue Form) umgestalten Arr in der in angegebenen Weise neuer Weg. neuer Weg ist ein Tupel, das die Abmessungen des umgeformten Arrays angibt.
  • Alternativ verwenden Sie array.reform(d0, d1, …, dn) umgestalten Arr In Form sein d0 x d1 x … x dn
  • Überprüfen Sie, ob d0 * d1 * …* dn = ndie Anzahl der Elemente im ursprünglichen Array, um Wertfehler während der Umformung zu vermeiden.
  • Tragen -1 für höchstens eine Dimension im neuen Formular, wenn die Dimension automatisch abgeleitet werden soll.
  • Endlich können Sie es verwenden Reformbeginn(-1) um die Matrix abzuflachen.

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

Wenn Sie möchten, können Sie die Codebeispiele im Jupyter Notebook ausprobieren. Wenn Sie nach anderen Entwicklungsumgebungen suchen, lesen Sie unseren Leitfaden zu Jupyter-Alternativen.