Möchten Sie mit NumPy beginnen? In diesem Leitfaden lernen Sie die Grundlagen von NumPy-Arrays in Python kennen.
In einem 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 mit ihnen durchzuführen.
Fangen wir an!
Grundlagen von NumPy-Arrays
NumPy ist eine der beliebtesten Python-Bibliotheken für wissenschaftliche Berechnungen und Datenanalysen. Die grundlegenden Datenstrukturen in NumPy sind N-dimensionale Arrays (N-D-Arrays). Sie haben Übertragung Fähigkeiten und ermöglichen es uns vektorisieren Operationen zu beschleunigen und integrierte mathematische Funktionen zur Leistungssteigerung zu verwenden.
Um mit NumPy arbeiten zu können, sollten Sie die Bibliothek zunächst installieren und in Ihre Arbeitsumgebung importieren. Sie ist verfügbar als PyPI-Paket 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 lautet np
.
import numpy as np
Hinweis: NumPy unter dem Alias importieren
np
ist keine Vorschrift, sondern eine empfohlene Konvention.
Python-Listen vs. NumPy-Arrays
Betrachten Sie die folgende Python-Liste von Zahlen:
py_list = [1,2,3,4]
Sie können ein NumPy-Array aus einer bestehenden Liste erhalten, indem Sie die np.array()
Funktion mit der Liste als Argument.
np_arr1 = np.array(py_list)
print(np_arr1)
[1 2 3 4]
Zur Überprüfung des Typs der np_arr1
rufen Sie das integrierte type()
Funktion, werden Sie sehen, dass es sich um ndarray
, die grundlegende Datenstruktur in NumPy.
type(np_arr1)
# numpy.ndarray
Obwohl die Python-Liste und das NumPy-Array ähnlich aussehen mögen, gibt es gewisse Unterschiede:
- Eine Python-Liste kann Objekte der folgenden Kategorien enthalten verschiedene Datentypen enthält, während ein NumPy-Array Elemente der dieselbe Datentyp. Der Standarddatentyp ist Float mit einer Genauigkeit von 64 Bit (float64).
- Die Elemente einer Python-Liste werden nicht unbedingt an zusammenhängenden Stellen im Speicher gespeichert. Die Elemente eines NumPy-Arrays werden jedoch in einem Angrenzend Block im Speicher. Dadurch wird das Aufsuchen von und der Zugriff auf Elemente beschleunigt.
Gehen wir noch auf ein paar andere Unterschiede ein.
Rundfunk und Fernsehen
Eine leistungsstarke Funktion von NumPy-Arrays ist das Broadcasting. Nehmen wir an, wir möchten 2 zu allen Elementen von np_arr1
und py_list
.
Versuchen wir, 2 zu addieren py_list
und 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 wie hier nicht unterstützt wird.
---------------------------------------------------------------------------
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 den gleichen Vorgang mit dem Array, np_arr1
.
>>> np_arr1 + 2
Das Ergebnis zeigt, dass zu jedem Element des Arrays 2 hinzugefügt wurde.
array([3, 4, 5, 6])
Das liegt daran, dass NumPy den Skalar 2 implizit in ein Array mit kompatibler Form übertragen hat, um dieses Ergebnis zu erhalten.
Vektorisierung
NumPy-Arrays unterstützen Vektorisierung für schnellere Element-weise Operationen. Angenommen, wir möchten die elementweise Summe der beiden Arrays finden.
Mit einer einfachen +
Operation auf die Liste würde die Verkettung der beiden Listen zurückgeben (was nicht das ist, was wir wollen!).
>>> py_list + py_list
# [1, 2, 3, 4, 1, 2, 3, 4]
Aber die gleiche Operation mit dem NumPy-Array, np_arr1
gibt die elementweise Summe von np_arr1
mit sich selbst.
>>> np_arr1 + np_arr1
# array([2, 4, 6, 8])
In ähnlicher Weise können verschachtelte Listen ähnlich aufgebaut sein wie ein N-dimensionales NumPy-Array. Die bisher besprochenen 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]]
Wie man NumPy-Arrays erstellt
Sie können jederzeit NumPy-Arrays aus bestehenden Python-Listen erstellen, indem Sie np.array(list-obj)
. Dies ist jedoch nicht der effizienteste Weg.
Stattdessen können Sie mehrere integrierte Funktionen verwenden, mit denen Sie Arrays einer bestimmten Form erstellen können. Die Form des Arrays ist ein Tupel, das die Größe des Arrays in jeder Dimension angibt. Die Form eines 2×2-Arrays mit zwei Zeilen und zwei Spalten ist zum Beispiel (2,2). In diesem Abschnitt werden wir lernen, wie man einige dieser eingebauten Funktionen verwendet.

