NumPy-Arrays und vektorisiertes Rechnen

NumPy speichert numerische Daten in Arrays, sodass ein Ausdruck auf viele Werte angewendet werden kann. Importiere NumPy mit import numpy as np; der Kurzname np wird üblicherweise verwendet, um seine Funktionen aufzurufen.

Die Struktur eines Arrays ablesen

Ein ndarray ist ein rechteckiges Gitter, dessen Elemente denselben Datentyp haben. Eine Dimension wird auch Achse genannt. Beginne mit einer kleinen Tabelle:

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])

Ihre Attribute beantworten vier verschiedene Fragen:

Achse 0 indiziert Zeilen, Achse 1 indiziert Spalten. Eine Datentabelle mit einer Zeile pro Person und Spalten für Größe, Masse und Alter hätte für 100 Personen die Form (100, 3). Das Produkt der Formeinträge ergibt die Elementanzahl.

Ein Vektor hat keine Zeilen- oder Spaltenachse

np.array([2, 4, 6, 8]) hat die Form (4,) und eine Achse. Das Komma macht daraus ein Tupel mit einem Eintrag. Die Form (1, 4) hat zwei Achsen: eine Zeile und vier Spalten. Auch die Form (4, 1) hat zwei Achsen, aber vier Zeilen und eine Spalte. Diese Arrays enthalten vier Werte, verhalten sich aber bei der Kombination mit anderen Arrays unterschiedlich. np.array(7) ist ein nulldimensionales Array: Seine Form ist () und sein ndim ist 0.

Arrays ändern die Bedeutung von Operatoren

Eine Liste ist ein allgemeiner Python-Container. Ein Array ist für Berechnungen an entsprechenden Positionen ausgelegt.

Bei der Array-Addition wird 1 mit 3 und 2 mit 4 kombiniert. Das Array behält seine Größe.

Warum numerische Arrays effizient sind

Ein neu erstelltes numerisches Array speichert Werte desselben Datentyps gemeinsam im Speicher. NumPy durchläuft diese Werte in kompiliertem Code und vermeidet so für jede Zahl eine separate Operation auf Python-Ebene. Eine Million float64-Werte belegen 8.000.000 Byte Elementspeicher, der bei einem Array dieser Größe über a.nbytes abrufbar ist. Eine Python-Liste speichert zusätzlich Referenzen auf Python-Objekte und benötigt daher erheblich mehr Platz. Der Geschwindigkeitsgewinn hängt von der Berechnung und dem Computer ab.

Die Größe eines Arrays wächst nicht durch eine append-Methode, die es direkt ändert. np.append(a, value) reserviert ein neues Array. Für Daten, die einzeln erfasst werden, erstelle eine Python-Liste und wandle sie einmal um. Verschachtelte Eingaben müssen rechteckig sein: np.array([[1, 2], [3]]) löst einen ValueError aus, weil die Zeilen unterschiedlich lang sind.

Angezeigte Ergebnisse erkennen

print(np.array([1, 2, 3])) zeigt [1 2 3]. Eine interaktive Anzeige verwendet array([1, 2, 3]). Für np.array([5, 6])[0] zeigt NumPy 2 auf einem 64-Bit-Computer np.int64(5) an; bei Rechnungen verhält sich der Wert wie die Zahl 5.

Wähle eine Erzeugungsfunktion danach aus, was du kennst: die tatsächlichen Werte, eine Form und einen Füllwert, eine Schrittweite oder eine benötigte Anzahl von Punkten. So zeigt der Code, wie die Daten aufgebaut werden sollen.

Mit Werten oder einer Form beginnen

np.array([3, 1, 4]) erstellt einen Vektor. Eine Liste gleich langer Listen erstellt eine Tabelle. Übergib die Werte als eine Sequenz; np.array(1, 2, 3) übergibt nicht korrekt drei Elemente.

Bei einer mehrdimensionalen Form sind die Klammern wichtig. np.zeros((2, 3)) übergibt ein Tupel. Bei np.zeros(2, 3) übergibt Python 3 als Datentyp-Argument, was einen Typfehler verursacht. Nullen und Einsen verwenden standardmäßig float64; full leitet seinen Datentyp aus dem Füllwert ab. Füge dtype=int hinzu, wenn du Ganzzahlen speichern musst.

empty garantiert weder Nullen noch sinnvolle Anfangswerte. Lies erst daraus, nachdem du jedem Element, das du verwenden wirst, einen Wert zugewiesen hast. zeros ist eine einfachere Wahl, wenn ein anfänglicher Wert von null sinnvoll ist.

Eine Schrittweite oder eine Punktanzahl wählen

np.arange(start, stop, step) folgt dem Schrittprinzip von Pythons range. np.arange(2, 11, 3) ergibt [2 5 8]: Beginne bei 2 und addiere 3, solange du unter 11 bleibst. Mit einem Argument beginnt np.arange(5) bei 0 und ergibt [0 1 2 3 4].

Gleitkomma-Schrittweiten können zu überraschenden Endpunkten führen. Beispielsweise enthält np.arange(1, 1.3, 0.1) den angezeigten Wert 1,3, weil die binäre Rundung die Berechnung der Folge beeinflusst. Für ein Dezimalgitter mit fester Punktanzahl verwende linspace:

grid = np.linspace(0, 1, 5)
# array([0.  , 0.25, 0.5 , 0.75, 1.  ])

Beide Endpunkte sind standardmäßig eingeschlossen. Fünf Punkte ergeben vier Abstände. Zehn Punkte zwischen 0 und 1 ergeben neun Abstände, ihr Abstand beträgt also etwa 0,111; Schritte von 0,1 benötigen 11 Punkte.

Eine vorhandene Struktur wiederverwenden

np.zeros_like(a), np.ones_like(a) und np.full_like(a, value) erstellen neue Arrays mit der Form und dem Datentyp von a. Der übernommene Datentyp ist wichtig: Füllst du eine Ganzzahlvorlage mit einer Dezimalzahl, kann der Nachkommateil verloren gehen, sofern du keinen Gleitkommatyp anforderst. np.eye(3) erstellt eine quadratische Einheitsmatrix mit Einsen auf der Diagonalen und Nullen an den übrigen Stellen.

Eine Datentabelle einmalig anlegen

Für Niederschlag in Millimetern an drei Stationen über vier Wochen:

rain = np.zeros((3, 4))
rain[0] = [12.0, 0.0, 5.5, 8.0]

Die erste Zuweisung füllt eine Zeile und erhält die Form (3, 4). Ist die Anzahl der Messwerte bekannt, vermeidest du durch das Reservieren der vollständigen Tabelle, wiederholt größere Arrays anzulegen. Ist die Menge der Eingaben unbekannt, sammle die Werte in einer Liste und rufe np.array auf, sobald die Sammlung abgeschlossen ist.

Der Datentyp eines Arrays bestimmt, was es speichern kann und wie viel Speicher jeder Wert benötigt. Die Wahl des richtigen Typs verhindert auch, dass bei Berechnungen unbemerkt Informationen verloren gehen.

Den Speichertyp prüfen

int64 speichert 64-Bit-Ganzzahlen, float64 speichert binäre Gleitkommazahlen und bool speichert Wahrheitswerte. Unicode-Datentypen wie <U5 speichern Text mit einer maximalen Zeichenanzahl. a.itemsize gibt die Byte pro Element an; a.nbytes ist a.size * a.itemsize. Ein float64 belegt 8 Byte und hat eine Genauigkeit von etwa 15 signifikanten Dezimalstellen.

