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.
Lassen Sie uns beginnen!
Basics of 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 Rundfunk Fähigkeiten und ermöglichen es uns vektorisieren Operationen für Geschwindigkeit und verwenden Sie integrierte mathematische Funktionen zur Leistungssteigerung.
Um mit NumPy zu arbeiten, sollten Sie zunächst die Bibliothek installieren und in Ihre Arbeitsumgebung importieren. Es ist erhältlich als PyPI-Paket das ist über Pip installierbar.
Um NumPy zu installieren, öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:
pip3 install numpyNach der Installation von NumPy können Sie es unter einem Alias in Ihre Arbeitsumgebung importieren. Der übliche Alias ist np.
import numpy as npHinweis: Importieren von NumPy unter dem Alias
npist keine Voraussetzung, sondern eine empfohlene Konvention.
Python Lists 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 aufrufen np.array() Funktion mit der Liste als Argument.
np_arr1 = np.array(py_list)
print(np_arr1)
[1 2 3 4]Um den Typ zu überprüfen np_arr1, rufen Sie das eingebaute auf type() Funktion, Sie werden sehen, dass es ist ndarray, die grundlegende Datenstruktur in NumPy.
type(np_arr1)
# numpy.ndarrayObwohl die Python-Liste und das NumPy-Array ähnlich aussehen, gibt es gewisse Unterschiede:
- Eine Python-Liste kann Objekte von enthalten anders Datentypen, während ein NumPy-Array Elemente der enthält gleich Datentyp. 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 a gespeichert zusammenhängend Block im Speicher. 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 2 hinzufügen np_arr1 und py_list.
Versuchen wir, 2 zu zu addieren py_list und schau was passiert:
>>> py_list + 2Wir 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 listLassen Sie uns dieselbe Operation auf dem Array versuchen, np_arr1.
>>> np_arr1 + 2Im 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.
Mit einem einfachen + Eine 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 zurück np_arr1 mit sich selbst.
>>> 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]]How to Create NumPy Arrays
Sie können NumPy-Arrays jederzeit aus vorhandenen Python-Listen erstellen, indem Sie verwenden 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 das benutzen zeros() Funktion zum Erstellen eines Arrays von Nullen. Ü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 aus Nullen:
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]Sie können auf die Attribute des NumPy-Arrays zugreifen, Attribute wie aufrufen dtype und shape, unter Verwendung der Punktnotation, wie unten gezeigt:
print(array0.dtype)
# float64
print(array0.shape)
# (3, 3)Um ein Array von Einsen zu erhalten, können Sie die verwenden 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 mehreren Anwendungen in der linearen Algebra häufig verwendet. Und Sie können die verwenden np.eye() Funktion zum Erstellen einer Identitätsmatrix. Das np.eye() Funktion akzeptiert 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.
Dieses randn() Funktion, die Teil von NumPy ist random Modul, kann verwendet werden, um Arrays von Zahlen zu generieren, die aus einem abgetastet werden Standardnormalverteilung. 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 Zahlenbeispielen aus a zurück gleichmäßige Verteilung über dem 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 zufälliger Ganzzahlen erstellen, indem Sie die verwenden randint() Funktion, 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 abgeleitet size -Argument und die Ganzzahlen nehmen Werte im Intervall an [low,high).
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.
Dieses arange() Die Funktion gibt ein Array von Zahlen zwischen a zurück start und stop Wert in Schritten von a step Wert: start, start + step, start + 2*step bis, aber nicht inklusive stopdem „Vermischten Geschmack“. Seine start und 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 bis zu 10 (ohne 0.5) in Schritten von XNUMX gehen.
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 verwenden np.linspace(). Benutzen np.linspace(start, stop, num) um eine Reihe von zu bekommen num gleichmäßig verteilte Zahlen zwischen den start und stop Werte.
Hier arr_lin ist 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. ]Ebenso arr_lin2 ist 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. ]💡 Anders als die arange() Funktion, die linspace() Funktion Dazu gehören der Endpunkt standardmäßig.
Basic Operations on 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 aufrufen
max()Methode auf dem Array-Objekt,int_arr1und - Um das kleinste Element im Array zu finden, können Sie die aufrufen
min()Methode auf dem Array-Objekt,int_arr1.
int_arr1.max()
# 73
int_arr1.min()
# 20Ermitteln 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 anrufen argmax() und argmin() Methoden auf dem Array-Objekt.
Hier tritt das maximale Element 73 bei Index 2 auf.
int_arr1.argmax()
# 2Und das minimale Element 20 tritt bei Index 0 auf.
int_arr1.argmin()
# 0Sie können auch
np.argmax(array)undnp.argmin(array)um die Indizes der maximalen bzw. minimalen Elemente zu finden. Erfahren Sie mehr über die NumPyargmax()Funktion.
How to Concatenate 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 mithilfe von vertikal verketten vstack() Funktion.
Hier ist ein Beispiel. arr1 ist ein Array von Einsen mit zwei Zeilen und drei Spalten und arr2 ist ein Array aus Nullen, zwei Zeilen und drei Spalten.
arr1 = np.ones((2,3))
arr2 = np.zeros((2,3))Wir können diese beiden Arrays mithilfe von vertikal verketten vstack() Funktion wie abgebildet:
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 haben gleich Anzahl der Spalten.
Lass uns ändern arr2 Form haben (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 2Horizontale Verkettung mit hstack
Sie können NumPy-Arrays mit horizontal verketten hstack() Funktion, 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 haben gleich Anzahl der Reihen. Hier beides arr1 und arr2 drei Reihen haben.
array([[1., 1., 1., 0., 0.],
[1., 1., 1., 0., 0.],
[1., 1., 1., 0., 0.]])Verketten verwenden
Sie können auch verkettete NumPy-Arrays entlang einer bestimmten Achse verwenden, indem Sie die verwenden concatenate() Funktion. Legen Sie optional fest axis Argument zu der Achse, entlang der Sie verketten möchten; Die Standard Wert 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 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 folgendes 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 Dimensionen der Arrays entlang der Verkettungsachse sollten ü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 allgemeine Operationen auszuführen, wie z. B. das Finden der minimalen und maximalen Elemente, das Verketten von Arrays und mehr.
Als nächstes lernen Sie, wie NumPy-Arrays umformen.
