List comprehension in Python: sintassi, filtri e dict comprehension

Una riga, un'idea

Hai già scritto questo schema diverse volte: parti da una lista vuota, scorri qualcosa con un ciclo, magari filtri, e aggiungi al risultato.

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

Una list comprehension dice la stessa cosa in una riga:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

Leggila da sinistra a destra: "una nuova lista fatta di n * 2, per ogni n in numbers." La struttura è [expression for item in iterable].

Non è un trucco esclusivo di Python: si chiama comprehension perché descrivi in modo dichiarativo cosa entra nella nuova lista, invece di scrivere i passaggi meccanici per costruirla.

Aggiungere un filtro

Metti una clausola if dopo la parte del ciclo per filtrare:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = [n for n in numbers if n % 2 == 0]
print(evens)

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

Leggi la seconda così: "n * n per ogni n in numbers, ma solo se n è dispari."

Il ciclo equivalente:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

Vanno bene entrambi. La comprehension è più corta e, dopo averne lette un po', diventa anche più facile da scorrere con gli occhi, perché l'intenzione è tutta lì in una riga.

Trasformare e filtrare insieme

Puoi far passare i valori attraverso una funzione e filtrare allo stesso tempo:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

Per ogni parola più lunga di 3 lettere, includi la sua versione in maiuscolo.

Cicli annidati in una comprehension

Due for producono coppie in stile prodotto cartesiano:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

L'ordine è lo stesso che avresti annidando i cicli: il primo for è quello esterno, il secondo quello interno. Si legge da sinistra a destra come il ciclo indentato equivalente.

Due livelli sono più o meno il limite oltre il quale un ciclo normale si legge meglio. Se arrivi a tre, torna ai cicli.

Dict e set comprehension

Stessa idea, parentesi diverse:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension: produce un dict
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension: produce un set
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

A prima vista le set comprehension sembrano identiche alle dict comprehension: la differenza è key: value contro una singola espressione. Graffe più : = dict; graffe senza : = set.

Espressioni generatore

Quasi gemelle delle list comprehension, ma con le parentesi tonde invece delle quadre e, soprattutto, non costruiscono una lista:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

Nota che abbiamo passato il generatore direttamente a sum() e any(), senza parentesi in più. Le espressioni generatore sono lo strumento giusto quando chi le riceve deve scorrere i valori una volta sola. Con collezioni grandi occupano molta meno memoria di una lista completa.

Quando usare invece un ciclo normale

Le comprehension sono seducenti. Tecnicamente puoi infilarci dentro parecchia roba. Non dovresti.

Scegli un ciclo semplice quando:

• La trasformazione richiede più di un passaggio. Se ti servono variabili intermedie, scrivila per esteso.
• C'è una gestione degli errori o una ramificazione complessa.
• Chi legge la riga deve fermarsi più di una volta per capirla.

La regola che applico: se riesco a leggere la comprehension tutta d'un fiato e capire cosa fa, resta. Se inciampo, la riscrivo come ciclo.

Alcune comprehension sembrano furbe ma fanno danni:

# Furba ma sfiancante:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# Più chiara come ciclo:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

Stesso risultato. La versione con il ciclo occupa cinque righe invece di una, ma "più lungo" non significa "peggiore".

Qualche schema che riutilizzerai

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# Prendi un attributo da ogni elemento.
names = [u["name"] for u in users]
print(names)

# Filtra e seleziona in un colpo solo.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# Costruisci un dict di ricerca indicizzato per campo.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# Conta quanti superano un test.
active_count = sum(1 for u in users if u["active"])
print(active_count)

Questi schemi coprono una quantità sorprendente del lavoro quotidiano con i dati.

Prossimo argomento

Ora hai visto i principali tipi di collezione e la comprehension che li tiene insieme. Prossimo capitolo: le funzioni, per impacchettare comportamenti in unità riutilizzabili e con un nome.