Auf typischen 64-Bit-Computern werden ganzzahlige Eingaben als 64-Bit-Ganzzahlen gespeichert. NumPy 2 verwendet diesen Standard auch unter 64-Bit-Windows. Dezimale Eingaben ergeben normalerweise float64.

Die Typinferenz wählt einen gemeinsamen Typ

np.array([1, 2.5]) wird zu [1. 2.5]: Die Ganzzahl wird als Gleitkommazahl dargestellt. np.array([True, 2]) wird zu [1 2]. Werden Zahlen und Text gemischt, kann das gesamte Array zu Text werden, sodass ein Eintrag wie 'n/a' spätere Rechnungen scheitern lassen kann. Prüfe dtype, wenn sich scheinbar numerische Daten nicht addieren oder multiplizieren lassen.

Bewusst umwandeln

astype gibt eine umgewandelte Kopie zurück:

x = np.array([1.7, -1.7, 2.5])
whole = x.astype(int)
# array([ 1, -1,  2])

Diese Umwandlung schneidet Nachkommastellen in Richtung null ab; sie rundet nicht. np.round(x).astype(int) ergibt [2 -2 2], weil genaue Hälften zur nächsten geraden Zahl gerundet werden. Text wie '1.5' lässt sich mit astype(float) umwandeln, aber 'n/a' löst einen ValueError aus. Bereinige Platzhalter vor der Umwandlung.

Zuweisungen verwenden den Datentyp des Ziels. Nach a = np.array([1, 2, 3]) speichert die Zuweisung a[0] = 9.9 ohne Warnung den Wert 9. Wenn du zuerst das gesamte Array in Gleitkommazahlen umwandelst, bleiben bei späteren Zuweisungen die Nachkommastellen erhalten.

Ganzzahlen fester Breite können überlaufen

Ein int8 speichert Werte von −128 bis 127; ein uint8 speichert 0 bis 255. Das Addieren zweier uint8-Arrays mit 250 und 10 ergibt durch Überlauf 4. Das Multiplizieren eines int8-Arrays mit dem Wert 100 mit 2 ergibt −56. Eine Python-Ganzzahl, die nicht in den Array-Typ passt, etwa 300 bei der Addition zu einem int8-Array in NumPy 2, löst dagegen einen OverflowError aus. Wandle kleine Ganzzahltypen vor Berechnungen, die ihren Wertebereich überschreiten können, in größere um.

Division und angenäherte Dezimalzahlen

Die Ganzzahldivision rundet in Richtung minus unendlich ab. Bei negativen Ergebnissen unterscheidet sich das vom Abschneiden der Nachkommastellen. Die Division gibt bei ganzzahligen Eingaben Gleitkommaergebnisse zurück.

Viele Dezimalbrüche sind in binärer Darstellung Näherungen. 0.1 + 0.2 == 0.3 ist falsch; np.isclose vergleicht entsprechende Werte mit einer Toleranz, und np.allclose gibt eine Antwort für das ganze Array.

Das Fehlwertkennzeichen np.nan ist eine Gleitkommazahl. Ganzzahl-Arrays können es nicht speichern. np.array([1, 2, np.nan]) wird daher zu einem Gleitkomma-Array; die Umwandlung fehlender Werte in Ganzzahlen behebt sie nicht und kann bedeutungslose Ergebnisse liefern.

Indizierung findet Werte anhand ihrer Position. Slicing wählt eine regelmäßige Folge von Positionen aus. Schreibe bei einer Tabelle für jede Achse eine eigene Auswahl, sodass der Code angibt, welche Zeilen und welche Spalten du benötigst.

Einen Vektor lesen

Für a = np.array([10, 20, 30, 40, 50]) enthält Position 0 den Wert 10 und Position −1 den Wert 50. Ein Slice hat die Form start:stop:step, wobei der Stoppwert ausgeschlossen ist:

Wenn du Start oder Stopp auslässt, reicht der Slice bis zum jeweiligen Ende. Ein Slice kann über das Array hinausreichen und wird automatisch gekürzt. Eine einzelne ungültige Position wie a[5] löst einen IndexError aus.

Für jede Tabellenachse eine eigene Auswahl angeben

m = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

m[1, 2] liest Zeile 1, Spalte 2 und ergibt 6. Das Komma trennt die Achsen. Ein Doppelpunkt allein wählt die gesamte Achse aus: m[0, :] ergibt die erste Zeile [1 2 3], und m[:, 1] ergibt die zweite Spalte [2 5 8]. Für einen Block wählt m[:2, 1:] die Zeilen 0 und 1 und die Spalten 1 und 2 aus und ergibt [[2 3] [5 6]].

Behandle die wiederholte Indizierung mit eckigen Klammern nicht als gleichbedeutend mit der Indizierung per Komma. m[1][2] findet zufällig denselben Skalar wie m[1, 2]. Aber m[:][0] nimmt zuerst alle Zeilen und wählt dann die erste Zeile aus. Es wählt nicht die erste Spalte aus; das tut m[:, 0].

Vorhersagen, welche Achsen erhalten bleiben

Ein einzelner Ganzzahlindex entfernt seine Achse. Ein Slice erhält seine Achse, selbst wenn nur eine Position ausgewählt wird. Daher hat m[:, 1] die Form (3,), während m[:, 1:2] die Form (3, 1) hat. Beide wählen 2, 5 und 8 aus, aber nur die zweite Variante erhält eine Spaltenachse. Dieser Unterschied wird wichtig, wenn Arrays mit anderen Formen subtrahiert oder multipliziert werden.

Dieselbe Regel gilt auch über Tabellen hinaus. Wenn t.shape gleich (2, 3, 4) ist, hat t[0] die Form (3, 4), t[0, 1] die Form (4,) und t[:, :, 0] die Form (2, 3). Alle am Ende des Index ausgelassenen Achsen werden vollständig ausgewählt.

Die ausgewählten Positionen ändern

Eine Zuweisung über einen Index schreibt in das vorhandene Array. a[1:3] = 0 ersetzt beide ausgewählten Werte durch null; der Skalar wird auf die gesamte Auswahl angewendet. m[0] = [0, 0, 0] ersetzt eine vollständige Zeile. Die zugewiesenen Werte müssen zur Form der Auswahl passen und werden in deren Datentyp umgewandelt.

Für vier Lernende und drei Tests:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores[2] ist das Ergebnis der dritten Person [88 91 95]. scores[:, -1] ergibt die Ergebnisse des letzten Tests [92 58 95 80]. scores[1:3, :2] ergibt [[64 70] [88 91]]: zwei Lernende mit jeweils zwei Testspalten.

Eine Auswahl kann ihre Daten mit dem ursprünglichen Array teilen oder unabhängige Daten besitzen. Wenn du weißt, was vorliegt, verhinderst du, dass Änderungen an einer kleinen Auswahl unerwartet eine größere Tabelle verändern.

Alias, Sicht und Kopie unterscheiden

Für a = np.arange(6) und b = a[2:5] macht die Zuweisung b[0] = 99 aus a den Wert [0 1 99 3 4 5]. Die erste Position der Sicht bezieht sich auf Position 2 im Original. Das unterscheidet sich vom Slicing einer Python-Liste, bei dem eine neue Liste entsteht.

