# La méthode Python np.where expliquée en détail

La fonction `np.where()` permet de travailler de manière ciblée avec des tableaux NumPy en Python. Grâce à ses opérations vectorisées, elle est plus efficace que les méthodes basées sur des boucles.

## Fonction `np.where()` en Python : à quoi ça sert ?

La fonction `np.where()` en Python est une méthode puissante de la bibliothèque NumPy, adaptée à la sélection conditionnelle d’éléments dans un tableau. Elle identifie et extrait les éléments qui **répondent à une certaine condition** et renvoie les indices ou les valeurs qui correspondent à cette condition.

La fonction `np.where()` est utilisée dans différents domaines, notamment le traitement des données, le calcul scientifique, l’apprentissage automatique (*machine learning*) et l’analyse des données. Dans la manipulation de données, `np.where()` permet de **filtrer des données** sur la base de certains critères et de remplacer des valeurs dans des tableaux.

## Python `np.where()` : syntaxe

La fonction `np.where()` accepte un **tableau de type NumPy**, composé par exemple d’entiers ou de valeurs booléennes. La syntaxe de la fonction `np.where()` en Python se présente comme suit :

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

- `condition` : c’est la condition qui est appliquée au tableau pour déterminer les éléments qui doivent être sélectionnés.
- `x` et `y` (facultatif) : si seule `condition` est indiquée, `np.where()` renvoie les indices des éléments qui remplissent la condition. Si `x` et `y` sont spécifiés, les valeurs de `x` sont renvoyées si la condition est remplie, et les valeurs de `y` dans le cas contraire.

La fonction `np.where()` renvoie en résultat un **nouveau tableau NumPy**. Ce nouveau tableau est créé en filtrant ou en sélectionnant des éléments du tableau original, sur la base d’une condition. Dans ce cas, chaque valeur `True` ou `False` dans ce tableau de conditions correspond à la sélection ou au filtrage de l’élément correspondant dans le tableau d’origine.

## Exemple d’utilisation de `np.where()`

La méthode `np.where()` est un outil extrêmement polyvalent en raison de sa capacité à effectuer des **opérations conditionnelles** sur des tableaux. Elle est très adaptée à la manipulation de données.

### Remplacer des éléments dans un tableau NumPy

La fonction `np.where()` de NumPy permet de remplacer des éléments dans un tableau en se basant sur une condition. Pour cela, vous pouvez convertir des listes Python en un tableau avec `np.array()` :

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

Nous voulons maintenant définir une condition pour identifier les éléments qui sont plus grands que 3. Pour cela, il faut créer un masque de condition, `True`, pour les éléments qui sont plus grands que 3 et un masque `False` pour ceux qui ne le sont pas.

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

Ensuite, nous utilisons `np.where()` et indiquons cette condition. On précise alors que les valeurs qui correspondent à la condition sont remplacées par -1, tandis que toutes les autres valeurs sont remplacées par 0 :

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

Le résultat, `new_arr`, contient le tableau modifié après le remplacement selon la condition. La sortie montrera que les valeurs supérieures à 3 ont été remplacées par -1, tandis que les autres valeurs ont été remplacées par 0 :

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

### Utiliser `np.where()` avec une seule condition

Si `numpy.where()` est utilisé avec seulement une condition et sans donner de valeurs de remplacement, il renvoie un **tuple d’indices** où la condition est `True`.

```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]),)
```

Dans cet exemple, `arr` est un tableau NumPy contenant des valeurs de 1 à 5. `condition = arr > 2` crée un **masque booléen** qui identifie les éléments de `arr` qui sont plus grands que 2. `np.where(condition)` est appelé sans spécifier de valeurs de remplacement. Cela renvoie un tuple d’indices pour lesquels la condition `arr > 2` est remplie. Le résultat sera un tableau d’indices où les éléments de `arr` sont supérieurs à 2.

### Diffusion avec `np.where()`

La diffusion dans NumPy permet des opérations entre des tableaux de formes différentes, tant que certaines règles sont respectées. Si des tableaux ont des formes différentes, NumPy essaie de les agrandir de manière à les rendre compatibles.

Supposons que nous ayons un tableau NumPy `arr` de la forme (3, 3) :

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

Et que nous ayons un autre tableau NumPy `row` de la forme (3,) :

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

On constate que la forme de `arr` **(3, 3)** et la forme de `row` **(3,)** sont différentes. Bien qu’elles ne correspondent pas exactement, la diffusion peut être utilisée pour effectuer une opération entre ces tableaux.

Nous voulons maintenant additionner les valeurs de chaque ligne de `arr` avec les valeurs de `row`. C’est là que la diffusion entre en jeu :

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

La matrice unidimensionnelle `row` a été agrandie en une matrice (3, 3) pour correspondre à la forme de `arr` en la répétant sur les lignes. Ensuite, les éléments de `arr` et `row` ont été additionnés élément par élément.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-npwhere/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-npwhere/) for AI/LLM consumption.