Vorwort des Übersetzers
Hallo nochmal! Fortsetzung unserer Artikelserie über die Übersetzung von Mana über Numpy. Viel Spaß beim Lesen.
Vergleichsoperatoren und Wertetests
Der Boolesche Vergleich kann zum elementweisen Vergleich von Arrays gleicher Länge verwendet werden. Der Rückgabewert ist ein Array von booleschen True / False-Werten:
>>> a = np.array([1, 3, 0], float) >>> b = np.array([0, 3, 2], float) >>> a > b array([ True, False, False], dtype=bool) >>> a == b array([False, True, False], dtype=bool) >>> a <= b array([False, True, True], dtype=bool)
Das Vergleichsergebnis kann in einem Array gespeichert werden:
>>> c = a > b >>> c array([ True, False, False], dtype=bool)
Arrays können mit einem einzelnen Wert verglichen werden:
>>> a = np.array([1, 3, 0], float) >>> a > 2 array([False, True, False], dtype=bool)
Mit den beliebigen Operatoren kann bestimmt werden, ob mindestens eines oder alle Elemente wahr sind:
>>> c = np.array([ True, False, False], bool) >>> any(c) True >>> all(c) False
Kombinierte boolesche Ausdrücke können mit den Sonderfunktionen logisch_und, logisch_oder und logisch_nicht Element für Element auf Arrays angewendet werden:
>>> a = np.array([1, 3, 0], float) >>> np.logical_and(a > 0, a < 3) array([ True, False, False], dtype=bool) >>> b = np.array([True, False, True], bool) >>> np.logical_not(b) array([False, True, False], dtype=bool) >>> c = np.array([False, True, False], bool) >>> np.logical_or(b, c) array([ True, True, False], dtype=bool)
Die where-Funktion erstellt ein neues Array aus zwei anderen Arrays gleicher Länge mithilfe eines Booleschen Filters, um zwischen zwei Elementen auszuwählen. Grundlegende Syntax: where (boolarray,
truearray, falsearray):
>>> a = np.array([1, 3, 0], float) >>> np.where(a != 0, 1 / a, a) array([ 1. , 0.33333333, 0. ])
Mit der where-Funktion kann auch ein Massenvergleich implementiert werden:
>>> np.where(a > 0, 3, 2) array([3, 3, 2])
Einige Funktionen ermöglichen das Testen von Werten in einem Array. Die Funktion ungleich Null gibt ein Tupel von Indizes mit Werten ungleich Null zurück. Die Anzahl der Elemente im Tupel entspricht der Anzahl der Achsen im Array:
>>> a = np.array([[0, 1], [3, 0]], float) >>> a.nonzero() (array([0, 1]), array([1, 0]))
Sie können auch die Werte auf Endlichkeit und NaN (keine Zahl) überprüfen:
>>> a = np.array([1, np.NaN, np.Inf], float) >>> a array([ 1., NaN, Inf]) >>> np.isnan(a) array([False, True, False], dtype=bool) >>> np.isfinite(a) array([ True, False, False], dtype=bool)
Obwohl wir hier Numpy-Konstanten verwendet haben, um NaN und Unendlichkeit hinzuzufügen, können sie das Ergebnis der Anwendung mathematischer Standardoperationen sein.
Array-Elemente auswählen und bearbeiten
Wir haben bereits gesehen, dass wie bei Listen Array-Elemente unter Verwendung der Zugriffsoperation durch Index erhalten werden können. Im Gegensatz zu Listen können Sie mit Arrays jedoch auch Elemente mit anderen Arrays auswählen. Dies bedeutet, dass wir ein Array verwenden können, um bestimmte Teilmengen der Elemente anderer Arrays zu filtern.
Boolesche Arrays können als Arrays zum Filtern verwendet werden:
>>> a = np.array([[6, 4], [5, 9]], float) >>> a >= 6 array([[ True, False], [False, True]], dtype=bool) >>> a[a >= 6] array([ 6., 9.])
Es ist anzumerken, dass, wenn wir ein boolesches Array a> = 6 als Index für die Zugriffsoperation durch den Index von Array a übergeben, das zurückgegebene Array nur True-Werte speichert. Wir können auch ein Array schreiben, um in eine Variable zu filtern:
>>> a = np.array([[6, 4], [5, 9]], float) >>> sel = (a >= 6) >>> a[sel] array([ 6., 9.])
Mit Booleschen Ausdrücken kann eine komplexere Filterung erreicht werden:
>>> a[np.logical_and(a > 5, a < 9)] >>> array([ 6.])
Zusätzlich zur booleschen Auswahl können Sie auch ganzzahlige Arrays verwenden. In diesem Fall speichert das Integer-Array die Indizes der Elemente, die aus dem Array entnommen werden sollen. Betrachten Sie das folgende eindimensionale Beispiel:
>>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a[b] array([ 2., 2., 4., 8., 6., 4.])
Mit anderen Worten, wenn wir b verwenden, um Elemente von a zu erhalten, nehmen wir das 0., 0., 1., 3., 2. und 1. Element von a in dieser Reihenfolge. Listen können auch als Arrays zum Filtern verwendet werden:
>>> a = np.array([2, 4, 6, 8], float) >>> a[[0, 0, 1, 3, 2, 1]] array([ 2., 2., 4., 8., 6., 4.])
Bei mehrdimensionalen Arrays müssen für jede Achse mehrere eindimensionale ganzzahlige Arrays in den Zugriffsoperatorindex (
Hinweisübersetzer: In unserem Fall sind Indizes Arrays ) übertragen werden. Dann durchläuft jedes der Arrays die folgende Sequenz: Das erste Element entspricht dem Index der Zeile, die das erste Element des Arrays b ist, das zweite Element entspricht dem Index der Spalte, die das erste Element des Arrays c ist, und so weiter. (
Anmerkung des Übersetzers: Das erste Array [2, 2] und das zweite [1, 4] haben Elemente mit den Indizes [2, 1] und [2, 4] am Ausgang. ) Beispiel:
>>> a = np.array([[1, 4], [9, 16]], float) >>> b = np.array([0, 0, 1, 1, 0], int) >>> c = np.array([0, 1, 1, 1, 1], int) >>> a[b,c] array([ 1., 4., 16., 16., 4.])
Für das Abrufen mit Integer-Arrays steht eine spezielle Take-Funktion zur Verfügung. Dies funktioniert genauso wie die Verwendung des Operators take für einen Index:
>>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a.take(b) array([ 2., 2., 4., 8., 6., 4.])
Die Take-Funktion stellt auch das Achsenargument bereit, um einen Unterabschnitt des mehrdimensionalen Arrays entlang einer Achse zu nehmen. (
Hinweis Übersetzer: Zeile oder Spalte (für zweidimensionale Arrays) ).
>>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([0, 0, 1], int) >>> a.take(b, axis=0) array([[ 0., 1.], [ 0., 1.], [ 2., 3.]]) >>> a.take(b, axis=1) array([[ 0., 0., 1.], [ 2., 2., 3.]])
Im Gegensatz zur Take-Funktion gibt es eine Put-Funktion, die Werte aus dem ursprünglichen Array entnimmt und in bestimmte Indizes in einem anderen Put-Array schreibt.
>>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> b = np.array([9, 8, 7], float) >>> a.put([0, 3], b) >>> a array([ 9., 1., 2., 8., 4., 5.])
Beachten Sie, dass der Wert 7 aus dem ursprünglichen Array b nicht verwendet wurde, da nur 2 Indizes [0, 3] angegeben sind. Das ursprüngliche Array wird bei Bedarf wiederholt, wenn die Längen nicht übereinstimmen:
>>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> a.put([0, 3], 5) >>> a array([ 5., 1., 2., 5., 4., 5.])
Vektor- und Matrixmathematik
NumPy bietet viele Funktionen zum Arbeiten mit Vektoren und Matrizen. Die Punktfunktion gibt das Skalarprodukt von Vektoren zurück:
>>> a = np.array([1, 2, 3], float) >>> b = np.array([0, 1, 1], float) >>> np.dot(a, b) 5.0
Die Punktfunktion kann auch Matrizen multiplizieren:
>>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([2, 3], float) >>> c = np.array([[1, 1], [4, 0]], float) >>> a array([[ 0., 1.], [ 2., 3.]]) >>> np.dot(b, a) array([ 6., 11.]) >>> np.dot(a, b) array([ 3., 13.]) >>> np.dot(a, c) array([[ 4., 0.], [ 14., 2.]]) >>> np.dot(c, a) array([[ 2., 4.], [ 0., 4.]])
Sie können auch den Skalar, den Tensor und das äußere Produkt von Matrizen und Vektoren erhalten. Beachten Sie, dass für Vektoren das innere und das skalare Produkt zusammenfallen.
>>> a = np.array([1, 4, 0], float) >>> b = np.array([2, 2, 1], float) >>> np.outer(a, b) array([[ 2., 2., 1.], [ 8., 8., 4.], [ 0., 0., 0.]]) >>> np.inner(a, b) 10.0 >>> np.cross(a, b) array([ 4., -1., -6.])
NumPy bietet auch eine Reihe integrierter Funktionen und Methoden für die Arbeit mit linearer Algebra. Dies alles finden Sie im Linalg-Untermodul. Diese Module können auch mit entarteten und nicht entarteten Matrizen bearbeitet werden. Die Determinante der Matrix wird folgendermaßen gesucht:
>>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float) >>> a array([[ 4., 2., 0.], [ 9., 3., 7.], [ 1., 2., 1.]]) >>> np.linalg.det(a) -48.
Sie können auch den Eigenvektor und den Eigenwert der Matrix ermitteln:
>>> vals, vecs = np.linalg.eig(a) >>> vals array([ 9. , 2.44948974, -2.44948974]) >>> vecs array([[-0.3538921 , -0.56786837, 0.27843404], [-0.88473024, 0.44024287, -0.89787873], [-0.30333608, 0.69549388, 0.34101066]])
Eine nicht entartete Matrix kann wie folgt gefunden werden:
>>> b = np.linalg.inv(a) >>> b array([[ 0.14814815, 0.07407407, -0.25925926], [ 0.2037037 , -0.14814815, 0.51851852], [-0.27777778, 0.11111111, 0.11111111]]) >>> np.dot(a, b) array([[ 1.00000000e+00, 5.55111512e-17, 2.22044605e-16], [ 0.00000000e+00, 1.00000000e+00, 5.55111512e-16], [ 1.11022302e-16, 0.00000000e+00, 1.00000000e+00]])
Eine einzelne Zerlegung (ein Analogon der Diagonalisierung einer nicht quadratischen Matrix) kann wie folgt erreicht werden:
>>> a = np.array([[1, 3,4], [5, 2, 3]], float) >>> U, s, Vh = np.linalg.svd(a) >>> U array([[-0.6113829 , -0.79133492], [-0.79133492, 0.6113829 ]]) >>> s array([ 7.46791327, 2.86884495]) >>> Vh array([[-0.61169129, -0.45753324, -0.64536587], [ 0.78971838, -0.40129005, -0.46401635], [-0.046676 , -0.79349205, 0.60678804]])
Wir beenden den dritten Teil. Viel Glück und bis bald!