Kopiere vor der Bearbeitung, wenn das Original unverändert bleiben muss. Eine kleine, aufbewahrte Sicht kann außerdem einen großen ursprünglichen Datenpuffer im Speicher halten; eine Kopie dieses kleinen Teils ist unabhängig davon.

Beliebige Positionen auswählen

Fancy Indexing verwendet eine Ganzzahlliste oder ein Ganzzahl-Array. Es erlaubt eine andere Reihenfolge und wiederholte Positionen:

a = np.array([10, 20, 30, 40, 50])
a[[4, 0, 0]]
# array([50, 10, 10])

Für m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) wählt m[[0, 2]] die erste und dritte Zeile aus. m[:, [2, 0]] wählt die letzte und die erste Spalte in dieser Reihenfolge aus und ergibt [[3 1] [6 4] [9 7]].

Zwei Ganzzahllisten in einem Index wählen Koordinatenpaare aus. m[[0, 2], [1, 2]] verbindet Zeile 0 mit Spalte 1 und Zeile 2 mit Spalte 2 und ergibt [2 9]. Es werden nicht alle Kombinationen ausgewählt. Für den Block aus beiden Zeilen und beiden Spalten verwende:

m[np.ix_([0, 2], [1, 2])]
# array([[2, 3], [8, 9]])

Wenn du zuerst die Zeilen und dann die Spalten auswählst, ergibt m[[0, 2]][:, [1, 2]] denselben Block.

Lesen und Zuweisen verhalten sich unterschiedlich

Fancy Indexing und boolesches Filtern geben Kopien zurück. Wenn c = a[[0, 1]] gilt, lässt eine Änderung an c[0] das Array a unverändert. Aber a[[0, 1]] = -1 schreibt direkt in diese ursprünglichen Positionen. Eine gespeicherte Auswahl und eine Zuweisung über einen Index sind unterschiedliche Operationen.

Das erklärt auch, warum verkettete Änderungen die Quelle möglicherweise nicht erreichen. In a[[0, 1]][0] = -1 ist die erste Auswahl bereits eine temporäre Kopie. Der letzte Schreibvorgang ändert dieses temporäre Array, nicht a.

Gemeinsame Speichernutzung direkt prüfen

np.shares_memory(x, y) prüft, ob sich zwei Arrays im Speicher überlappen. Die Funktion gibt für einen gewöhnlichen, nicht leeren Slice wahr und für eine durch Fancy Indexing erzeugte Kopie falsch zurück. Das Attribut base kann den Eigentümer des zugrunde liegenden Speichers angeben, muss aber nicht das Array bezeichnen, aus dem du zuletzt einen Slice ausgewählt hast. Wenn a = np.arange(6), b = a[2:5] und c = b[0:2] gilt, ist c.base is a wahr und c.base is b falsch. Verwende shares_memory, wenn es darum geht, ob zwei Arrays Daten gemeinsam nutzen.

Eine boolesche Maske hält fest, welche Werte eine Bedingung erfüllen. Sobald eine Maske vorliegt, können dieselben Wahrheitswerte Werte auswählen, Ereignisse zählen oder Ersatzwerte bestimmen.

Eine Maske erstellen und anwenden

t = np.array([18.5, 22.0, 15.2, 25.8, 21.1])
warm = t > 20
t[warm]
# array([22. , 25.8, 21.1])

Der Vergleich ergibt [False True False True True]. Die boolesche Indizierung behält die Positionen mit dem Wert wahr und gibt eine Kopie zurück. Eine 1-dimensionale Maske, die auf eine Achse angewendet wird, muss dieselbe Länge wie diese Achse haben.

Um Bedingungen zu verknüpfen, verwende & für und, | für oder und ~ für nicht. Setze jeden Vergleich in Klammern:

comfortable = (t > 18) & (t < 23)
t[comfortable]
# array([18.5, 22. , 21.1])

Pythons and und or versuchen, aus einem ganzen Array einen einzigen Wahrheitswert zu gewinnen, und scheitern bei Arrays mit mehreren Elementen. Lässt du die Klammern weg, ändert sich ebenfalls, wie Python den Ausdruck gruppiert, weil bitweise Operatoren vor Vergleichen ausgewertet werden.

Bedingungen zählen, Anteile berechnen oder Bedingungen prüfen

True zählt als 1 und False als 0. warm.sum() ist 3 und warm.mean() ist 0,6, der Anteil der Tage über 20 °C. np.count_nonzero(warm) zählt ebenfalls wahre Einträge. warm.any() prüft, ob mindestens ein Tag warm ist; warm.all() prüft, ob jeder Tag warm ist.

Diese Operationen beantworten andere Fragen als t[warm].mean(), das die durchschnittliche Temperatur an warmen Tagen berechnet. Der Mittelwert einer Maske misst einen Anteil; der Mittelwert ausgewählter Messwerte behält die Einheit der Messung.

Werte ersetzen oder zwischen Alternativen wählen

Eine Zuweisung über eine Maske aktualisiert die ausgewählten Positionen. Mit t2 = t.copy() hebt die Zeile t2[t2 < 16] = 16 niedrige Messwerte auf 16 an. np.clip(t, 16, 25) gibt ein neues, an beiden Enden begrenztes Array zurück: [18.5 22. 16. 25. 21.1].

np.where(condition, x, y) erstellt ein neues Ergebnis, das an wahren Positionen x und an falschen Positionen y übernimmt. np.where(t > 20, 'warm', 'cool') liefert an jeder ursprünglichen Position eine Bezeichnung. Filtern verkürzt dagegen das Ergebnis. Mit einer Bedingung allein gibt np.where(t > 20) ein Tupel aus Index-Arrays zurück, hier (array([1, 3, 4]),).

Werte oder vollständige Datensätze behalten

Eine Maske derselben Form extrahiert aus einem 2-dimensionalen Array passende Elemente in einen flachen Vektor. Bei m[m > 5] geht die Zeilenstruktur verloren. Um ganze Datensätze zu erhalten, leite aus einer Spalte pro Zeile einen Wahrheitswert ab:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])
scores[scores[:, 2] >= 90]
# array([[78, 85, 92], [88, 91, 95]])

Fehlende Werte ausdrücklich finden

NaN ist selbst zu sich selbst nicht gleich. Gleichheits- und Ordnungsvergleiche mit NaN sind falsch; der Ungleichheitsvergleich ist wahr. Daher erkennen weder x == np.nan noch x != np.nan vorhandene und fehlende Einträge korrekt. np.isnan(x) markiert fehlende Positionen, und x[~np.isnan(x)] behält vorhandene Werte.

Eine Formänderung verändert, wie Werte auf Achsen gruppiert werden. Umformen, Transponieren und das Hinzufügen einer Achse erfüllen unterschiedliche Aufgaben, auch wenn einige davon dieselbe endgültige Form ergeben.

Umformen, ohne die Elementanzahl zu ändern

a = np.arange(6)
r = a.reshape(2, 3)
# array([[0, 1, 2], [3, 4, 5]])

Standardmäßig wird jeweils eine Zeile gefüllt: Die letzte Achse ändert sich am schnellsten. Das Umformen derselben Werte zu (3, 2) ergibt [[0 1] [2 3] [4 5]]. Das Produkt der neuen Dimensionen muss der ursprünglichen Elementanzahl entsprechen. Zwölf Elemente passen in (3, 4), aber nicht in (5, 3).

