Python np.where Method

Mit der np.where()-Funktion können Sie gezielt mit NumPy-Arrays in Python arbeiten. Durch ihre vek­to­ri­sier­ten Ope­ra­tio­nen ist sie zudem ef­fi­zi­en­ter im Vergleich zu schlei­fen­ba­sier­ten Methoden.

Wozu dient np.where in Python?

Die np.where()-Funktion in Python ist eine leis­tungs­fä­hi­ge Methode aus der Bi­blio­thek NumPy, die für die bedingte Auswahl von Elementen aus einem Array geeignet ist. Sie iden­ti­fi­ziert und ex­tra­hiert Elemente, die eine bestimmte Bedingung erfüllen, und gibt die Indizes oder die Werte zurück, die dieser Bedingung ent­spre­chen.

Die np.where()-Funktion wird in ver­schie­de­nen Bereichen ein­ge­setzt, darunter Da­ten­ver­ar­bei­tung, wis­sen­schaft­li­che Be­rech­nun­gen, ma­schi­nel­les Lernen und Da­ten­ana­ly­se. In der Da­ten­ma­ni­pu­la­ti­on er­mög­licht np.where() das Filtern von Daten auf der Grundlage be­stimm­ter Kriterien und das Ersetzen von Werten in Arrays.

Das ist die Syntax von Python np.where()

Die np.where()-Funktion ak­zep­tiert ein NumPy-artiges Array, das bei­spiels­wei­se aus Integern oder boole­schen Werten besteht. Die Syntax der np.where()-Funktion in Python sieht konkret fol­gen­der­ma­ßen aus:

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

• condition: Das ist die Bedingung, die auf das Array an­ge­wen­det wird, um zu bestimmen, welche Elemente aus­ge­wählt werden sollen.
• x und y (optional): Falls nur condition angegeben ist, gibt np.where() die Indizes der Elemente zurück, die die Bedingung erfüllen. Wenn x und y spe­zi­fi­ziert sind, werden die Werte aus x zu­rück­ge­ge­ben, wo die Bedingung erfüllt ist, und die Werte aus y an­dern­falls.

Nachdem die np.where()-Funktion auf­ge­ru­fen wurde, gibt sie als Ergebnis einen neuen NumPy-Array zurück. Dieser neue Array entsteht durch Filtern oder Auswählen von Elementen des ur­sprüng­li­chen Arrays, basierend auf einer Bedingung. Hierbei ent­spricht jeder Wert True oder False in diesem Be­din­gungs­ar­ray der Auswahl oder Filterung des ent­spre­chen­den Elements im ur­sprüng­li­chen Array.

Beispiele für den Einsatz von np.where()

Die Methode np.where() ist aufgrund ihrer Fähigkeit, bedingte Ope­ra­tio­nen auf Arrays durch­zu­füh­ren, ein äußerst viel­sei­ti­ges Werkzeug und eignet sich sehr gut, um Daten zu ma­ni­pu­lie­ren.

Elemente in einem NumPy-Array ersetzen

Die np.where()-Funktion in NumPy er­mög­licht es, Elemente in einem Array basierend auf einer Bedingung zu ersetzen. Dabei können Sie Python-Lists mit np.array() in ein Array wandeln:

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

Nun wollen wir eine Bedingung de­fi­nie­ren, um Elemente zu iden­ti­fi­zie­ren, die größer als 3 sind. Dies geschieht durch Erstellen einer Be­din­gungs­mas­ke, die True ist für Elemente, die größer als 3 sind, und sonst False:

condition = arr > 3

An­schlie­ßend verwenden wir np.where() und geben diese Bedingung an. Dabei wird fest­ge­legt, dass Werte, die der Bedingung ent­spre­chen, durch -1 ersetzt werden, während alle anderen Werte mit 0 aus­ge­tauscht werden:

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

Das Ergebnis, new_arr, enthält das mo­di­fi­zier­te Array nach dem Ersetzen gemäß der Bedingung. Die Ausgabe wird zeigen, dass Werte, die größer als 3 waren, durch -1 ersetzt wurden, während die anderen Werte durch 0 ersetzt wurden:

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

np.where() mit nur einer Bedingung verwenden

Wenn numpy.where() nur mit einer Bedingung und ohne Angabe von Er­satz­wer­ten ein­ge­setzt wird, gibt sie ein Tupel von Indizes zurück, an denen die Bedingung True ist.

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 Beispiel ist arr ein NumPy-Array, das Werte von 1 bis 5 enthält. condition = arr > 2 erstellt eine boolesche Maske, die Elemente in arr iden­ti­fi­ziert, die größer als 2 sind. np.where(condition) wird ohne Angabe von Er­satz­wer­ten auf­ge­ru­fen. Dadurch wird ein Tupel von Indizes zu­rück­ge­ge­ben, bei denen die Bedingung arr > 2 erfüllt ist. Die Ausgabe wird ein Array von Indizes sein, wo die Elemente von arr größer als 2 sind.

Broad­cas­ting mit np.where()

Broad­cas­ting in NumPy erlaubt Ope­ra­tio­nen zwischen Arrays mit un­ter­schied­li­chen Formen, solange bestimmte Regeln erfüllt sind. Wenn Arrays un­ter­schied­li­che Formen haben, versucht NumPy, diese so zu ver­grö­ßern, dass sie kom­pa­ti­bel werden.

An­ge­nom­men, wir haben 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 wir haben einen weiteren NumPy-Array row mit der Form (3,):

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

Hier ist die Form von arr (3, 3) und die Form von row (3,). Obwohl die Formen nicht genau über­ein­stim­men, kann Broad­cas­ting verwendet werden, um eine Operation zwischen diesen Arrays aus­zu­füh­ren.

Nun wollen wir die Werte in jeder Zeile von arr mit den Werten in row addieren. Hier kommt Broad­cas­ting ins Spiel:

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

Die ein­di­men­sio­na­le row wurde in eine (3, 3)-Matrix ver­grö­ßert, um mit der Form von arr zu passen, indem sie über die Zeilen wie­der­holt wurde. An­schlie­ßend wurden die Elemente von arr und row ele­ment­wei­se addiert.