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 :

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() :

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.

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 :

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 :

print(new_arr)

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.

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) :

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

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 :

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.