Eine Dimension kann -1 sein, sodass NumPy ihre Länge ermittelt. np.arange(12).reshape(-1, 3) ergibt vier Zeilen mit je drei Elementen; reshape(2, -1) ergibt zwei Zeilen mit je sechs Elementen. Zwei unbekannte Dimensionen sind nicht erlaubt, weil sich ihre einzelnen Längen nicht allein aus der Gesamtzahl bestimmen lassen.

Transponieren vertauscht die Achsen

Für r oben ist r.T gleich [[0 3] [1 4] [2 5]] mit der Form (3, 2). Jede frühere Spalte ist nun eine Zeile. Diese Anordnung unterscheidet sich von r.reshape(3, 2), obwohl die Formen der Ergebnisse übereinstimmen.

Transponieren ist nützlich, wenn die nächste Operation die umgekehrte Achsenreihenfolge benötigt. Umformen ist nützlich, wenn eine Folge bereits eine sinnvolle Gruppierung hat, etwa Monate, die zu Quartalen zusammengefasst sind.

Das Transponieren eines 1-dimensionalen Arrays erzeugt keine Spalte

v = np.arange(3) hat nur eine Achse, daher hat v.T weiterhin die Form (3,). Füge ausdrücklich eine Achse hinzu:

column = v[:, np.newaxis]  # shape (3, 1)
row = v[np.newaxis, :]     # shape (1, 3)

Auch v.reshape(-1, 1) und np.expand_dims(v, 1) erzeugen eine Spalte. np.squeeze(column) entfernt deren Achse der Länge eins und gibt die Form (3,) zurück. Das Hinzufügen einer Achse ändert keine Werte, legt aber für spätere Rechnungen fest, wie sie ausgerichtet werden sollen.

Abflachen und gemeinsame Speichernutzung

r.ravel() und r.flatten() geben beide Werte in einem 1-dimensionalen Ergebnis aus. ravel gibt nach Möglichkeit eine Sicht zurück; flatten kopiert immer. reshape(-1) ist eine weitere Möglichkeit, eine 1-dimensionale Anordnung anzufordern, doch ob sie den Speicher gemeinsam nutzt, hängt von der Speicheranordnung der Eingabe ab. Beim Umformen kann eine Kopie nötig sein; beim Transponieren teilt die Array-Sicht die Daten. Verwende .copy(), wenn unabhängiger Speicher benötigt wird.

Monatswerte zu Quartalen gruppieren

Für monthly = np.array([120, 135, 150, 160, 155, 170, 180, 175, 165, 150, 140, 130]) erstellt monthly.reshape(4, 3) vier Quartalszeilen mit jeweils drei Monaten. Das Summieren jeder Zeile mit .sum(axis=1) ergibt [405 485 520 420]. Die erste Summe ist 120 + 135 + 150 = 405. Das Umformen funktioniert, weil die Monate jedes Quartals in der chronologischen Eingabe bereits beieinanderstehen.

Beim Zusammenfügen werden Werte mehrerer Arrays kombiniert. Beim Aufteilen wird ein Array in Teile zerlegt. Entscheide zuerst, ob die Operation eine vorhandene Achse erweitern oder eine neue einführen soll.

Entlang einer vorhandenen Achse verketten

np.concatenate([a, b], axis=0) fügt Vektoren aneinander. Das Zusammenfügen von [1 2] und [3 4 5] ergibt [1 2 3 4 5].

Bei zwei Arrays mit jeweils der Form (2, 3) fügt Achse 0 Zeilen hinzu und ergibt (4, 3). Achse 1 fügt Spalten hinzu und ergibt (2, 6). Nur die Verknüpfungsachse darf sich in der Länge unterscheiden. So lassen sich die Formen (2, 3) und (2, 2) entlang Achse 1 zu (2, 5) zusammenfügen, aber nicht entlang Achse 0, weil ihre Spaltenanzahlen nicht übereinstimmen.

Die Arrays müssen zusammen als Sequenz übergeben werden, etwa als [a, b]. Das Zusammenfügen erstellt ein neues kombiniertes Array und kopiert die Daten der Eingaben.

Entlang einer neuen Achse stapeln

Für p = np.array([1, 2, 3]) und q = np.array([4, 5, 6]):

stack setzt gleiche Eingabeformen voraus und fügt eine Achse hinzu. concatenate erhält die Anzahl der Achsen. Die Hilfsfunktionen bilden gängige Anordnungen ab: vstack([p, q]) erzeugt Zeilen, hstack([p, q]) fügt diese 1-dimensionalen Eingaben aneinander und column_stack([p, q]) erzeugt Spalten. Wegen des Verhaltens von hstack bei 1-dimensionalen Eingaben reicht sein Name allein nicht aus, um eine Tabelle vorherzusagen.

An Grenzen oder nach Anzahl der Teile aufteilen

np.split(np.arange(10), [3, 7]) teilt vor den Positionen 3 und 7 und ergibt [0 1 2], [3 4 5 6] und [7 8 9]. Die Grenzpositionen sind keine Längen der Teile.

Ein ganzzahliges zweites Argument fordert dagegen gleich große Teile an: np.split(x, 3) verlangt drei gleich große Stücke. Zehn Elemente lassen sich nicht in drei Teile mit gleicher ganzzahliger Größe aufteilen, daher wird ein ValueError ausgelöst. np.array_split(np.arange(10), 3) erlaubt unterschiedliche Längen und ergibt 4, 3 und 3. Diese Aufteilungsaufrufe geben eine Sammlung von Arrays zurück, nicht ein einzelnes Array mit einer neuen Stapelachse.

Eine Messtabelle erstellen

h = np.array([1.62, 1.75, 1.80])  # meters
w = np.array([55.0, 72.5, 80.0])  # kilograms
data = np.column_stack([h, w])

Die Form (3, 2) steht für drei Personen mit Körpergröße und Masse in den Spalten. data[:, 1] / data[:, 0] ** 2 berechnet für jede Zeile die Masse geteilt durch das Quadrat der Körpergröße und ergibt ungefähr 21,0, 23,7 und 24,7 kg/m². Entscheidend ist, dass die Personen in beiden Messwert-Arrays in derselben Reihenfolge stehen.

Treffen Eingaben in Stapeln ein, sammle die Stapel-Arrays in einer Python-Liste und rufe concatenate einmal auf. Wird ein wachsendes Array bei jedem Schleifendurchlauf erneut zusammengefügt, werden seine vorhandenen Daten wiederholt kopiert.

Vektorisierung beschreibt eine Berechnung für ganze Arrays. NumPy übernimmt die wiederholte Arbeit an den einzelnen Elementen in kompiliertem Code, sodass der Python-Ausdruck nahe an der beabsichtigten Berechnung bleiben kann.

Eine Schleife in Arithmetik auf entsprechenden Positionen übersetzen

prices = np.array([2.50, 4.00, 1.20])
qty = np.array([3, 1, 5])
line_totals = prices * qty
order_total = line_totals.sum()

Die Produkte sind [7.5 4. 6.] und ihre Summe ist 17,5. Jeder Preis wird mit seiner zugehörigen Menge gepaart. Eine Python-Schleife, die eine Summe aktualisiert, liefert dasselbe Ergebnis, überlässt Python aber die separate Verarbeitung jedes Paares.

Alle arithmetischen Operatoren arbeiten elementweise: +, -, *, /, //, % und **. Ein Skalar wird auf jeden Eintrag angewendet. 10 - np.array([1, 2, 3]) ergibt [9 8 7]; die Reihenfolge der Operanden ist weiterhin wichtig. Zwei Arrays benötigen gleiche Formen oder Formen, die für Broadcasting kompatibel sind.

