NumPy Arrays: Eine Einführung [Mit Beispielen]

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_arr1rufen 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_arr1gibt 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 shapeunter 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_arr1und
• 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) und np.argmin(array) um die Indizes der maximalen bzw. minimalen Elemente zu finden. Erfahren Sie mehr über die NumPy argmax() 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 = 1erhalten 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.