NumPy-Arrays: Eine Einführung [mit Beispielen]

Möchten Sie mit NumPy loslegen? In diesem Handbuch lernen Sie die Grundlagen von NumPy-Arrays in Python kennen.

Als ersten Schritt lernen Sie, wie NumPy-Arrays anders funktionieren als Python-Listen. Anschließend lernen Sie verschiedene Möglichkeiten kennen, NumPy-Arrays zu erstellen und grundlegende Operationen an ihnen auszuführen.

Lass uns anfangen!

Grundlagen von NumPy-Arrays

NumPy ist eine der beliebtesten Python-Bibliotheken für wissenschaftliches Rechnen und Datenanalyse. Die grundlegenden Datenstrukturen in NumPy sind N-dimensionale Arrays (ND-Arrays). Sie haben Broadcasting -Fähigkeiten und ermöglichen es uns, Operationen für Geschwindigkeit zu vektorisieren und integrierte mathematische Funktionen zur Leistungsverbesserung zu verwenden.

Um mit NumPy zu arbeiten, sollten Sie zunächst die Bibliothek installieren und in Ihre Arbeitsumgebung importieren. Es ist als PyPI-Paket verfügbar, das über Pip installiert werden kann.

Um NumPy zu installieren, öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

 pip3 install numpy

Nach der Installation von NumPy können Sie es unter einem Alias ​​in Ihre Arbeitsumgebung importieren. Der übliche Alias ​​ist np .

 import numpy as np

Hinweis : Das Importieren von NumPy unter dem Alias np ist keine Voraussetzung, sondern eine empfohlene Konvention.

Python-Listen vs. NumPy-Arrays

Betrachten Sie die folgende Python-Liste mit Zahlen:

 py_list = [1,2,3,4]

Sie können ein NumPy-Array aus einer vorhandenen Liste abrufen, indem Sie die Funktion np.array() mit der Liste als Argument aufrufen.

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

Um den Typ von np_arr1 zu überprüfen, rufen Sie die eingebaute Funktion type() auf, Sie werden sehen, dass es ndarray ist, die grundlegende Datenstruktur in NumPy.

 type(np_arr1) # numpy.ndarray

Obwohl die Python-Liste und das NumPy-Array ähnlich aussehen, gibt es gewisse Unterschiede:

• Eine Python-Liste kann Objekte verschiedener Datentypen enthalten, während ein NumPy-Array Elemente desselben Datentyps enthält. Der Standarddatentyp ist Float mit einer Genauigkeit von 64 Bit (float64).
• Die Elemente einer Python-Liste werden nicht unbedingt an zusammenhängenden Speicherorten gespeichert. Die Elemente eines NumPy-Arrays werden jedoch in einem zusammenhängenden Block im Arbeitsspeicher gespeichert. Dadurch ist es schneller, Elemente nachzuschlagen und darauf zuzugreifen.

Lassen Sie uns ein paar andere Unterschiede durchgehen.

Rundfunk

Eine leistungsstarke Funktion von NumPy-Arrays ist das Broadcasting. Angenommen, wir möchten allen Elementen von np_arr1 und py_list 2 hinzufügen.

Lassen Sie uns versuchen, 2 zu py_list und zu sehen, was passiert:

 >>> py_list + 2

Wir sehen, dass wir einen TypeError erhalten, der besagt, dass wir nur zwei Listen verketten können, und das Hinzufügen von py_list + 2 auf diese Weise wird nicht unterstützt.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

Versuchen wir dieselbe Operation für das Array np_arr1 .

 >>> np_arr1 + 2

Im Ergebnis sehen wir, dass jedem Element des Arrays 2 hinzugefügt wurde.

 array([3, 4, 5, 6])

Dies liegt daran, dass NumPy den Skalar 2 implizit an ein Array mit kompatibler Form gesendet hat, um dieses Ergebnis zu erzielen.

Vektorisierung

NumPy-Arrays unterstützen die Vektorisierung für schnellere elementweise Operationen. Angenommen, wir möchten die elementweise Summe der beiden Arrays ermitteln.

Die Verwendung einer einfachen + -Operation auf der Liste würde die Verkettung der beiden Listen zurückgeben (was wir nicht wollen!).

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

Aber die gleiche Operation auf dem NumPy-Array, np_arr1 , gibt die elementweise Summe von np_arr1 mit sich selbst zurück.

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

In ähnlicher Weise können verschachtelte Listen in ihrer Struktur einem N-dimensionalen NumPy-Array ähneln. Die bisher diskutierten Unterschiede bleiben jedoch bestehen.

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