Elementweise Produkte und Matrixprodukte unterscheiden

* multipliziert entsprechende Einträge. Für A = np.array([[1, 2], [3, 4]]) und B = np.array([[5, 6], [7, 8]]) ergibt A * B den Wert [[5 12] [21 32]]. Die Matrixmultiplikation verwendet @ und würde [[19 22] [43 50]] ergeben. Wähle * für gepaarte Messwerte wie Preis und Menge.

Vergleiche geben ebenfalls eine Antwort pro Position zurück

a == b erzeugt ein boolesches Array. Es prüft nicht, ob zwei Arrays als ganze Objekte gleich sind. Eine if-Anweisung benötigt einen Wahrheitswert, daher schlägt if a == b: bei Ergebnissen mit mehreren Elementen fehl. np.array_equal(a, b) prüft die exakte Gleichheit ganzer Arrays. Für angenäherte Dezimalzahlen prüft np.allclose(a, b) die Übereinstimmung innerhalb einer Toleranz.

Divisionswarnungen verstehen

Bei den standardmäßigen Fehlereinstellungen von NumPy erzeugt eine Gleitkommadivision durch null eine Warnung und besondere Werte:

np.array([1.0, -1.0, 0.0]) / 0
# array([ inf, -inf, nan])

np.isfinite erkennt Ergebnisse, die weder unendlich noch NaN sind. Eine Ganzzahldivision durch null gibt dagegen ganzzahlige Nullen mit einer Warnung zurück. Diese Nullen erscheinen endlich, prüfe daher ganzzahlige Nenner vor der Ganzzahldivision mit (d == 0).any(). Eine Warnung verdient auch dann Beachtung, wenn das Programm weiterläuft.

Über direkte Aktualisierung entscheiden

a += value verändert den vorhandenen Speicher und behält dessen Datentyp bei. Ist a ein Ganzzahl-Array, löst a += 0.5 einen Umwandlungsfehler aus, weil das Gleitkommaergebnis nach der Umwandlungsregel dieser Operation nicht gespeichert werden kann. a = a + 0.5 erstellt ein Gleitkommaergebnis und bindet a daran. Das unterscheidet sich von der Zuweisung einer einzelnen Dezimalzahl an ein Ganzzahlelement, bei der Nachkommastellen stillschweigend abgeschnitten werden können.

Einen mehrstufigen Ausdruck aufbauen

Für old = np.array([2.50, 4.00, 8.00]) und new = np.array([3.00, 3.00, 8.00]) ergibt (new - old) / old * 100 den Wert [20. -25. 0.]. Bestimme zunächst jede Änderung, dividiere dann durch ihren Ausgangswert und drücke anschließend das Verhältnis als Prozentsatz aus. Die Vorzeichen zeigen einen Anstieg, einen Rückgang und keine Änderung. Für diese Prozentrechnung dürfen die Ausgangswerte nicht null sein.

Eine universelle Funktion, kurz ufunc, wendet eine Berechnung separat auf jede Array-Position an. Diese Funktionen erweitern die Vektorisierung über gewöhnliche Arithmetik hinaus auf Wurzeln, Logarithmen, Rundung, Vergleiche und andere numerische Operationen.

Eine Funktion für Arrays wählen

Unäre ufuncs nehmen eine Eingabe entgegen. np.sqrt(np.array([1, 4, 9])) ergibt [1. 2. 3.], und np.abs(np.array([-2, 3])) ergibt [2 3]. np.exp ist die Exponentialfunktion, np.log der natürliche Logarithmus und np.log10 der Logarithmus zur Basis 10. Beispielsweise ist np.exp(0) gleich 1,0 und np.log10(1000) gleich 3,0.

Pythons Modul math arbeitet mit einzelnen Zahlen. math.sqrt(np.array([1, 4])) kann nicht beide Wurzeln berechnen und löst einen Typfehler aus. Verwende für numerische Arrays die NumPy-Variante. Auch Operatoren rufen ufuncs auf: a + b entspricht np.add(a, b) und a * b entspricht np.multiply(a, b).

Entsprechende Werte vergleichen oder ein ganzes Array reduzieren

Binäre ufuncs nehmen zwei Eingaben entgegen. np.maximum([1, 5, 3], [4, 2, 6]) ergibt [4 5 6] und wählt an jeder Position den größeren Wert. np.minimum wählt den kleineren, und np.power potenziert entsprechende Basen mit den jeweiligen Exponenten.

np.maximum(x, 0) setzt negative Einträge in einem neuen Ergebnis auf null. Das unterscheidet sich von np.max(x), einer Aggregation, die einen einzelnen größten Wert zurückgibt. Für [1, 5, 3] ergibt max den Wert 5; maximum benötigt eine weitere Eingabe und erhält die elementweise Struktur.

Nach der gewünschten Regel runden

np.round(x, 2) rundet auf zwei Nachkommastellen. Genaue Hälften folgen der Regel zur geraden Zahl: np.round([0.5, 1.5, 2.5]) ergibt [0. 2. 2.]. Die binäre Näherung kann Werte beeinflussen, die als Dezimalzahl wie genaue Hälften aussehen. Berücksichtige daher bei der Interpretation angezeigter Dezimalzahlen ihre Gleitkommadarstellung.

Werte außerhalb des Definitionsbereichs prüfen

Bei reellen Gleitkommaeingaben gibt np.sqrt(-1.0) unter den standardmäßigen Fehlereinstellungen NaN mit einer Warnung zurück, während np.log(0.0) minus unendlich mit einer Warnung zurückgibt. Anders als math.sqrt(-1) halten diese Aufrufe normalerweise nicht mit einem Definitionsbereichsfehler an. Prüfe die Eingaben, wenn die mathematische Operation einen eingeschränkten Wertebereich voraussetzt. np.isnan markiert NaN; np.isfinite markiert Werte, die weder NaN noch unendlich sind; np.isclose vergleicht Werte mit einer Toleranz.

Ufuncs zu einer nützlichen Berechnung kombinieren

Berechne für die Koordinaten-Arrays x = np.array([3, 5, 8]) und y = np.array([4, 12, 15]) den Abstand vom Ursprung mit np.sqrt(x ** 2 + y ** 2). Das Quadrieren ergibt [9 25 64] und [16 144 225]; die Addition ergibt [25 169 289]; die Wurzeln sind [5. 13. 17.]. np.hypot(x, y) berechnet diese Abstände direkt.

Broadcasting ermöglicht Arrays unterschiedlicher Form die Teilnahme an elementweisen Berechnungen. Die ausgerichteten Achsen bestimmen, welche Werte gepaart und welche wiederholt werden.

Dimensionen von rechts vergleichen

Richte Formen an ihren rechten Enden aus. Jedes Paar von Achsenlängen muss gleich sein oder eine Länge von 1 enthalten. Fehlende führende Achsen zählen als Länge 1. Eine Achse der Länge eins wird gedanklich an die andere Länge angepasst; NumPy muss die wiederholten Eingabewerte nicht kopieren.

Bei (4, 3) und (3,) stimmen die letzten Längen mit 3 überein. Die fehlende führende Dimension verhält sich wie 1 und wird auf 4 erweitert. Das Ergebnis ist (4, 3): Der Vektor wird auf jede Zeile angewendet. (4, 3) und (4,) schlagen fehl, weil die letzten Längen 3 und 4 nicht übereinstimmen und keine von beiden 1 ist. Ein inkompatibles Paar löst einen ValueError aus.

