6.12. Auswahl und Umsortierung#

Reduktionen fassten ein Array zu einem Skalar oder einem Ergebnis niedrigeren Rangs zusammen. Die Auswahl umfasst die Operationen, die festlegen, welche Elemente überleben und wo sie landen: bedingte Auswahl, Begrenzen, Sortieren, Nachschlagen von Indizes, Umsortieren entlang einer Achse.

6.12.1. Bedingte Auswahl#

where() gibt ein Array zurück, das Elemente aus x übernimmt, wo die Bedingung wahr ist, und andernfalls aus y. Die drei Operanden werden gemeinsam gebroadcastet:

a = np.array([1, 2, 3, 4, 5], dtype=np.float)
np.where(a < 3, a, 0.0)
# array([1.0, 2.0, 0.0, 0.0, 0.0])

Dies ist das richtige Werkzeug für ein „if/else pro Element“, ohne eine Python-Schleife zu schreiben.

clip() ist eine Kurzform für maximum(lo, minimum(a, hi)) – es sättigt die Werte auf einen Bereich:

np.clip(a, 2.0, 4.0)
# array([2.0, 2.0, 3.0, 4.0, 4.0])

maximum() und minimum() nehmen zwei Operanden und geben elementweise den größeren / kleineren zurück:

np.maximum(a, 3.0)
np.minimum(a, np.array([5, 4, 3, 2, 1]))

6.12.2. Indizes finden#

nonzero() gibt die Koordinaten jedes Elements ungleich null zurück, aufgeteilt in ein Index-Array pro Dimension. Für eine zweidimensionale Eingabe ist das Ergebnis ein Tupel aus zwei Arrays: Das erste enthält die Zeilenindizes, das zweite die Spaltenindizes. Spaltenweise zusammengefasst ergeben sie die (row, col) jeder Position ungleich null:

m = np.array([[0, 2, 0],
              [3, 0, 0]], dtype=np.float)
np.nonzero(m)
# (array([0, 1], dtype=uint16), array([1, 0], dtype=uint16))

Die Einträge ungleich null in m sind m[0, 1] = 2 und m[1, 0] = 3. Das erste zurückgegebene Array [0, 1] liefert deren Zeilenindizes; das zweite [1, 0] liefert deren Spaltenindizes. Liest man die beiden Arrays nebeneinander, erhält man die Positionen (0, 1) und (1, 0) zurück.

Zwei Reduktionen erzeugen ebenfalls Indizes:

  • argmin() / argmax() – Index des kleinsten / größten Elements.

  • argsort() – ein Integer-Array, das die Eingabe entlang der angegebenen Achse sortieren würde (standardmäßig die letzte):

    a = np.array([40, 10, 30, 20], dtype=np.uint8)
idx = np.argsort(a)             # array([1, 3, 2, 0], dtype=uint16)
a[idx]                          # array([10, 20, 30, 40])

    argsort gibt immer uint16 zurück; das zu sortierende Array darf daher auf der sortierten Achse nicht mehr als 65.535 Elemente haben.

bincount() zählt das Vorkommen jeder nicht-negativen Ganzzahl in einer eindimensionalen uint8 / uint16-Eingabe:

histogram = np.bincount(np.array([0, 1, 1, 2, 2, 2], dtype=np.uint8))
# array([1, 2, 3], dtype=uint16)

Nützlich, um Histogramme von Pixelwerten mit kleinen Ganzzahlen zu erstellen, ohne eine Python-Schleife zu schreiben.

6.12.3. Sortieren und Umsortieren#

sort() gibt eine sortierte Kopie des Arrays entlang der angegebenen Achse zurück (standardmäßig die letzte). Verwenden Sie sort() direkt auf dem Array für eine In-Place-Version:

np.sort(np.array([3, 1, 2], dtype=np.float))
# array([1.0, 2.0, 3.0])

flip() kehrt die Reihenfolge entlang der angegebenen Achse um (jede Achse, wenn kein axis übergeben wird):

np.flip(np.array([1, 2, 3, 4]))
# array([4, 3, 2, 1])

roll() verschiebt Elemente zyklisch um die angegebene Anzahl. Nützlich zur Implementierung eines Schieberegisters im Ringpuffer-Stil:

np.roll(np.array([1, 2, 3, 4]), 1)
# array([4, 1, 2, 3])

take() ist die explizite Form der Fancy-Indizierung – Elemente an beliebigen Indizes auswählen:

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

6.12.4. Filtern und strukturelle Bearbeitungen#

compress() ist die explizite Form der booleschen Indizierung – es gibt die durch die boolesche Bedingung ausgewählten Ausschnitte von a zurück:

a = np.array([10, 20, 30, 40], dtype=np.uint8)
np.compress(a > 15, a)
# array([20, 30, 40], dtype=uint8)

delete() gibt eine Kopie zurück, in der die Einträge an den angegebenen Indizes entfernt sind:

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.delete(a, [1, 3])
# array([10, 30, 50], dtype=uint8)

diff() gibt die n-te diskrete Vorwärtsdifferenz des Arrays entlang einer Achse zurück. Wird verwendet, um Änderungen erster Ordnung zwischen benachbarten Samples zu berechnen:

samples = np.array([1, 3, 6, 10, 15], dtype=np.float)
np.diff(samples)
# array([2.0, 3.0, 4.0, 5.0])

6.12.5. Was jede Operation kostet#

Fast jede Funktion auf dieser Seite gibt ein neu allokiertes Array zurück. Zwei Ausnahmen:

  • sort() sortiert in-place; die freie Funktion sort() gibt eine sortierte Kopie zurück.

  • take() akzeptiert ein Schlüsselwort out=, um in einen bereits vorhandenen Puffer zu schreiben.

In einer Schleife, die viele Male pro Sekunde läuft, sollte das In-Place-sort() bevorzugt und überall sonst vorab allokierte Puffer wiederverwendet werden. Boolesche Masken selbst werden bei jeder Ausführung des Vergleichs allokiert – erstellen Sie eine Maske einmal und verwenden Sie sie über mehrere Operationen hinweg wieder, anstatt sie in jeder Iteration neu aufzubauen.