So erstellen Sie NumPy-Arrays

Sie können NumPy-Arrays jederzeit aus vorhandenen Python-Listen erstellen, indem np.array(list-obj) . Dies ist jedoch nicht der effizienteste Weg.

Stattdessen können Sie mehrere integrierte Funktionen verwenden, mit denen Sie Arrays mit einer bestimmten Form erstellen können. Die Form des Arrays ist ein Tupel, das die Größe des Arrays entlang jeder Dimension angibt. Beispielsweise ist die Form eines 2×2-Arrays mit zwei Zeilen und zwei Spalten (2,2). In diesem Abschnitt erfahren Sie, wie Sie einige dieser integrierten Funktionen verwenden.

Erstellen von Arrays aus Nullen und Einsen

Es ist oft hilfreich, ein Array spezifischer Dimensionen zu erstellen, die nur mit Nullen oder nur mit Einsen gefüllt sind. Und dann verwenden und ändern Sie sie in den nachfolgenden Schritten im Programm.

Wir können die Funktion zeros() verwenden, um ein Array von Nullen zu erstellen. Übergeben Sie die Form des erforderlichen Arrays als Tupel: np.zeros(shape) .

 array0 = np.zeros((3,3)) print(array0)

Hier ist die Ausgabe, ein 2D-Array von Nullen:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

Sie können auf die Attribute des NumPy-Arrays zugreifen und Attribute wie dtype und shape aufrufen, indem Sie die Punktnotation verwenden, wie unten gezeigt:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

Um ein Array von Einsen zu erhalten, können Sie die Funktion np.ones() verwenden.

 array1 = np.ones((3,3)) print(array1)

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

Erstellen einer Identitätsmatrix

Die Identitätsmatrix wird in mehreren Anwendungen in der linearen Algebra häufig verwendet. Und Sie können die Funktion np.eye() verwenden, um eine Identitätsmatrix zu erstellen. Die Funktion np.eye() nur ein Argument: die Reihenfolge der Matrix ( n ).

 arrayi = np.eye(3) print(arrayi)

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

Erstellen von Arrays von Zufallszahlen

Sie können auch Arrays mit einer bestimmten Form erstellen, die mit Zufallszahlen aus bestimmten Verteilungen gefüllt sind. Die am häufigsten verwendeten Wahrscheinlichkeitsverteilungen sind die Gleichverteilung und die Standardnormalverteilung.

Die Funktion randn() , die Teil des random von NumPy ist, kann verwendet werden, um Arrays von Zahlen zu generieren, die aus einer Standardnormalverteilung entnommen werden . Die Standardnormalverteilung ist eine Gaußsche Verteilung mit einem Mittelwert von null und einer Einheitsvarianz.

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() gibt ein Array von Zahlenmustern aus einer gleichmäßigen Verteilung über das Intervall [0,1) zurück.

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

Sie können auch ein Array zufälliger Ganzzahlen erstellen, indem Sie die Funktion randint() verwenden, die Teil des Zufallsmoduls von NumPy ist. np.random.randint(low, high, size) gibt ein Array von ganzen Zahlen zurück. Die Form des Arrays wird aus dem size abgeleitet und die Ganzzahlen nehmen Werte im Intervall [low,high) an.

Hier ist ein Beispiel:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

Andere nützliche integrierte Funktionen

Lassen Sie uns als Nächstes einige andere hilfreiche Funktionen zum Erstellen von NumPy-Arrays durchgehen.

Die Funktion arange() gibt ein Array von Zahlen zwischen einem start und einem stop in Schritten eines step zurück: start , start + step , start + 2*step up to but not using stop . Die start und step sind optional . Die Standardschrittweite ist 1 und der Standardstartwert ist 0.

