Metodo np.where in Python

Con la funzione np.where() è possibile lavorare con gli array NumPy in Python in modo mirato. Grazie alle ope­ra­zio­ni vet­to­ria­li, è anche più ef­fi­cien­te rispetto ai metodi basati sui cicli.

A cosa serve np.where in Python?

La funzione np.where() in Python è un ef­fi­cien­te metodo della libreria NumPy, utile per la selezione con­di­zio­na­le di elementi di un array. Iden­ti­fi­ca ed estrae gli elementi che sod­di­sfa­no una de­ter­mi­na­ta con­di­zio­ne e re­sti­tui­sce gli indici o i valori che cor­ri­spon­do­no a questa con­di­zio­ne.

La funzione np.where() è uti­liz­za­ta in molti ambiti, tra cui l’ela­bo­ra­zio­ne dei dati, i calcoli scien­ti­fi­ci, l’ap­pren­di­men­to au­to­ma­ti­co e l’analisi dei dati. Nella ma­ni­po­la­zio­ne dei dati, np.where() permette il fil­trag­gio dei dati in base a de­ter­mi­na­ti criteri e la so­sti­tu­zio­ne 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 con­di­zio­ne che viene applicata sull’array per de­ter­mi­na­re gli elementi da se­le­zio­na­re.
• x e y (opzionali): se indichi soltanto condition, np.where() re­sti­tui­sce gli indici degli elementi che sod­di­sfa­no la con­di­zio­ne. Spe­ci­fi­can­do x e y, invece, vengono re­sti­tui­ti i valori di x che sod­di­sfa­no la con­di­zio­ne e i valori di y in caso contrario.

Una volta ri­chia­ma­ta, la funzione np.where() re­sti­tui­sce come risultato un nuovo array NumPy. Questo nuovo array è generato dal fil­trag­gio o dalla selezione di elementi dell’array ori­gi­na­rio, sulla base di una con­di­zio­ne. In questo caso, ciascun valore True o False in questo array con­di­zio­na­le cor­ri­spon­de alla selezione o al fil­trag­gio dell’elemento cor­ri­spon­den­te nell’array ori­gi­na­rio.

Esempi di utilizzo di np.where()

Grazie alla sua capacità di eseguire ope­ra­zio­ni con­di­zio­na­li sugli array, il metodo np.where() è uno strumento estre­ma­men­te versatile ed è par­ti­co­lar­men­te indicato per la ma­ni­po­la­zio­ne dei dati.

So­sti­tu­zio­ne di elementi in un array NumPy

La funzione np.where() in NumPy consente di so­sti­tui­re gli elementi in un array sulla base di una con­di­zio­ne. In questo caso puoi tra­sfor­ma­re 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 con­di­zio­ne per iden­ti­fi­ca­re gli elementi maggiori di 3. A tal fine viene creata una maschera per la con­di­zio­ne: per gli elementi che sono maggiori di 3 il valore è True, al­tri­men­ti è False:

condition = arr > 3

Suc­ces­si­va­men­te uti­liz­zia­mo np.where() e in­di­chia­mo questa con­di­zio­ne. Sta­bi­lia­mo quindi che i valori che cor­ri­spon­do­no alla con­di­zio­ne devono essere so­sti­tui­ti con -1, mentre tutti gli altri valori sono so­sti­tui­ti con 0:

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

Il risultato new_arr contiene l’array mo­di­fi­ca­to dopo la so­sti­tu­zio­ne ef­fet­tua­ta secondo la con­di­zio­ne. L’output mostra quindi che i valori maggiori di 3 sono stati so­sti­tui­ti con -1, mentre gli altri valori con 0:

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

Utilizzo di np.where() con una sola con­di­zio­ne

Se si utilizza numpy.where() con una sola con­di­zio­ne e senza indicare valori so­sti­tu­ti­vi, viene re­sti­tui­ta una tupla di indici per i quali la con­di­zio­ne è 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 iden­ti­fi­ca gli elementi in arr che sono maggiori di 2. np.where(condition) viene ri­chia­ma­ta senza indicare valori so­sti­tu­ti­vi. In questo modo viene re­sti­tui­ta una tupla di indici per i quali è sod­di­sfat­ta la con­di­zio­ne arr > 2. Il risultato sarà quindi un array di indici, dove gli elementi di arr sono maggiori di 2.

Broa­d­ca­sting con np.where()

Il broa­d­ca­sting in NumPy consente di eseguire ope­ra­zio­ni fra array di forme diverse, a con­di­zio­ne che siano sod­di­sfat­te de­ter­mi­na­te regole. Se gli array hanno forme diverse, NumPy tenta di in­gran­dir­li in modo da renderli com­pa­ti­bi­li.

Ipo­tiz­zia­mo 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 coin­ci­do­no esat­ta­men­te, è possibile uti­liz­za­re il broa­d­ca­sting per eseguire un’ope­ra­zio­ne 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 broa­d­ca­sting:

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

Un array row mo­no­di­men­sio­na­le è stato in­gran­di­to in una matrice (3, 3) per adattarlo alla forma di arr ri­pe­ten­do­ne le righe. Suc­ces­si­va­men­te, gli elementi di arr e row sono stati sommati elemento per elemento.