# Wat is np.where in Python?

Je kunt de functie `np.where()` gebruiken om met NumPy-arrays in Python te werken. Dankzij de gevectoriseerde bewerkingen is deze functie efficiënter dan op loops gebaseerde methoden.

## Wat doet np.where?

De Python-functie `np.where()` is een krachtige methode uit de NumPy-bibliotheek en wordt gebruikt voor het selecteren van elementen uit een array. Het identificeert en extraheert elementen die **aan een bepaalde voorwaarde voldoen** en retourneert vervolgens indices of waarden die aan die voorwaarde voldoen.

De functie wordt gebruikt in verschillende domeinen, zoals gegevensverwerking, wetenschappelijke berekeningen, machine learning en gegevensanalyse. Bij gegevensmanipulatie maakt `np.where()` het mogelijk om **gegevens te filteren** en waarden in arrays te vervangen.

## Wat is de syntaxis van np.where in Python?

De functie `np.where()` neemt een **NumPy-achtige array** die bestaat uit bijvoorbeeld gehele getallen of Booleaanse waarden. De syntaxis ziet er als volgt uit:

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

- `condition`: Dit is de voorwaarde die op de array wordt toegepast om te bepalen welke elementen worden geselecteerd.
- `x` en `y` (optioneel): Als u `x` en `y` opgeeft, worden de waarden uit `x` geretourneerd wanneer aan de voorwaarde wordt voldaan. Anders worden de waarden uit `y` geretourneerd. Als u `x` en `y` niet opgeeft, retourneert `np.where()` de indices die aan de voorwaarde voldoen.

Na uitvoering retourneert `np.where()` een **nieuwe NumPy-array**. De nieuwe array is het resultaat van het filteren of selecteren van elementen uit de oorspronkelijke array op basis van de voorwaarde.

## Voorbeelden van het gebruik van np.where

De `np.where()` is een veelzijdig hulpmiddel voor het toepassen van voorwaarden op arrays en is erg handig voor het bewerken van gegevens. Hieronder bekijken we enkele voorbeelden van hoe je deze methode kunt gebruiken.

### Elementen in een NumPy-array vervangen

Met de functie `np.where()` in NumPy kun je elementen in een array vervangen op basis van een voorwaarde. Voordat je begint, kun je Python-lijsten omzetten in arrays met behulp van `np.array()`.

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

Nu we onze array hebben, willen we een voorwaarde definiëren om elementen groter dan 3 te identificeren. We kunnen dit doen met een voorwaarde die `True` is voor elementen die groter zijn dan 3 en anders false:

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

Vervolgens gebruiken we `np.where()` en voeren we deze voorwaarde in. We stellen ook vast dat waarden die aan de voorwaarde voldoen, worden vervangen door -1 en alle andere waarden worden vervangen door 0.

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

Het resultaat, `new_arr`, bevat de array die op basis van de voorwaarde is gewijzigd. In de uitvoer worden waarden die groter zijn dan 3 vervangen door -1. Alle andere waarden worden vervangen door 0.

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

### Gebruik np.where met één voorwaarde

Als u `np.where()` gebruikt met slechts één voorwaarde en zonder vervangende waarden, retourneert het een **tuple van indices** waarvoor de voorwaarde waar is.

```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 dit voorbeeld is `arr` een NumPy-array die waarden van 1 tot 5 bevat. `condition = arr > 2` creëert een Booleaans masker dat elementen in `arr` identificeert die groter zijn dan 2. `np.where(condition)` wordt uitgevoerd zonder vervangende waarden en retourneert als resultaat een tuple van indices die voldoen aan de voorwaarde `arr > 2`. De uitvoer is een array van indices waarin de elementen groter zijn dan 2.

### Uitzending met np.where

In NumPy maakt broadcasting het mogelijk om bewerkingen uit te voeren met arrays van verschillende vormen, mits aan bepaalde voorwaarden wordt voldaan. Wanneer arrays verschillende vormen hebben, zal NumPy proberen ze te vergroten zodat ze compatibel zijn.

Stel dat we een NumPy-array `arr` hebben met de vorm (3, 3):

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

En we hebben nog een NumPy-array `row` met de vorm (3,):

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

De vormen van de twee arrays komen niet helemaal overeen, maar met behulp van broadcasting kunnen bewerkingen tussen beide worden uitgevoerd. Als we bijvoorbeeld de waarden van elke rij van `arr` willen optellen bij de waarden in `row`, dan is dat mogelijk met broadcasting.

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

In het bovenstaande voorbeeld werd de eendimensionale array `row` vergroot tot een (3, 3) matrix om overeen te komen met de vorm van `arr`. Vervolgens werden de elementen van `arr` en `row` element voor element bij elkaar opgeteld.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-npwhere-methode/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-npwhere-methode/) for AI/LLM consumption.