Iterare sulle Liste

Scorrere una lista — visitare ogni elemento uno per uno — è una delle operazioni più comuni in Python. Questo capitolo tratta tutti i modi pratici per farlo: cicli for, cicli while, enumerate(), zip(), break e continue, e le list comprehension. Spiega inoltre le insidie a cui prestare attenzione quando si modifica una lista durante l'iterazione.

Perché Iterare su una Lista?

Una lista Python contiene una sequenza ordinata di elementi. I cicli permettono di agire su ogni elemento senza scrivere una riga di codice per elemento. Che si stia sommando prezzi, filtrando record o trasformando stringhe, un ciclo è di solito lo strumento giusto.

Iterare con un Ciclo for

Il modo più semplice e leggibile per iterare su una lista è un ciclo for.

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

apple
banana
cherry

Python assegna ogni elemento a fruit a turno, esegue il blocco indentato, poi passa all'elemento successivo. Il ciclo si ferma automaticamente quando la lista è esaurita — non è necessaria alcuna gestione degli indici.

Iterare con range() e un Indice

Quando si ha bisogno sia dell'indice che del valore, è possibile combinare range() con len():

colors = ['red', 'green', 'blue']
for i in range(len(colors)):
    print(i, colors[i])

0 red
1 green
2 blue

Funziona, ma enumerate() (trattato di seguito) è più elegante per questo schema.

Iterare con enumerate()

enumerate() abbina ogni elemento al suo indice ed è l'approccio idiomatico in Python quando si ha bisogno di entrambi:

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

È possibile far partire il contatore da un numero diverso passando un secondo argomento:

for index, fruit in enumerate(['apple', 'banana', 'cherry'], start=1):
    print(index, fruit)

1 apple
2 banana
3 cherry

Iterare su Due Liste con zip()

zip() abbina gli elementi di due (o più) liste in modo da poterle iterare affiancate:

names  = ['Alice', 'Bob', 'Carol']
scores = [92, 85, 78]

for name, score in zip(names, scores):
    print(name, '->', score)

Alice -> 92
Bob -> 85
Carol -> 78

Se le liste hanno lunghezze diverse, zip() si ferma alla lista più corta. Utilizzare itertools.zip_longest() se si ha bisogno di continuare fino alla fine della lista più lunga.

Iterare con un Ciclo while

Un ciclo while continua a girare finché una condizione è True. L'indice viene gestito manualmente:

numbers = [10, 20, 30, 40, 50]
i = 0
while i < len(numbers):
    print(numbers[i])
    i += 1

10
20
30
40
50

I cicli while sono utili quando la condizione di arresto non è semplicemente "fine della lista" — ad esempio, quando si cerca un elemento e ci si ferma non appena viene trovato.

Controllare l'Esecuzione del Ciclo

break — Uscita Anticipata

break interrompe immediatamente il ciclo. È utile quando si è trovato ciò che si cercava e non è necessario continuare a iterare:

fruits = ['apple', 'banana', 'cherry', 'date']
for fruit in fruits:
    if fruit == 'cherry':
        print('Found it!')
        break
    print(fruit)

apple
banana
Found it!

continue — Saltare un Elemento

continue salta alla iterazione successiva senza eseguire le righe rimanenti del blocco corrente:

numbers = [1, 2, 3, 4, 5, 6]
for n in numbers:
    if n % 2 == 0:
        continue        # skip even numbers
    print(n)

1
3
5

La Clausola else su un Ciclo

Un ciclo for o while può avere un blocco else che viene eseguito quando il ciclo termina senza incontrare un break. Questo è utile per i pattern "cerca e riporta":

target = 7
numbers = [1, 3, 5, 9]

for n in numbers:
    if n == target:
        print('Found', target)
        break
else:
    print(target, 'not in list')

7 not in list

Iterare su uno Slice di Lista

È possibile iterare su una parte di una lista affettandola (slicing):

items = ['a', 'b', 'c', 'd', 'e']
for item in items[1:4]:   # indices 1, 2, 3
    print(item)

b
c
d

Iterare in ordine inverso con uno slice:

for item in items[::-1]:
    print(item)

e
d
c
b
a

Cicli Annidati

È possibile annidare cicli for per lavorare con liste di liste o per calcolare combinazioni:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

1 2 3 
4 5 6 
7 8 9 

Il ciclo interno completa tutte le sue iterazioni per ogni singola iterazione del ciclo esterno.

Le List Comprehension come Alternativa al Ciclo

Una list comprehension crea una nuova lista applicando un'espressione a ogni elemento — è un'alternativa compatta e leggibile a un ciclo for che costruisce una lista:

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

# for loop approach
squares = []
for n in numbers:
    squares.append(n ** 2)

# list comprehension — same result in one line
squares = [n ** 2 for n in numbers]

print(squares)

[1, 4, 9, 16, 25]

È possibile aggiungere una condizione per filtrare gli elementi allo stesso tempo:

evens = [n for n in range(1, 11) if n % 2 == 0]
print(evens)

[2, 4, 6, 8, 10]

Insidia Comune: Modificare una Lista Durante l'Iterazione

Non aggiungere o rimuovere elementi da una lista all'interno di un ciclo for che itera sulla stessa lista. L'indice interno del ciclo è basato sulla lunghezza originale, quindi gli elementi possono essere saltati o visitati due volte.

# BAD — skips items
numbers = [1, 2, 3, 4, 5]
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)   # mutates the list mid-loop
print(numbers)              # [1, 3, 5] may look correct here but...

Il pattern sicuro è iterare su una copia della lista, oppure costruire una nuova lista con una comprehension:

numbers = [1, 2, 3, 4, 5]
numbers = [n for n in numbers if n % 2 != 0]
print(numbers)

[1, 3, 5]

Operazioni di Base sulle Liste Usate con i Cicli

Le sezioni seguenti riepilogano i metodi delle liste più spesso usati insieme ai cicli. Vedere Python List Methods per il riferimento completo.

Aggiungere Elementi

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

[1, 2, 3, 4]

Rimuovere Elementi

remove() elimina il primo valore corrispondente e solleva un ValueError se l'elemento non viene trovato.

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)

[1, 2, 4, 5]

Ordinare una Lista

my_list = [3, 1, 4, 2, 5]
my_list.sort()
print(my_list)

[1, 2, 3, 4, 5]

sort() modifica la lista in-place. Per ottenere una copia ordinata senza modificare l'originale, usare la funzione built-in sorted(). Vedere Sort Lists per ordinare in ordine inverso, ordinare per chiave e altro ancora.

Argomenti Correlati

• Python Lists — creazione, indicizzazione e slicing delle liste
• Python for Loops — il riferimento completo al ciclo for
• Python while Loops — sintassi e pattern del ciclo while
• List Comprehension — costruzione compatta di liste su una sola riga
• List Methods — append, extend, pop, insert e altro
• Sort Lists — ordinamento in-place vs. copie ordinate
• Remove List Items — remove, pop, del e clear
• Loop Dictionaries — iterare su coppie chiave-valore
• Loop Tuples — iterare su sequenze immutabili

Pratica