# Python np.where Method

Mit der `np.where()`-Funktion können Sie gezielt mit NumPy-Arrays in Python arbeiten. Durch ihre vektorisierten Operationen ist sie zudem effizienter im Vergleich zu schleifenbasierten Methoden.

## Wozu dient np.where in Python?

Die `np.where()`-Funktion in Python ist eine leistungsfähige Methode aus der Bibliothek NumPy, die für die bedingte Auswahl von Elementen aus einem Array geeignet ist. Sie identifiziert und extrahiert Elemente, die **eine bestimmte Bedingung erfüllen**, und gibt die Indizes oder die Werte zurück, die dieser Bedingung entsprechen.

Die `np.where()`-Funktion wird in verschiedenen Bereichen eingesetzt, darunter Datenverarbeitung, wissenschaftliche Berechnungen, maschinelles Lernen und Datenanalyse. In der Datenmanipulation ermöglicht `np.where()` das **Filtern von Daten** auf der Grundlage bestimmter Kriterien und das Ersetzen von Werten in Arrays.

## Das ist die Syntax von Python `np.where()`

Die `np.where()`-Funktion akzeptiert ein **NumPy-artiges Array**, das beispielsweise aus Integern oder booleschen Werten besteht. Die Syntax der `np.where()`-Funktion in Python sieht konkret folgendermaßen aus:

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

- `condition`: Das ist die Bedingung, die auf das Array angewendet wird, um zu bestimmen, welche Elemente ausgewä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` spezifiziert sind, werden die Werte aus `x` zurückgegeben, wo die Bedingung erfüllt ist, und die Werte aus `y` andernfalls.

Nachdem die `np.where()`-Funktion aufgerufen wurde, gibt sie als Ergebnis einen **neuen NumPy-Array** zurück. Dieser neue Array entsteht durch Filtern oder Auswählen von Elementen des ursprünglichen Arrays, basierend auf einer Bedingung. Hierbei entspricht jeder Wert `True` oder `False` in diesem Bedingungsarray der Auswahl oder Filterung des entsprechenden Elements im ursprünglichen Array.

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

Die Methode `np.where()` ist aufgrund ihrer Fähigkeit, **bedingte Operationen** auf Arrays durchzuführen, ein äußerst vielseitiges Werkzeug und eignet sich sehr gut, um Daten zu manipulieren.

### Elemente in einem NumPy-Array ersetzen

Die `np.where()`-Funktion in NumPy ermöglicht es, Elemente in einem Array basierend auf einer Bedingung zu ersetzen. Dabei können Sie [Python-Lists](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-list/) mit `np.array()` in ein Array wandeln:

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

Nun wollen wir eine Bedingung definieren, um Elemente zu identifizieren, die größer als 3 sind. Dies geschieht durch Erstellen einer Bedingungsmaske, die `True` ist für Elemente, die größer als 3 sind, und sonst `False`:

```python
condition = arr > 3
```

Anschließend verwenden wir `np.where()` und geben diese Bedingung an. Dabei wird festgelegt, dass Werte, die der Bedingung entsprechen, durch -1 ersetzt werden, während alle anderen Werte mit 0 ausgetauscht werden:

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

Das Ergebnis, `new_arr`, enthält das modifizierte 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:

```python
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 Ersatzwerten eingesetzt wird, gibt sie ein **Tupel von Indizes** zurück, an denen die Bedingung `True` ist.

```python
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` identifiziert, die größer als 2 sind. `np.where(condition)` wird ohne Angabe von Ersatzwerten aufgerufen. Dadurch wird ein Tupel von Indizes zurückgegeben, 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.

### Broadcasting mit `np.where()`

Broadcasting in NumPy erlaubt Operationen zwischen Arrays mit unterschiedlichen Formen, solange bestimmte Regeln erfüllt sind. Wenn Arrays unterschiedliche Formen haben, versucht NumPy, diese so zu vergrößern, dass sie kompatibel werden.

Angenommen, wir haben ein NumPy-Array `arr` mit der Form (3, 3):

```python
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,):

```python
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 übereinstimmen, kann Broadcasting verwendet werden, um eine Operation zwischen diesen Arrays auszuführen.

Nun wollen wir die Werte in jeder Zeile von `arr` mit den Werten in `row` addieren. Hier kommt Broadcasting ins Spiel:

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

Die eindimensionale `row` wurde in eine (3, 3)-Matrix vergrößert, um mit der Form von `arr` zu passen, indem sie über die Zeilen wiederholt wurde. Anschließend wurden die Elemente von `arr` und `row` elementweise addiert.


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/python-npwhere-method/](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-npwhere-method/) for AI/LLM consumption.