In diesem Beispiel ist array_a ein Array von Zahlen, die bei 1 beginnen und in Schritten von 0,5 bis zu 10 reichen, diese jedoch nicht einschließen.

 array_a = np.arange(1,10,0.5) print(array_a)

 [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

Sie können mit np.linspace() auch Arrays mit gleichmäßig verteilten Zahlen erstellen. Verwenden Sie np.linspace(start, stop, num) , um ein Array von num -Zahlen mit gleichmäßigen Abständen zwischen den start und stop zu erhalten.

Hier ist arr_lin ein Array aus 5 gleichmäßig verteilten Zahlen im Intervall [1,10].

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

In ähnlicher Weise ist arr_lin2 ein Array aus 10 gleichmäßig verteilten Zahlen im Intervall [1,20].

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

Im Gegensatz zur Funktion arange() linspace() standardmäßig den Endpunkt.

Grundlegende Operationen auf NumPy-Arrays

Lassen Sie uns als Nächstes einige der grundlegenden Operationen auf NumPy-Arrays durchgehen.

Finden der minimalen und maximalen Elemente

Immer wenn wir Funktionen aus dem Zufallsmodul von NumPy verwenden, um Arrays zu erstellen, erhalten wir bei jeder Ausführung des Codes ein anderes Ergebnis. Um reproduzierbare Ergebnisse zu erhalten, sollten wir einen Seed setzen: np.random.seed(seed_value) .

Im folgenden Beispiel habe ich den Startwert für die Reproduzierbarkeit gesetzt, int_arr1 ist ein Array aus sieben zufälligen ganzen Zahlen im Intervall [1.100).

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• Um das maximale Element im Array zu finden, können Sie die Methode max() für das Array-Objekt int_arr1 und aufrufen
• Um das kleinste Element im Array zu finden, können Sie die Methode min() für das Array-Objekt int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

Ermitteln des Index der maximalen und minimalen Elemente

Manchmal müssen Sie möglicherweise den Index der maximalen und minimalen Elemente finden. Dazu können Sie die Methoden argmax() und argmin() für das Array-Objekt aufrufen.

Hier tritt das maximale Element 73 bei Index 2 auf.

 int_arr1.argmax() # 2

Und das minimale Element 20 tritt bei Index 0 auf.

 int_arr1.argmin() # 0

Sie können auch np.argmax(array) und np.argmin(array) verwenden, um die Indizes der maximalen bzw. minimalen Elemente zu finden. Erfahren Sie mehr über die Funktion NumPy argmax() .

So verketten Sie NumPy-Arrays

Eine weitere häufige Operation, die Sie möglicherweise mit NumPy-Arrays durchführen möchten, ist die Verkettung.

Vertikale Verkettung mit vstack

Sie können Arrays mit der Funktion vstack() vertikal verketten.

Hier ist ein Beispiel. arr1 ist ein Array aus Einsen mit zwei Zeilen und drei Spalten und arr2 ist ein Array aus Nullen mit zwei Zeilen und drei Spalten.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Wir können diese beiden Arrays mit der Funktion vstack() wie gezeigt vertikal verketten:

 np.vstack((arr1,arr2))

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

Da das Stapeln vertikal erfolgt, sollten die beiden Arrays die gleiche Anzahl von Spalten haben.

Ändern arr2 in die Form (2,2). Es hat jetzt zwei Zeilen und zwei Spalten.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

Daher ist eine vertikale Verkettung nicht möglich und wir erhalten einen ValueError.

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

Horizontale Verkettung mit hstack

Sie können NumPy-Arrays mit der Funktion hstack() horizontal verketten, wie unten gezeigt.

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

Da das Stapeln horizontal erfolgt, sollten die Eingabearrays die gleiche Anzahl von Zeilen haben. Hier haben sowohl arr1 als auch arr2 drei Zeilen.

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

Verketten verwenden

Sie können auch NumPy-Arrays entlang einer bestimmten Achse verketten, indem Sie die Funktion concatenate() verwenden. Legen Sie das optionale axis auf die Achse fest, entlang der Sie verketten möchten; der Standardwert der Achse ist Null.

Hier sind ein paar Beispiele:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Wenn wir die zu verkettende Achse nicht angeben, werden die Arrays entlang der Achse 0 verkettet. Im resultierenden Array wird das zweite Array arr2 (als Zeilen) unterhalb des ersten Arrays hinzugefügt.

 np.concatenate((arr1,arr2))

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

Wenn wir axis = 1 angeben, erhalten wir das folgende Ergebnis. arr2 wird (als Spalten) neben dem ersten Array arr1 .

 np.concatenate((arr1,arr2),axis=1)

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

Wie bei den Funktionen hstack() und vstack() sollten die Dimensionen der Arrays entlang der Verkettungsachse übereinstimmen .

Fazit

In diesem Tutorial haben Sie die Unterschiede zwischen NumPy-Arrays und Python-Listen kennengelernt, wobei der Schwerpunkt auf den Vorteilen von N-dimensionalen Arrays in Bezug auf Geschwindigkeit und Effizienz liegt.

Sie haben auch mehrere nützliche Funktionen kennengelernt, um Arrays einer bestimmten Dimension zu erstellen und gängige Operationen auszuführen, wie z. B. das Finden der minimalen und maximalen Elemente, das Verketten von Arrays und mehr.

Als Nächstes erfahren Sie, wie Sie NumPy-Arrays umformen.