Metodo np.where in Python

Con la funzione np.where() è possibile lavorare con gli array NumPy in Python in modo mirato. Grazie alle operazioni vettoriali, è anche più efficiente rispetto ai metodi basati sui cicli.

A cosa serve np.where in Python?

La funzione np.where() in Python è un efficiente metodo della libreria NumPy, utile per la selezione condizionale di elementi di un array. Identifica ed estrae gli elementi che soddisfano una determinata condizione e restituisce gli indici o i valori che corrispondono a questa condizione.

La funzione np.where() è utilizzata in molti ambiti, tra cui l’elaborazione dei dati, i calcoli scientifici, l’apprendimento automatico e l’analisi dei dati. Nella manipolazione dei dati, np.where() permette il filtraggio dei dati in base a determinati criteri e la sostituzione di valori negli array.

La sintassi di np.where() in Python

La funzione np.where() accetta un array di tipo NumPy, composto ad esempio da valori interi o booleani. In concreto, la sintassi della funzione np.where() in Python si presenta così:

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

• condition: questa è la condizione che viene applicata sull’array per determinare gli elementi da selezionare.
• x e y (opzionali): se indichi soltanto condition, np.where() restituisce gli indici degli elementi che soddisfano la condizione. Specificando x e y, invece, vengono restituiti i valori di x che soddisfano la condizione e i valori di y in caso contrario.

Una volta richiamata, la funzione np.where() restituisce come risultato un nuovo array NumPy. Questo nuovo array è generato dal filtraggio o dalla selezione di elementi dell’array originario, sulla base di una condizione. In questo caso, ciascun valore True o False in questo array condizionale corrisponde alla selezione o al filtraggio dell’elemento corrispondente nell’array originario.

Esempi di utilizzo di np.where()

Grazie alla sua capacità di eseguire operazioni condizionali sugli array, il metodo np.where() è uno strumento estremamente versatile ed è particolarmente indicato per la manipolazione dei dati.

Sostituzione di elementi in un array NumPy

La funzione np.where() in NumPy consente di sostituire gli elementi in un array sulla base di una condizione. In questo caso puoi trasformare le liste in Python in un array con np.array():

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

Ora definiamo una condizione per identificare gli elementi maggiori di 3. A tal fine viene creata una maschera per la condizione: per gli elementi che sono maggiori di 3 il valore è True, altrimenti è False:

condition = arr > 3

Successivamente utilizziamo np.where() e indichiamo questa condizione. Stabiliamo quindi che i valori che corrispondono alla condizione devono essere sostituiti con -1, mentre tutti gli altri valori sono sostituiti con 0:

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

Il risultato new_arr contiene l’array modificato dopo la sostituzione effettuata secondo la condizione. L’output mostra quindi che i valori maggiori di 3 sono stati sostituiti con -1, mentre gli altri valori con 0:

print(new_arr)

Utilizzo di np.where() con una sola condizione

Se si utilizza numpy.where() con una sola condizione e senza indicare valori sostitutivi, viene restituita una tupla di indici per i quali la condizione è 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]),)

In questo esempio, arr è un array NumPy che contiene i valori da 1 a 5. condition = arr > 2 crea una maschera booleana che identifica gli elementi in arr che sono maggiori di 2. np.where(condition) viene richiamata senza indicare valori sostitutivi. In questo modo viene restituita una tupla di indici per i quali è soddisfatta la condizione arr > 2. Il risultato sarà quindi un array di indici, dove gli elementi di arr sono maggiori di 2.

Broadcasting con np.where()

Il broadcasting in NumPy consente di eseguire operazioni fra array di forme diverse, a condizione che siano soddisfatte determinate regole. Se gli array hanno forme diverse, NumPy tenta di ingrandirli in modo da renderli compatibili.

Ipotizziamo di avere un array NumPy arr nella forma (3, 3):

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

Inoltre, abbiamo un ulteriore array NumPy row nella forma (3,):

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

Qui, arr è nella forma (3, 3), mentre la forma di row è (3,). Anche se le forme non coincidono esattamente, è possibile utilizzare il broadcasting per eseguire un’operazione fra questi array.

A questo punto vogliamo sommare i valori di ciascuna riga di arr con i valori in row. Qui entra in gioco il broadcasting:

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

Un array row monodimensionale è stato ingrandito in una matrice (3, 3) per adattarlo alla forma di arr ripetendone le righe. Successivamente, gli elementi di arr e row sono stati sommati elemento per elemento.