Arrays aus Nullen und Einsen erstellen
Es ist oft hilfreich, ein Array mit bestimmten Dimensionen zu erstellen, das mit allen Nullen oder allen Einsen gefüllt ist. Diese können Sie dann in den nachfolgenden Programmschritten verwenden und ändern.
Wir können die zeros()
Funktion, um ein Array von Nullen zu erstellen. Geben Sie die Form des gewünschten Arrays als Tupel ein: 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, indem Sie Attribute wie dtype
und shape
unter Verwendung der Punktnotation, wie unten dargestellt:
print(array0.dtype)
# float64
print(array0.shape)
# (3, 3)
Um ein Array von Einsen zu erhalten, können Sie die np.ones()
Funktion.
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 verschiedenen Anwendungen der linearen Algebra häufig verwendet. Und Sie können die np.eye()
Funktion, um eine Identitätsmatrix zu erstellen. Die np.eye()
Funktion nimmt nur ein Argument entgegen: die Reihenfolge der Matrix (n
).
arrayi = np.eye(3)
print(arrayi)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
Arrays von Zufallszahlen erstellen
Sie können auch Arrays mit einer bestimmten Form erstellen, die mit Zufallszahlen aus bestimmten Verteilungen gefüllt werden. Die am häufigsten verwendeten Wahrscheinlichkeitsverteilungen sind die Gleichverteilung und die Standardnormalverteilung.
Die randn()
Funktion, die Teil von NumPy's random
kann verwendet werden, um Arrays von Zahlen zu erzeugen, die aus einer Standard-Normalverteilung. Die Standardnormalverteilung ist eine Gaußsche Verteilung mit Mittelwert Null und 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 Zahlen zurück, die aus einer gleichmäßige Verteilung über das Intervall [0,1).
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 mit zufälligen Ganzzahlen erstellen, indem Sie die randint()
Funktion, die Teil des Zufallsmoduls von NumPy ist. np.random.randint(low, high, size)
gibt ein Array von Ganzzahlen zurück. Die Form des Arrays wird aus der size
Argument und die ganzen Zahlen nehmen Werte im Intervall [low,high)
.
Hier ist ein Beispiel:
int_arr = np.random.randint(1,100,(2,3))
print(int_arr)
[[53 89 33]
[24 85 33]]
Weitere nützliche integrierte Funktionen
Als Nächstes wollen wir uns einige andere hilfreiche Funktionen zur Erstellung von NumPy-Arrays ansehen.
Die arange()
Funktion gibt ein Array von Zahlen zwischen einem start
und stop
Wert in Schritten von a step
Wert: start
, start + step
, start + 2*step
bis zu, aber nicht einschließlich stop
. Die start
und die step
Werte sind optional. Die Standardschrittweite ist 1 und der Standardstartwert ist 0.
In diesem Beispiel, array_a
ist eine Reihe von Zahlen, die bei 1 beginnen und in 0,5er-Schritten bis zu 10 reichen, aber 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 auch Arrays mit gleichmäßig verteilten Zahlen erstellen, indem Sie np.linspace()
. Verwenden Sie np.linspace(start, stop, num)
um ein Array von num
gleichmäßig verteilte Zahlen zwischen den start
und stop
Werte.
Hier, arr_lin
ist ein Feld von 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. ]
Ähnlich, arr_lin2
ist ein Feld von 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. ]
💡 Anders als die arange()
Funktion, die linspace()
Funktion enthält den Endpunkt standardmäßig.
Grundlegende Operationen auf NumPy-Arrays
Als Nächstes wollen wir einige der grundlegenden Operationen mit NumPy-Arrays durchgehen.
Suche nach dem Minimum und Maximum der Elemente
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 festlegen: np.random.seed(seed_value)
.
Im folgenden Beispiel habe ich die Saat für die Reproduzierbarkeit gesetzt, int_arr1
ist ein Array von sieben zufälligen Ganzzahlen 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 in einem Array zu finden, können Sie die Funktion
max()
Methode auf das Array-Objekt,int_arr1
und - Um das kleinste Element im Array zu finden, können Sie die Funktion
min()
Methode auf das Array-Objekt,int_arr1
.
int_arr1.max()
# 73
int_arr1.min()
# 20
Suche nach dem Index der maximalen und minimalen Elemente
Manchmal müssen Sie den Index des maximalen und des minimalen Elements finden. Zu diesem Zweck können Sie die Funktion argmax()
und die argmin()
Methoden auf das Array-Objekt.
Hier liegt das maximale Element 73 bei Index 2.
int_arr1.argmax()
# 2
Und das kleinste Element 20 befindet sich bei Index 0.
int_arr1.argmin()
# 0
Sie können auch Folgendes verwenden
np.argmax(array)
undnp.argmin(array)
um die Indizes der maximalen bzw. minimalen Elemente zu finden. Erfahren Sie mehr über die NumPyargmax()
Funktion.
Wie man NumPy-Arrays verkettet
Eine weitere häufige Operation, die Sie mit NumPy-Arrays durchführen möchten, ist die Verkettung.
Vertikale Verkettung mit vstack
Sie können Arrays vertikal verketten, indem Sie die vstack()
Funktion.
Hier ist ein Beispiel. arr1
ist eine Reihe von Einsen mit zwei Zeilen und drei Spalten und arr2
ist ein Array von Nullen mit zwei Zeilen und drei Spalten.
arr1 = np.ones((2,3))
arr2 = np.zeros((2,3))
Wir können diese beiden Arrays vertikal verketten, indem wir die vstack()
Funktion wie gezeigt:
np.vstack((arr1,arr2))
array([[1., 1., 1.],
[1., 1., 1.],
[0., 0., 0.],
[0., 0., 0.]])
Da die Stapelung vertikal erfolgt, sollten die beiden Arrays die dieselbe Anzahl von Spalten.
Ändern wir arr2
in die Form (2,2) bringen. Sie hat nun 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 horizontal verketten, indem Sie die hstack()
Funktion, wie unten dargestellt.
arr1 = np.ones((3,3))
arr2 = np.zeros((3,2))
np.hstack((arr1,arr2))
Da die Stapelung horizontal erfolgt, sollten die Eingabefelder die dieselbe Anzahl von Zeilen. Hier sind beide arr1
und arr2
haben drei Reihen.
array([[1., 1., 1., 0., 0.],
[1., 1., 1., 0., 0.],
[1., 1., 1., 0., 0.]])
Verkettung verwenden
Sie können auch die Verkettung von NumPy-Arrays entlang einer bestimmten Achse verwenden, indem Sie die concatenate()
Funktion. Stellen Sie das optionale axis
Argument auf die Achse, entlang der Sie verketten möchten; das Standard Wert der Achse ist Null.
Hier sind einige 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. In dem resultierenden Array wird das zweite Array arr2
wird (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 angeben axis = 1
erhalten wir das folgende Ergebnis. arr2
wird (als Spalten) neben dem ersten Array verkettet, arr1
.
np.concatenate((arr1,arr2),axis=1)
array([[1., 1., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0.]])
Wie bei der hstack()
und vstack()
Funktionen, die Abmessungen der Arrays entlang der Verkettungsachse sollte mit.
Schlussfolgerung
In diesem Tutorium 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 lag.
Sie haben auch einige nützliche Funktionen kennengelernt, mit denen Sie Arrays einer bestimmten Dimension erstellen und allgemeine Operationen durchführen können, z. B. die Ermittlung des Minimums und des Maximums von Elementen, die Verkettung von Arrays und vieles mehr.
Als nächstes lernen Sie, wie man NumPy-Arrays umgestalten.