Spalten zentrieren oder standardisieren

X = np.array([[1, 10], [2, 20], [3, 30]])
centered = X - X.mean(axis=0)

Die Spaltenmittelwerte sind [2. 20.] mit der Form (2,). Sie passen zur letzten Achse von (3, 2) und ergeben [[-1. -10.] [0. 0.] [1. 10.]]. Die Division des zentrierten Ergebnisses durch X.std(axis=0) standardisiert jede Spalte und ergibt in beiden Spalten ungefähr −1,22, 0 und 1,22. Für diese Division darf die Streuung keiner Spalte null sein.

Eine Achse für Zeilenberechnungen erhalten

Verwende eine Ergebnistabelle mit vier Lernenden und drei Tests:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores.mean(axis=1) hat die Form (4,). Diese Form lässt sich nicht als ein Mittelwert pro Zeile durch Broadcasting mit (4, 3) kombinieren. Erhalte die entfernte Achse:

row_mean = scores.mean(axis=1, keepdims=True)
centered = scores - row_mean

row_mean hat nun die Form (4, 1). Die führende 4 passt zu den Zeilen; die abschließende 1 wird über drei Spalten erweitert. scores.mean(axis=1)[:, np.newaxis] erzeugt dieselbe Form. Für die Zeile [78, 85, 92] ergibt die Subtraktion ihres Mittelwerts 85 den Wert [-7. 0. 7.].

Mit derselben Regel eine Tabelle erstellen

np.arange(1, 4)[:, np.newaxis] * np.arange(1, 5) kombiniert (3, 1) und (4,). Beide Arrays werden auf die Ergebnisform (3, 4) erweitert und ergeben [[1 2 3 4] [2 4 6 8] [3 6 9 12]].

Eine Erweiterung kann auch unbeabsichtigt sein. Eine Spalte der Form (3, 1) minus ein Vektor der Form (3,) erzeugt alle neun paarweisen Differenzen mit der Form (3, 3). Wenn du drei entsprechende Differenzen beabsichtigt hast, bringe beide Eingaben auf die Form (3,), zum Beispiel mit column.ravel().

Jede Spalte vor dem Addieren gewichten

Für dieselbe Ergebnistabelle und w = np.array([0.2, 0.3, 0.5]) wendet scores * w die drei Gewichte auf jede Zeile an. Das Summieren mit .sum(axis=1) ergibt [87.1 62.8 92.4 74.8]. Das erste Ergebnis ist 15,6 + 25,5 + 46,0 = 87,1.

Eine Aggregation fasst Werte zu weniger Ergebnissen zusammen: einer Summe, einem Mittelwert, einem Extremwert oder einem Streuungsmaß. Die Wahl der Achse gehört zur Wahl der Fragestellung, denn sie bestimmt, welche Wertegruppen zusammengefasst werden.

Die angegebene Achse zusammenfassen

Bei einer Tabelle der Form (4, 3) mit vier Lernenden und drei Tests berücksichtigt eine Aggregation ohne axis alle 12 Werte. scores.sum() ergibt eine Gesamtsumme. scores.mean(axis=0) fasst die Achse der Lernenden zusammen und lässt drei Testmittelwerte übrig. scores.mean(axis=1) fasst die Testachse zusammen und lässt vier Mittelwerte der Lernenden übrig.

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

Die Gesamtsumme ist 941. Die Spaltenmittelwerte sind [75.5 78.5 81.25]; die Zeilenmittelwerte sind ungefähr [85. 64. 91.33 73.33]. Frag dich, welche Achse verschwinden soll. Die Aussage „Achse 0 bedeutet jede Zeile“ kehrt die Operation um: Achse 0 fasst Zeilen zusammen.

Die zurückzugebende Größe wählen

Methoden wie a.sum() und Funktionen wie np.sum(a) beschreiben dieselbe grundlegende Operation. Die NumPy-Methoden vermeiden das abweichende Verhalten der eingebauten Python-Funktionen. Beispielsweise addiert Pythons sum(scores) Zeilen-Arrays zu Spaltensummen, während scores.sum() alle Einträge zusammenfasst. Pythons max(scores) versucht, Zeilen zu vergleichen, und löst einen Fehler wegen eines mehrdeutigen Wahrheitswerts aus.

Positionen unterscheiden sich von Werten

scores.mean(axis=1).argmax() ist 2: Die dritte Person hat den höchsten Mittelwert. argmax gibt bei gleichen Maxima die erste Position zurück. Ohne Achse gibt es bei einer Tabelle einen zeilenweise abgeflachten Index zurück; scores.argmax() ist 8. np.unravel_index(8, scores.shape) stellt die Koordinate (2, 2) wieder her.

Verwende keepdims=True, wenn eine Aggregation zur ursprünglichen Tabelle passen muss. scores.sum(axis=1, keepdims=True) hat die Form (4, 1) und eignet sich damit für einen Normierungswert pro Zeile. Ohne diese Angabe hat das Ergebnis die Form (4,).

Zwischensummen erhalten, wenn die Reihenfolge wichtig ist

np.cumsum([3, 1, 4, 1, 5]) ergibt [3 4 8 9 14]. Jede Position enthält die Summe bis zu diesem Punkt. np.cumprod([1, 2, 3, 4]) ergibt entsprechend [1 2 6 24]. np.diff([3, 1, 4, 1, 5]) ergibt die vier Änderungen zwischen benachbarten Werten [-2 3 -3 4]. Gib bei einer Tabelle axis=1 an, um separate kumulative Summen entlang der Zeilen zu erhalten.

Die Konvention für die Streuung angeben

std und var dividieren die Summe der quadrierten Abweichungen standardmäßig durch die Anzahl der Werte: ddof=0. Verwende ddof=1 für die Stichprobenformel, deren Divisor um eins kleiner ist. Für [2, 4, 4, 4, 5, 5, 7, 9] ist der Mittelwert 5, die standardmäßige Standardabweichung 2,0 und die Stichprobenstandardabweichung etwa 2,14. Ein Bericht sollte deutlich machen, welche Konvention er verwendet.

Rangbasierte Kennwerte beschreiben, wo Werte in einer sortierten Verteilung liegen. Sortieren hilft auch dabei, Datensätzen Ränge zuzuweisen. Bei einer Tabelle musst du jedoch sorgfältig vorgehen, damit die Felder jedes Datensatzes zusammenbleiben.

Die Mitte und die Quartile bestimmen

Für x = np.array([12, 15, 11, 20, 18, 14]) lautet die sortierte Reihenfolge [11 12 14 15 18 20]. Bei sechs Werten bildet np.median(x) das arithmetische Mittel der beiden Werte in der Mitte, 14 und 15, und ergibt 14,5. Bei einer ungeraden Anzahl ist der Median der einzelne Wert in der Mitte.

np.percentile(x, q) erwartet einen Prozentsatz von 0 bis 100. np.quantile(x, q) erwartet den entsprechenden Anteil von 0 bis 1. Ihre standardmäßige lineare Interpolation kann einen Wert zwischen Beobachtungen ergeben. Bei sechs Werten liegt das 25. Perzentil an der von null aus gezählten Position 0,25 × 5 = 1,25. Diese liegt ein Viertel des Weges von 12 zu 14 und ergibt 12,5. Das 50. und das 75. Perzentil sind 14,5 und 17,25, der Interquartilsabstand ist also 4,75.

