Cos'è l'iterazione?

Un programma che invia un'email di promemoria a 10.000 utenti non contiene 10.000 copie del codice di invio. Contiene il codice una volta sola, dentro un ciclo, e il ciclo lo esegue una volta per utente. Ogni esecuzione è un'iterazione, e il ciclo nel suo insieme è il modo in cui il programma itera sui suoi utenti.

Come funziona l'iterazione, passo per passo

Ogni ciclo segue lo stesso schema:

1. Controlla. Verifica la condizione del ciclo, che è un booleano: c'è un altro elemento, o il contatore è ancora sotto il limite?
2. Esegui. Se la risposta è vero, esegui il corpo del ciclo una volta.
3. Aggiorna. Passa all'elemento successivo o cambia il contatore.
4. Ripeti. Torna al passo 1. Quando il controllo dà falso, il programma continua con il codice dopo il ciclo.

Qui il corpo viene eseguito cinque volte, e ogni iterazione aggiunge il numero successivo a un totale parziale:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

La variabile total vive fuori dal ciclo, quindi mantiene il suo valore da un'iterazione all'altra. Questo schema, una variabile impostata prima del ciclo e aggiornata al suo interno, si chiama accumulatore, e compare in quasi ogni ciclo che calcola qualcosa.

Cicli a conteggio e cicli a condizione

Esistono due tipi di iterazione. L'iterazione definita viene eseguita un numero noto di volte: una volta per ogni elemento di una lista, o una volta per ogni numero da 1 a 5. Il ciclo for di Python è fatto per questo, spesso insieme a range().

L'iterazione indefinita si ripete finché non succede qualcosa, e il numero di passaggi non è noto in anticipo. Un ciclo while è adatto a questo caso:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Il denaro che cresce del 10% all'anno impiega 8 anni a raddoppiare. Il programma l'ha scoperto iterando, non risolvendo un'equazione. Le guide ai cicli for e ai cicli while trattano entrambi in Python.

Iterare su una collezione

La maggior parte dei cicli scorre una collezione: gli elementi di un array, i caratteri di una stringa, le righe di un file. Il ciclo for di Python ti consegna direttamente ogni elemento, ed enumerate() aggiunge la sua posizione:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Dietro le quinte, for chiede alla collezione un iteratore con iter(), poi chiama next() su di esso una volta per iterazione. Puoi fare le stesse chiamate a mano:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Senza il valore predefinito, il quarto next() solleva StopIteration. Quell'eccezione è il segnale che un ciclo for usa per sapere che la collezione è finita.

Altri linguaggi scrivono la stessa idea in modo diverso. C conta con un indice, mentre Java e JavaScript hanno anche un ciclo che ti consegna ogni elemento:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iterazione e ricorsione

La ricorsione è l'altro modo per ripetere un lavoro: una funzione chiama se stessa su una versione più piccola del problema finché non arriva a un caso a cui può rispondere direttamente. Tutto ciò che si scrive con l'una si può scrivere con l'altra, ma si comportano in modo diverso:

La riga sulla memoria conta nella pratica. Python permette per impostazione predefinita circa 1.000 chiamate annidate, quindi una somma ricorsiva di 5.000 numeri fallisce dove un ciclo non ha problemi:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

La visualizzazione della ricorsione mostra lo stack delle chiamate che cresce e si riduce passo dopo passo.

Errori comuni

Il ciclo infinito. Un ciclo while la cui condizione non diventa mai falsa gira finché non fermi il programma. La causa più comune è dimenticare il passo di aggiornamento, per esempio omettere count = count - 1.

Sbagliare di uno. range(1, 5) dà 1, 2, 3 e 4, non 5, perché il valore finale è escluso. Un ciclo che gira una volta di troppo o di meno funziona comunque senza errori e dà una risposta sbagliata, cioè un errore logico.

Modificare una lista mentre la scorri. Rimuovere elementi dalla lista su cui stai iterando fa saltare degli elementi al ciclo:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Un 2 è sopravvissuto, perché rimuovere il primo 2 ha spostato il secondo in una posizione che il ciclo aveva già superato. Costruisci invece una nuova lista: numbers = [n for n in numbers if n != 2].

Cosa leggere dopo

I cicli scorrono le collezioni, quindi cos'è un array è la pagina che le fa naturalmente da compagna, e cos'è un booleano spiega i controlli vero o falso che decidono quando un ciclo si ferma. Quando un ciclo dà un risultato sbagliato senza messaggi di errore, leggi cos'è un errore logico. Per esercitarti a scrivere cicli, inizia il corso Python o prova gli esempi qui sopra nel playground Python.