NumPy in Python. Teil 3

    Vorwort des Übersetzers


    Hallo nochmal! Wir setzen unsere Artikelreihe über numpy Mana-Übersetzung fort. Viel Spaß beim Lesen.


    Vergleichsoperatoren und Wertetests


    Ein boolescher Vergleich kann für den elementweisen Vergleich von Arrays gleicher Länge verwendet werden. Der Rückgabewert ist ein Array mit 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 Ergebnis des Vergleichs 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)

    Die Operatoren any und all können verwendet werden, um zu bestimmen, 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 durch das Element-Element-Prinzip mit den Sonderfunktionen logic_und, logic_or und logic_not 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 derselben Länge, wobei ein boolescher Filter verwendet wird, um zwischen zwei Elementen auszuwählen. Grundlegende Syntax: wo (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 Nicht-Null-Funktion gibt ein Tupel von Indizes mit Nicht-Null-Werten zurück. Die Anzahl der Elemente in einem 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 für Gliedmaßen 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 die numpy-Konstanten verwendet haben, um NaN-Werte und unendlich 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 die Elemente eines Arrays unter Verwendung einer Indexzugriffsoperation 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 Untermengen von Elementen aus anderen Arrays zu filtern.

    Boolesche Arrays können als Filterarrays 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.])

    Wenn Sie ein boolesches Array a> = 6 als Index für eine Zugriffsoperation für den Index von Array a übergeben, werden nur True-Werte im zurückgegebenen Array gespeichert. Wir können auch ein Array zum Filtern in eine Variable schreiben:

    >>> a = np.array([[6, 4], [5, 9]], float)
    >>> sel = (a >= 6)
    >>> a[sel]
    array([ 6.,  9.])

    Eine verfeinerte Filterung kann mit booleschen Ausdrücken erreicht werden:

    >>> a[np.logical_and(a > 5, a < 9)]
    >>> array([ 6.])

    Zusätzlich zur booleschen Auswahl können Sie auch Integer-Arrays verwenden. In diesem Fall speichert das Integer-Array die Indizes der Elemente, die aus dem Array entnommen werden. 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 die 0, 0, 1, 3, 2 und 1 Elemente von a in dieser Reihenfolge. Listen können auch als Filterarrays 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 wir für jede Achse mehrere eindimensionale Integer-Arrays vom Zugriffsoperator auf den Index übertragen ( Anmerkung des Übersetzers: In unserem Fall sind die Indizes Arrays ). Dann durchläuft jedes der Arrays die folgende Sequenz: Das erste Element entspricht dem Index der Zeile, das das erste Element des Arrays b ist, das zweite Element entspricht dem Index der Spalte, das das erste Element des Arrays c ist, usw. ( Anmerkung des Übersetzers: das erste Array [2, 2] und das zweite [1, 4], wir 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.])

    Die Sonderfunktion take steht für das Abtasten mit Integer-Arrays zur Verfügung. Dies funktioniert genauso wie der Indexoperator:

    >>> 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 ein Achsenargument bereit, um einen Unterabschnitt eines mehrdimensionalen Arrays entlang einer Achse zu nehmen. ( Anmerkung des Übersetzers: in Zeilen oder Spalten (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 übernimmt und sie 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 des ursprünglichen Arrays b nicht verwendet wurde, da nur 2 Indizes [0, 3] angegeben sind. Das ursprüngliche Array wird ggf. wiederholt, wenn die Länge nicht übereinstimmt:

    >>> 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 Matrix-Mathematik


    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 externe Produkt von Matrizen und Vektoren erhalten. Beachten Sie, dass für Vektoren das innere und das innere 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 von integrierten Funktionen und Methoden für das Arbeiten mit linearer Algebra. Dies ist alles im Linalg-Submodul zu finden. Diese Module können auch mit entarteten und nicht entarteten Matrizen betrieben werden. Die Determinante der Matrix wird wie folgt 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)
    -53.999999999999993

    Sie können auch den Eigenvektor und den Eigenwert der Matrix finden:

    >>> 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 (analog zur 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!

    Jetzt auch beliebt: