# La funzione Python filter(): come filtrare iterabili in base a una condizione

Con la funzione `filter()` di Python è possibile filtrare un iterabile in base a una condizione specifica, creando così un nuovo iteratore composto solo dai valori che soddisfano tale condizione. Questa funzione può essere utilizzata anche con le stringhe o per eliminare i valori nulli.

## Cos’è Python `filter()`?

La funzione `filter()` di Python permette di applicare una **condizione a un iterabile** e selezionare solo gli elementi che la soddisfano. Questi vengono poi riproposti come [iteratore](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/iteratori-python/). La condizione è considerata soddisfatta se l’elemento non è “0” o “false”. Sebbene esistano altre opzioni per filtrare una lista o un dizionario, la funzione `filter()` di Python può essere utilizzata in modo particolarmente efficiente. Essa crea solo un oggetto che fa riferimento all’iterabile di partenza, fornendo la funzione specificata e un indice. Di conseguenza, risulta occupare molto meno spazio rispetto ad altre opzioni.

## Sintassi e parametri

La sintassi di Python `filter()` si scrive così:

```python
filter(function, iterable)
```

Python `filter()` presenta quindi due parametri:

- `function`: questo argomento specifica una funzione che viene applicata a ogni elemento dell’iterabile e restituisce un valore booleano (“true” o “false”).
- `iterable`: questo parametro specifica la sequenza che deve essere filtrata dalla funzione Python `filter()`. Può trattarsi di una lista specifica, di un set, un altro iterabile o una [tupla di Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tuple-in-python/).

La funzione verifica ogni elemento dell’iterabile per la condizione specificata. Se la condizione è “vera”, l’elemento viene incluso nella nuova sequenza. Se l’elemento non soddisfa questa condizione, viene escluso. Nei prossimi paragrafi ti mostriamo come funziona questo processo con alcuni esempi pratici.

## Esempio di Python `filter()`

Nel nostro primo esempio, utilizziamo una serie di numeri e vogliamo considerare solo i valori superiori a 10. A questo scopo usiamo Python `filter()`. Il relativo codice si presenta così:

```python
valori = [3, 7, 9, 11, 17, 24, 25, 38, 40, 42]
def funzione(x):
    return x > 10
numeri = filter(funzione, valori)
numeri_lista = list(numeri)
print(numeri_lista)
```

Come output otteniamo questa nuova lista:

```python
[11, 17, 24, 25, 38, 40, 42]
```

## La funzione Python `filter()` con stringhe

Ovviamente `filter()` funziona anche con le [stringhe in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringhe-in-python/). Nel seguente esempio istruiamo il sistema a tenere in considerazione solo le vocali. Questo il relativo codice:

```python
valori = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
def filtrare_vocale(letter):
    vocale = ['a', 'e', 'i', 'o', 'u']
    if letter in vocale:
        return True
    else:
        return False
vocale_filtrata = filter(filtrare_vocale, valori)
vocale = tupla(vocale_filtrata)
print(vocale)
```

Abbiamo trasformato l’output in una tupla. La sintassi è la seguente:

```python
('a', 'e', 'i')
```

## Combinazione con lambda

È possibile combinare la funzione Python `filter()` con una [funzione lambda](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/funzioni-lambda-in-python/). Si tratta di una **funzione anonima** utilizzata principalmente a livello locale. Nel nostro esempio, selezioniamo una sequenza di numeri e istruiamo il sistema a considerare solo i numeri pari. Il codice è il seguente:

```python
numeri = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nuovo_iteratore = filter(lambda x: (x % 2 == 0), numeri)
numeri_pari = list(nuovo_iteratore)
print(numeri_pari)
```

Otteniamo il seguente output:

```python
[2, 4, 6, 8, 10]
```

## La funzione `filter()` con `None`

Dichiarando `None` come primo argomento di `filter()` di Python, il sistema viene istruito a filtrare solo i valori “falsy”. Il termine “falsy” si usa per descrivere valori che non sono veri o falsi secondo il principio booleano, ma che invece presentano **un valore nullo**. In linea di principio, sono quindi vuoti. Per il nostro esempio, selezioniamo un elenco di valori diversi. Si tratta di valori interi, vuoti o booleani. Quindi usiamo `filter()` di Python con `None` ed eliminiamo i valori che non soddisfano la nostra condizione. Il relativo codice è questo:

```python
valori = [1, 2, 3, 'x', 0, 4, True, False, 5]
nuovo_iteratore = filter(None, valori)
nuovi_valori = list(nuovo_iteratore)
print(nuovo_valore)
```

L’output è il seguente:

```python
[1, 2, 3, 'x', 4, True, 5]
```

## Eliminare stringhe vuote con Python `filter()`

Anche se desideri eliminare stringhe vuote, ti basterà usare Python `filter()`. Il relativo comando presenta questa sintassi:

```python
frase = ['Questo', ' ', 'è', 'un', ' ', 'esempio', ' ']
frase = list(filter(None, frase))
print(frase)
```

Le stringhe vuote vengono eliminate dall’output, lasciando solo quelle con un valore. Il risultato appare quindi come segue:

```python
['Questo', ' ', 'è', 'un', ' ', 'esempio', ' ']
```

Consiglio Riconoscimento automatico del framework, staging semplificato e numerose funzioni: con [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS") di IONOS non hai a disposizione solo un’infrastruttura affidabile ma effettui il deployment della tua pagina web anche direttamente da GitHub. Seleziona la tariffa più adatta alle tue esigenze.


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