Der Median ist gegenüber einem Extremwert robuster als das arithmetische Mittel. Wird 200 zu diesen Daten hinzugefügt, steigt das arithmetische Mittel von 15,0 auf etwa 41,4; der Median steigt von 14,5 auf 15,0. Keines der beiden Maße allein beschreibt die ganze Verteilung.

Sortierte Daten oder Sortierpositionen wählen

np.sort(x) gibt eine sortierte Kopie zurück. x.sort() verändert x und gibt None zurück, sodass y = x.sort() keine sortierten Werte in y ablegt. Für absteigende Werte verwende np.sort(x)[::-1].

Bei einem 2-dimensionalen Array wird standardmäßig entlang der letzten Achse sortiert, also jede Zeile unabhängig. axis=0 sortiert jede Spalte unabhängig. Keine der beiden Operationen sortiert Datensätze. Für tab = np.array([[3, 1], [1, 2], [2, 0]]) ergibt np.sort(tab, axis=0) den Wert [[1 0] [2 1] [3 2]] und trennt damit Werte, die ursprünglich zusammengehörten.

Um Datensätze zu erhalten, ermittle eine Reihenfolge aus der Schlüsselspalte und wende sie auf ganze Zeilen an:

order = tab[:, 0].argsort()
ranked = tab[order]
# array([[1, 2], [2, 0], [3, 1]])

Dieselbe Indexreihenfolge kann zusammengehörige Vektoren neu anordnen. Wenn avg = np.array([85.0, 64.0, 91.33, 73.33]) und names = np.array(['Ana', 'Ben', 'Chen', 'Dara']) gilt, ordnet order = np.argsort(avg)[::-1] die Mittelwerte absteigend. names[order] ergibt ['Chen' 'Ana' 'Dara' 'Ben'].

Unterschiedliche Werte zählen und Zugehörigkeit prüfen

np.unique gibt sortierte unterschiedliche Werte zurück. Mit return_counts=True gibt es auch die zugehörigen Häufigkeiten zurück:

colors = np.array(['red', 'blue', 'red', 'green', 'blue', 'red'])
values, counts = np.unique(colors, return_counts=True)

Die Ausgaben sind ['blue' 'green' 'red'] und [2 1 3]. values[counts.argmax()] findet den häufigsten Wert, 'red'. Die Positionen der Häufigkeiten entsprechen denen der unterschiedlichen Werte.

np.isin(a, allowed) gibt eine Maske für die Zugehörigkeit zu einer Sammlung zurück. Für a = np.arange(1, 6) ergibt np.isin(a, [2, 4]) den Wert [False True False True False]. Damit lassen sich diese Werte oder die zugehörigen Datensätze auswählen.

Für fehlende Daten und gefilterte Teilmengen brauchst du eine ausdrückliche Regel zur Zusammenfassung. Ein numerisches Ergebnis kann falsch sein, selbst wenn die Array-Operation erfolgreich ausgeführt wird: Ein Platzhalter kann als Messwert gezählt oder eine leere Teilmenge für einen aussagekräftigen Mittelwert gehalten werden.

Fehlende Werte vor dem Zusammenfassen finden

NaN wird bei gewöhnlichen Summen und Mittelwerten weitergegeben. Für x = np.array([3.0, np.nan, 5.0]) ergeben sowohl x.sum() als auch x.mean() den Wert NaN. np.nansum(x) ergibt 8,0 und np.nanmean(x) ergibt 4,0; die fehlende Position wird übersprungen. Verwandte Funktionen sind nanmax, nanmin, nanstd und nanmedian. Sind alle Werte fehlend, gibt nanmean NaN mit einer Warnung zurück, weil keine beobachteten Werte übrig bleiben.

Für Sensormesswerte in °C:

r = np.array([21.5, np.nan, 22.1, 23.0, np.nan, 21.9])
missing = np.isnan(r)

missing.sum() ist 2, missing.mean() ist etwa 0,33, und r[~missing] behält vier Messwerte. np.nanmean(r) ist 22,125 und berücksichtigt nur diese vier Werte. Der Vergleich r == np.nan würde die fehlenden Messwerte nicht markieren.

Platzhaltercodes zuerst umwandeln

Eine Zahl wie −999 kann in einem Eingabesystem fehlende Daten darstellen. NumPy behandelt sie als echten Messwert, bis du sie ersetzt:

v = np.array([12, -999, 15, -999, 9]).astype(float)
v[v == -999] = np.nan
np.nanmean(v)  # 12.0

Wandle zuerst in Gleitkommazahlen um, weil ein Ganzzahl-Array NaN nicht speichern kann. Diese Ersetzung ist nur angebracht, wenn −999 für diese Daten als Fehlwertcode definiert ist.

Auffüllen verändert die Verteilung

Werden fehlende Temperaturen durch null ersetzt, beträgt der Mittelwert des Beispiels 14,75, obwohl keine Temperatur von null gemessen wurde. Das Auffüllen mit dem Mittelwert der beobachteten Werte, 22,125, erhält diesen Mittelwert, verringert aber die scheinbare Streuung. Ein aufgefüllter Wert ist eine eingefügte Schätzung; seine Auswirkung gehört daher zur Entscheidung über die Analyse.

Für eine 2-dimensionale Tabelle D fasst np.nanmean(D, axis=0) die beobachteten Werte jeder Spalte zusammen. Jede Spalte kann eine andere Anzahl haben. Um Zeilen mit einem oder mehreren fehlenden Werten zu entfernen:

complete = ~np.isnan(D).any(axis=1)
clean_rows = D[complete]

Die Reduktion erzeugt eine Entscheidung pro Zeile; die Negation behält Zeilen ohne fehlende Einträge. Mit D = np.array([[1., 2.], [np.nan, 4.], [5., np.nan], [7., 8.]]) bleiben so [[1. 2.] [7. 8.]] erhalten.

Eine Bedingung oder Gruppe zusammenfassen

Für Temperaturen t berechnet t[t > 20].mean() nur den Mittelwert der Tage über 20 °C. Verwende bei gruppierten Daten eine passende Bezeichnungsmaske: Mit group = np.array(['A', 'B', 'A', 'B', 'A']) und value = np.array([10, 20, 14, 26, 12]) ist value[group == 'A'].mean() gleich 12,0 und der entsprechende Mittelwert von B gleich 23,0. Durchlaufe np.unique(group), um dies für jede Gruppe zu wiederholen.

Prüfe mask.any(), bevor du eine gefilterte Teilmenge zusammenfasst. Der Mittelwert einer leeren Auswahl ist NaN mit einer Warnung, ihre Summe dagegen 0. Diese null kann eine sinnvolle leere Summe sein, belegt aber nicht, dass ein Messwert vorhanden war.

Ein Zufallszahlengenerator unterstützt Stichproben, das Mischen und Simulationen. Ein Startwert macht den Anfangszustand wiederholbar, sodass du eine Analyse erneut ausführen kannst, während du ihre Logik untersuchst.

Einen Generator erstellen und wiederverwenden

rng = np.random.default_rng(42)

NumPy empfiehlt diese Generator-Schnittstelle für neuen Code. Ihr standardmäßiger Bitgenerator ist PCG64. Ohne Startwert bezieht default_rng() neue Entropie aus dem Betriebssystem. Ältere Aufrufe wie np.random.seed und np.random.rand verwenden einen gemeinsamen globalen Zustand; Generator-Objekte ermöglichen einer Analyse, ihren eigenen Zustand direkt zu verwalten.

