# 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ì:

```python
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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/liste-in-python/) in un array con `np.array()`:

```python
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`:

```python
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:

```python
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:

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

### 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`.

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

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

```python
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:

```python
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.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/metodo-npwhere-in-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/metodo-npwhere-in-python/) for AI/LLM consumption.