Python-Methode np.where im Detail

Mit der np.where()-Funktion arbeitest du gezielt mit NumPy-Arrays in Python. Dank ihrer vek­to­ri­sier­ten Ope­ra­tio­nen ist sie deutlich ef­fi­zi­en­ter als klas­si­sche Methoden mit Schleifen.

Was macht np.where in Python?

Die np.where()-Funktion in Python ist ein starkes Werkzeug aus der NumPy-Bi­blio­thek, um Elemente aus einem Array bedingt aus­zu­wäh­len. Sie findet Elemente, die eine bestimmte Bedingung erfüllen, und liefert dir entweder die Indizes oder direkt die passenden Werte zurück.

Die np.where()-Funktion ist viel­sei­tig ein­setz­bar – egal ob in der Da­ten­ver­ar­bei­tung, bei wis­sen­schaft­li­chen Be­rech­nun­gen, im Machine Learning oder der Da­ten­ana­ly­se. Bei der Da­ten­ma­ni­pu­la­ti­on hilft dir np.where() dabei, Daten nach Kriterien zu filtern und Werte in Arrays effizient zu ersetzen.

So sieht die Syntax von Python np.where() aus

Die np.where()-Funktion nutzt ein NumPy-artiges Array, das zum Beispiel aus Ganz­zah­len oder boole­schen Werten besteht. Die konkrete Syntax der np.where()-Funktion in Python ist wie folgt aufgebaut:

import numpy as np
np.where(condition[, x, y])

• condition: Dies ist die Bedingung für das Array, nach der die Elemente aus­ge­wählt werden.
• x und y (optional): Gibst du nur condition an, liefert np.where() die Indizes der passenden Elemente. Sind x und y definiert, werden bei erfüllter Bedingung Werte aus x zu­rück­ge­ge­ben, ansonsten die aus y.

Nach dem Aufruf liefert die np.where()-Funktion ein neues NumPy-Array als Ergebnis. Dieses entsteht durch das Filtern oder Auswählen basierend auf deiner Bedingung. Dabei ent­spricht jeder Wert True oder False im Be­din­gungs­ar­ray der Auswahl des ent­spre­chen­den Elements im Original-Array.

An­wen­dungs­bei­spie­le für np.where()

Da die Methode np.where() bedingte Ope­ra­tio­nen direkt auf Arrays ausführt, ist sie ein extrem flexibles Tool für deine Da­ten­ma­ni­pu­la­ti­on.

Elemente in einem NumPy-Array aus­tau­schen

Mit np.where() in NumPy ersetzt du Elemente in einem Array ganz einfach nach einer Bedingung. Dabei kannst du Python-Lists mit np.array() in ein Array umwandeln:

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

De­fi­nie­ren wir nun eine Bedingung für Elemente, die größer als 3 sind. Wir erstellen eine Maske, die True ist, wenn der Wert über 3 liegt, und ansonsten False:

condition = arr > 3

Jetzt nutzen wir np.where() mit dieser Bedingung. Wir legen fest, dass passende Werte durch -1 und alle anderen durch 0 ersetzt werden:

new_arr = np.where(condition, -1, 0)

Das Ergebnis new_arr zeigt das an­ge­pass­te Array. Die Ausgabe bestätigt: Alle Werte über 3 wurden zu -1, die rest­li­chen zu 0:

print(new_arr)
# Output: [0 0 0 -1 -1]

np.where() mit nur einer Bedingung nutzen

Ver­wen­dest du numpy.where() nur mit einer Bedingung (ohne Er­satz­wer­te), erhältst du ein Tupel von Indizes, an denen die Bedingung True ergibt.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
condition = arr > 2
result = np.where(condition)
print(result)
# Output: (array([2, 3, 4]),)

In diesem Fall ist arr ein NumPy-Array mit den Werten 1 bis 5. condition = arr > 2 erstellt eine boolesche Maske für alle Elemente in arr, die größer als 2 sind. Da np.where(condition) ohne Er­satz­wer­te auf­ge­ru­fen wird, liefert es die Indizes zurück, für welche die Bedingung arr > 2 zutrifft. Du erhältst also ein Array mit den Po­si­tio­nen, an denen die Werte in arr größer als 2 sind.

Broad­cas­ting mit np.where()

Broad­cas­ting erlaubt in NumPy Ope­ra­tio­nen zwischen Arrays mit ver­schie­de­nen Formen, sofern sie kom­pa­ti­bel sind. NumPy versucht dann, die Arrays so zu “dehnen”, dass sie zu­sam­men­pas­sen.

Nehmen wir ein NumPy-Array arr mit der Form (3, 3):

import numpy as np
arr = np.array([[1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]])

Und ein weiteres Array row mit der Form (3,):

row = np.array([10, 11, 12])

Die Formen von arr (3, 3) und row (3,) sind un­ter­schied­lich, aber dank Broad­cas­ting können wir sie trotzdem kom­bi­nie­ren.

Wir addieren nun die Werte jeder Zeile von arr mit den Werten aus row:

result = arr + row
print(result)
# Output: [[11 13 15]
    [14 16 18]
    [17 19 21]]

Dabei wurde die ein­di­men­sio­na­le row virtuell zu einer (3, 3)-Matrix erweitert, um zur Form von arr zu passen. Danach wurden die Elemente von arr und row schritt­wei­se addiert.