Pseudozufallswerte stammen aus einem deterministischen Algorithmus. Derselbe Anfangszustand und dieselbe Folge von Aufrufen reproduzieren die Zahlenfolge in derselben Umgebung. Jede Ziehung verändert den Zustand. Wird bei jedem Schleifendurchlauf ein neuer Generator mit dem Startwert 42 erstellt, beginnt die Folge erneut und wiederholt dieselben anfänglichen Ziehungen, statt sie fortzusetzen. Halte neben dem Startwert auch die NumPy-Version und den Code fest, denn die Kompatibilität der Folge zwischen Versionen oder allen Umgebungen ist nicht garantiert. Verwende für Passwörter oder Sicherheitstoken Pythons Modul secrets.

Eine Verteilung und eine Ausgabeform wählen

size kann eine Elementanzahl oder ein Formtupel sein. Bei normal ist loc der Mittelwert der Verteilung und scale ihre Standardabweichung. Eine Varianz von 100 benötigt daher scale=10. Der tatsächliche Mittelwert und die Standardabweichung einer kleinen Stichprobe müssen nicht exakt mit den Verteilungsparametern übereinstimmen.

Bei ganzzahligen Ziehungen ist die obere Schranke standardmäßig ausgeschlossen. Für einen Würfel brauchst du integers(1, 7), da integers(1, 6) keine 6 ziehen kann. integers(1, 6, endpoint=True) schließt die obere Schranke ein und modelliert ebenfalls einen Würfel.

Werte mit oder ohne Zurücklegen ziehen

rng.choice(['heads', 'tails'], size=5) führt fünf Ziehungen mit Zurücklegen aus. Ein Wert kann mehrfach erscheinen. Für unterschiedliche gezogene Positionen verwende replace=False; werden mehr Positionen angefordert, als die Grundgesamtheit enthält, wird ein ValueError ausgelöst. Wahrscheinlichkeiten können als p=[0.7, 0.3] in derselben Reihenfolge wie die Werte angegeben werden und müssen sich zu 1 summieren.

Ziehen ohne Zurücklegen verhindert, dass eine Eingabeposition zweimal ausgewählt wird. Enthält die Eingabe selbst doppelte Werte, können dennoch gleiche Werte in der Stichprobe erscheinen.

Datensätze mischen, ohne ihre Felder zu trennen

rng.shuffle(a) ordnet das vorhandene Array neu und gibt None zurück. rng.permutation(a) gibt eine gemischte Kopie zurück. rng.permutation(10) ergibt die Ganzzahlen 0 bis einschließlich 9 in zufälliger Reihenfolge, die sich als Zeilenindizes eignen.

Bei einem 2-dimensionalen Array ist die Standardachse 0: Ganze Zeilen werden zusammen verschoben. So bleiben die Felder jeder Beobachtung aufeinander ausgerichtet. Um zwei zusammengehörige Arrays einheitlich zu mischen, erzeuge eine Permutation ihrer gemeinsamen Datensatzindizes und wende sie auf beide an.

Eine vektorisierte Simulation stellt wiederholte Versuchsdurchläufe als Arrays dar, wendet die Ereignisregel auf diese Arrays an und fasst die Ergebnisse zusammen. Die Form des Arrays sollte zeigen, was ein Versuchsdurchlauf enthält.

Ein Ereignis in einen Anteil umwandeln

rng = np.random.default_rng(42)
rolls = rng.integers(1, 7, size=100_000)
estimate = (rolls == 6).mean()

Die Maske ist für jede beobachtete 6 einmal wahr. Ihr Mittelwert schätzt die Wahrscheinlichkeit dieses Ereignisses, nahe 1/6 beziehungsweise etwa 0,1667. rolls.mean() beantwortet eine andere Frage: die durchschnittliche Augenzahl, nahe 3,5. Ein fester Startwert wiederholt eine Schätzung, macht sie aber nicht exakt.

Vektorisierung vermeidet Arbeit auf Python-Ebene für jede Ziehung und macht große Simulationen oft deutlich schneller als eine Schleife. Die Beschleunigung hängt von der Berechnung, der Array-Größe und dem Computer ab und ist daher keine feste Eigenschaft des Ereignisses.

Eine Zeile pro Versuchsdurchlauf mit mehreren Werten verwenden

Um in jedem Versuchsdurchlauf zwei Würfel zu simulieren:

dice = rng.integers(1, 7, size=(100_000, 2))
totals = dice.sum(axis=1)
p_seven = (totals == 7).mean()

Die Tabelle hat 100.000 Zeilen für Versuchsdurchläufe und zwei Würfelspalten. Das Reduzieren von Achse 1 ergibt eine Summe pro Versuchsdurchlauf. Sechs der 36 gleich wahrscheinlichen geordneten Paare ergeben die Summe 7, daher sollte die geschätzte Wahrscheinlichkeit nahe 6/36 liegen. Das Reduzieren von Achse 0 würde dagegen zwei Summen über alle Versuchsdurchläufe ergeben und das Ereignis auf Ebene der einzelnen Durchläufe verlieren.

Auch größere Simulationen schwanken

Für unabhängige Versuchsdurchläufe ist der Standardfehler eines geschätzten Anteils:

Dabei ist $p$ die Ereigniswahrscheinlichkeit und $n$ die Anzahl der Versuchsdurchläufe. Für eine gewürfelte 6 bei 100.000 Durchläufen beträgt er etwa 0,0012. Nach einer Normalapproximation liegen etwa 95 % der Schätzungen höchstens 0,0023 von 1/6 entfernt. Eine Erhöhung der Anzahl der Versuchsdurchläufe um den Faktor 100 verringert den Standardfehler um den Faktor 10. Mehr Ziehungen korrigieren kein falsch programmiertes Ereignis.

Eine Zufallsbewegung erstellen und untersuchen

steps = rng.choice([-1, 1], size=1000) zieht Schritte nach links oder rechts. walk = steps.cumsum() ergibt die Position nach jedem Schritt. Maximum und Minimum geben die äußersten erreichten Positionen an. Um den ersten Punkt zu finden, der mindestens 10 Einheiten vom Start entfernt ist:

hit = np.abs(walk) >= 10
if hit.any():
    step_count = hit.argmax() + 1

argmax findet den ersten wahren Eintrag, gibt aber auch 0 zurück, wenn alle Einträge falsch sind. Die Prüfung mit any() unterscheidet einen tatsächlichen Treffer von keinem Treffer. Addiere 1, weil die Array-Position 0 die Position nach Schritt 1 ist.

Für viele Zufallsbewegungen summiert rng.choice([-1, 1], size=(5000, 1000)).cumsum(axis=1) jede Zeile separat. walks[:, -1] wählt alle Endpositionen aus; ihr Mittelwert liegt nahe 0 und ihre Standardabweichung nahe der Quadratwurzel aus 1.000, also etwa 31,6.

Permutationen und exakte Prüfungen nutzen

Für eine zufällige Aufteilung von 100 Datensätzen kannst du idx = rng.permutation(100) und dann data[idx[:80]] und data[idx[80:]] verwenden. Die beiden disjunkten Slices einer Permutation ordnen jeden Datensatz genau einmal zu. Vergleiche bei einer Simulation einen einfachen Fall mit einer exakten Antwort, etwa dem Würfelmittelwert 3,5, bevor du komplizierteren Ausgaben vertraust.