11. Ripetere azioni con i cicli while

I programmi spesso devono ripetere azioni più volte. Hai già visto come prendere decisioni con le istruzioni if nel Capitolo 8, ma cosa succede se devi eseguire un’azione ripetutamente finché non viene soddisfatta una certa condizione? È qui che entrano in gioco i cicli(loop).

Python fornisce due tipi principali di cicli: i cicli while e i cicli for. In questo capitolo ci concentreremo sui cicli while, che ripetono un blocco di codice finché una condizione rimane vera. Il ciclo for, più adatto a iterare su sequenze, verrà trattato nel Capitolo 12.

Comprendere i cicli while è fondamentale per scrivere programmi che possono elaborare dati ripetutamente, validare l’input dell’utente, implementare cicli di gioco e gestire molti altri scenari reali di programmazione.

11.1) La struttura di un ciclo while

Un ciclo while (while loop) esegue ripetutamente un blocco di codice finché una condizione specificata viene valutata come True. Una volta che la condizione diventa False, il ciclo si ferma e il programma prosegue con il codice dopo il ciclo.

Sintassi di base di un ciclo while

La struttura di un ciclo while è la seguente:

while condition:
    # Blocco di codice da ripetere
    # Questo codice viene eseguito finché condition è True

La condition è un’espressione qualsiasi che viene valutata come valore booleano (o può essere interpretata come truthy o falsy, come abbiamo imparato nel Capitolo 7). Il blocco di codice indentato sotto l’istruzione while si chiama corpo del ciclo(loop body), ed esegue ripetutamente finché la condizione rimane True.

Vediamo un esempio semplice:

# Conta da 1 a 5
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count = count + 1  # Incrementa count
print("Loop finished!")

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Loop finished!

Come funziona passo dopo passo:

1. Inizializziamo count a 1
2. Viene verificata la condizione count <= 5. Poiché 1 <= 5 è True, il corpo del ciclo viene eseguito
3. All’interno del ciclo, stampiamo il conteggio corrente e poi lo incrementiamo di 1
4. Dopo che il corpo del ciclo è completato, Python torna all’istruzione while e controlla di nuovo la condizione
5. Questo processo si ripete finché count diventa 6, punto in cui 6 <= 5 è False e il ciclo termina
6. Il programma prosegue con il codice dopo il ciclo

L’intuizione chiave è che la condizione viene controllata prima di ogni iterazione (ogni ripetizione del corpo del ciclo). Se la condizione è inizialmente False, il corpo del ciclo non viene mai eseguito:

count = 10
while count <= 5:
    print("This will never print")
print("Loop skipped entirely")

Output:

Loop skipped entirely

Poiché 10 <= 5 è False fin dall’inizio, il corpo del ciclo non viene mai eseguito.

L’importanza di modificare la variabile del ciclo

Affinché un ciclo while si fermi prima o poi, qualcosa all’interno del ciclo deve cambiare la condizione da True a False. Questo di solito significa modificare la/le variabile/i usata/e nella condizione. Se ti dimentichi di farlo, crei un ciclo infinito(infinite loop) (che discuteremo in dettaglio nella prossima sezione).

Ecco un esempio che dimostra perché aggiornare la variabile del ciclo è importante:

# Calcola la somma dei numeri da 1 a 10
total = 0
number = 1
 
while number <= 10:
    total = total + number  # Aggiunge il numero corrente a total
    number = number + 1     # Passa al numero successivo
 
print(f"The sum of numbers from 1 to 10 is: {total}")

Output:

The sum of numbers from 1 to 10 is: 55

In questo esempio, stiamo accumulando una somma mentre procediamo attraverso i numeri. Sia total sia number cambiano a ogni iterazione, ma è la modifica di number che assicura che il ciclo alla fine termini quando number diventa 11.

Cicli while con input dell’utente

Un uso pratico dei cicli while è elaborare l’input dell’utente finché non viene soddisfatta una condizione specifica. Creiamo un semplice gioco di indovinare il numero:

# Semplice gioco di indovinare il numero
secret_number = 7
guess = 0
 
while guess != secret_number:
    guess = int(input("Guess the number (1-10): "))
    
    if guess < secret_number:
        print("Too low! Try again.")
    elif guess > secret_number:
        print("Too high! Try again.")
    else:
        print("Correct! You guessed it!")

Questo ciclo continua a chiedere tentativi finché l’utente non inserisce il numero corretto. Ogni iterazione elabora un tentativo e fornisce feedback. Il ciclo termina naturalmente quando guess è uguale a secret_number, facendo diventare False la condizione guess != secret_number.

Cicli while con condizioni multiple

Puoi usare gli operatori booleani (and, or, not) per creare condizioni di ciclo più complesse, come abbiamo imparato nel Capitolo 9:

# Elabora l'input finché l'utente non inserisce "quit" o raggiunge 5 tentativi
attempts = 0
user_input = ""
 
while user_input != "quit" and attempts < 5:
    user_input = input("Enter a command (or 'quit' to exit): ")
    attempts += 1
    
    if user_input == "quit":
        print("Goodbye!")
    else:
        print(f"You entered: {user_input}")
        print(f"Attempts remaining: {5 - attempts}")
 
if attempts >= 5 and user_input != "quit":
    print("Maximum attempts reached.")

Questo ciclo continua finché entrambe le condizioni sono vere: l’utente non ha inserito "quit" e non ha superato 5 tentativi. Il ciclo termina quando una delle due condizioni diventa falsa.

Visualizzare l’esecuzione di un ciclo while

Ecco un diagramma di flusso che mostra come viene eseguito un ciclo while:

Il ciclo crea un ciclo in cui la condizione viene controllata, il corpo viene eseguito se la condizione è vera, le variabili vengono aggiornate e poi la condizione viene controllata di nuovo. Questo ciclo continua finché la condizione non diventa falsa.

11.2) Cicli infiniti e come evitarli

Un ciclo infinito(infinite loop) è un ciclo che non termina mai perché la sua condizione non diventa mai False. I cicli infiniti sono uno degli errori più comuni che i principianti commettono con i cicli while, e possono far sì che il programma rimanga bloccato indefinitamente.

Cosa causa i cicli infiniti?

La causa più comune dei cicli infiniti è dimenticare di modificare la/le variabile/i che influenzano la condizione del ciclo. Vediamo un esempio problematico:

# ATTENZIONE: Ciclo infinito - solo a scopo dimostrativo
# PROBLEMA: count non viene mai modificato
count = 1
while count <= 5:
    print(f"Count is: {count}")
    # Missing: count += 1

Se eseguissi questo codice, stamperebbe "Count is: 1" per sempre perché count rimane 1 e 1 <= 5 è sempre True. La condizione non cambia mai.

Come riconoscere che si tratta di un ciclo infinito: guarda la condizione del ciclo (count <= 5) e poi controlla se qualcosa all’interno del corpo del ciclo modifica count. In caso contrario, e se la condizione parte come True, hai un ciclo infinito.

Ecco la versione corretta:

# Versione corretta con incremento adeguato
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Questo garantisce che il ciclo prima o poi termini

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5

Fare debugging dei cicli infiniti con limiti di sicurezza

Quando sviluppi codice con cicli, è utile aggiungere un limite di sicurezza per evitare cicli infiniti accidentali durante i test:

# Limite di sicurezza durante lo sviluppo
count = 1
iterations = 0
max_iterations = 100  # Limite di sicurezza
 
while count <= 5 and iterations < max_iterations:
    print(f"Count is: {count}")
    count += 1
    iterations += 1
 
if iterations >= max_iterations:
    print("WARNING: Maximum iterations reached. Check for infinite loop.")

Questo schema aggiunge un contatore che traccia quante volte il ciclo è stato eseguito. Se raggiunge il limite di sicurezza, sai che qualcosa non va nella logica del ciclo. Una volta che sei sicuro che il ciclo funzioni correttamente, puoi rimuovere il limite di sicurezza.

Cicli infiniti con input dell’utente

Un altro scenario comune per i cicli infiniti riguarda la validazione dell’input dell’utente:

# ATTENZIONE: Potenziale ciclo infinito - solo a scopo dimostrativo
# PROBLEMA: Se l'utente non inserisce mai un input valido, il ciclo non finisce mai
age = -1
while age < 0:
    age = int(input("Enter your age: "))
    # Se l'utente inserisce un numero negativo, il ciclo continua

Questo ciclo funziona correttamente se l’utente alla fine inserisce un numero non negativo, ma diventa un ciclo infinito se l’utente continua a inserire valori negativi. Anche se questo potrebbe essere accettabile per alcuni programmi (vuoi continuare a chiedere finché non ricevi un input valido), è importante capire che la terminazione del ciclo dipende interamente dal comportamento dell’utente.

Un approccio più robusto potrebbe includere un modo per uscire:

# Approccio migliore con opzione di uscita
age = -1
while age < 0:
    user_input = input("Enter your age (or 'quit' to exit): ")
    
    if user_input.lower() == 'quit':
        print("Exiting program.")
        age = 0  # Imposta un valore valido per uscire dal ciclo
    else:
        age = int(user_input)
        if age < 0:
            print("Age must be non-negative. Please try again.")
 
if age > 0:
    print(f"Your age is: {age}")

Cicli infiniti con errori logici

A volte i cicli infiniti si verificano a causa di errori logici in come aggiorni le variabili:

# ATTENZIONE: Ciclo infinito - solo a scopo dimostrativo
# PROBLEMA: count viene decrementato invece di essere incrementato
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count -= 1  # ERRORE: Questo rende count più piccolo, non più grande

Questo crea un ciclo infinito perché count inizia a 1 e diventa 0, -1, -2, ecc. Poiché i numeri negativi sono sempre minori o uguali a 5, la condizione count <= 5 rimane True per sempre.

La versione corretta:

count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Corretto: incrementa per superare 5 prima o poi

Fare debugging dei cicli infiniti

Se crei accidentalmente un ciclo infinito mentre esegui uno script Python, puoi interromperlo premendo Ctrl+C (o Cmd+C su Mac) nel terminale. Questo invia a Python un segnale di interruzione da tastiera, che ferma il programma.

Come evitare i cicli infiniti:

1. Assicurati sempre che la condizione del ciclo possa diventare False: verifica che le variabili nella condizione vengano modificate all’interno del ciclo
2. Usa l’operatore di confronto corretto: assicurati che <=, <, !=, ecc. corrispondano alla tua intenzione
3. Testa prima con valori piccoli: prima di eseguire un ciclo che potrebbe iterare molte volte, testa con limiti piccoli
4. Aggiungi istruzioni di stampa per il debug: stampa temporaneamente la variabile del ciclo per vedere come cambia:
5. Usa limiti di sicurezza durante lo sviluppo: come mostrato prima, aggiungi un contatore massimo di iterazioni durante i test

11.3) Usare break e continue nei cicli while

Python fornisce due istruzioni speciali che ti danno più controllo sull’esecuzione dei cicli: break e continue. Queste istruzioni ti permettono di alterare il flusso normale di un ciclo in base a condizioni che emergono durante l’esecuzione.

11.3.1) L’istruzione break

L’istruzione break termina immediatamente il ciclo, indipendentemente dalla condizione del ciclo. Quando Python incontra break, esce completamente dal ciclo e prosegue con il codice dopo il ciclo.

Ecco un esempio semplice:

# Esce dal ciclo quando viene raggiunto un valore specifico
count = 1
while count <= 10:
    if count == 5:
        print("Reached 5, stopping loop")
        break
    print(f"Count: {count}")
    count += 1
 
print("Loop exited")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Reached 5, stopping loop
Loop exited

Nota che una volta che count è uguale a 5, viene eseguita l’istruzione break e il ciclo termina immediatamente. Il ciclo non raggiunge mai count = 6 anche se la condizione count <= 10 sarebbe ancora True.

Come break cambia il flusso del ciclo

È cruciale capire come break altera l’esecuzione normale del ciclo. Ecco un diagramma di flusso che mostra la differenza:

Il punto chiave: break fornisce un percorso di uscita immediato dal ciclo, bypassando sia il codice rimanente del corpo del ciclo sia il controllo della condizione.

Uso pratico di break: validazione dell’input

Uno degli usi più comuni di break è uscire da un ciclo quando viene ricevuto un input valido:

# Continua a chiedere un input valido finché non viene ricevuto
while True:
    age_input = input("Enter your age (must be positive): ")
    
    # Prova a convertire in intero
    try:
        age = int(age_input)
        
        # Controlla se è valido
        if age > 0:
            print(f"Thank you! Your age is {age}")
            break  # Esce dal ciclo quando l'input è valido
        else:
            print("Age must be positive. Please try again.")
    except ValueError:
        print("That's not a valid number. Please try again.")
 
print("Input validation complete")

Questo schema usa while True: per creare un ciclo infinito intenzionale, poi usa break per uscire quando viene ricevuto un input valido. Questo è più pulito che cercare di gestire una condizione di ciclo complessa. (Nota: qui stiamo usando try ed except, che impareremo in dettaglio nella Parte VII. Per ora, capisci solo che cattura gli errori quando si converte l’input in un intero.)

break con condizioni multiple

Puoi usare break con condizioni complesse per uscire da un ciclo quando viene soddisfatto uno qualsiasi di diversi criteri:

# Cerca un elemento specifico nell'input dell'utente
search_term = "python"
attempts = 0
max_attempts = 5
 
while attempts < max_attempts:
    user_input = input("Enter a word (or 'quit' to exit): ").lower()
    attempts += 1
    
    if user_input == 'quit':
        print("User requested exit")
        break
    
    if user_input == search_term:
        print(f"Found '{search_term}'!")
        break
    
    print(f"'{user_input}' is not '{search_term}'. Try again.")
    print(f"Attempts remaining: {max_attempts - attempts}")
 
if attempts >= max_attempts:
    print("Maximum attempts reached")

Questo ciclo può uscire in tre modi:

1. L’utente inserisce "quit" (primo break)
2. L’utente inserisce il termine di ricerca (secondo break)
3. Raggiunto il numero massimo di tentativi (la condizione del ciclo diventa False)

11.3.2) L’istruzione continue

L’istruzione continue salta il resto dell’iterazione corrente e torna al controllo della condizione del ciclo. A differenza di break, che esce completamente dal ciclo, continue salta semplicemente alla prossima iterazione.

Ecco un esempio di base:

# Stampa solo i numeri dispari da 1 a 10
count = 0
while count < 10:
    count += 1
    
    if count % 2 == 0:  # Se è un numero pari
        continue  # Salta il resto e passa alla prossima iterazione
    
    print(f"Odd number: {count}")

Output:

Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9

Come funziona:

1. count viene incrementato all’inizio di ogni iterazione
2. Se count è pari (count % 2 == 0), viene eseguito continue
3. L’istruzione continue salta l’istruzione print e torna alla condizione del while
4. Se count è dispari, continue non viene eseguito, quindi viene eseguita l’istruzione print

Come continue cambia il flusso del ciclo

Ecco un diagramma di flusso che mostra come continue influisce sull’esecuzione del ciclo:

La differenza cruciale tra break e continue:

• break: esce completamente dal ciclo, saltando al codice dopo il ciclo
• continue: salta il codice rimanente nell’iterazione corrente, tornando al controllo della condizione

Nota importante sulla posizione di continue

Nota che count += 1 viene prima del continue. Se lo mettessimo dopo, i numeri pari farebbero sì che continue salti l’incremento, creando un ciclo infinito:

# ATTENZIONE: Ciclo infinito - solo a scopo dimostrativo
# PROBLEMA: continue salta l'incremento per i numeri pari
count = 0
while count < 10:
    if count % 2 == 0:
        continue  # Salta tutto ciò che segue, incluso count += 1
    count += 1  # ERRORE: Questo non viene mai eseguito per i numeri pari
    print(f"Odd number: {count}")

Quando count è 0 (pari), viene eseguito continue, saltando count += 1. Il ciclo controlla di nuovo 0 < 10, e il ciclo si ripete per sempre.

La regola: assicurati sempre che le variabili del ciclo che influenzano la condizione vengano aggiornate prima di qualsiasi istruzione continue che potrebbe saltare il resto del corpo del ciclo.

Uso pratico di continue: filtrare i dati

L’istruzione continue è utile quando elabori dati e vuoi saltare determinati elementi:

# Elabora solo i punteggi validi
score_count = 0
total_score = 0
attempts = 0
 
while attempts < 5:
    score_input = input(f"Enter score {attempts + 1} (or 'skip' to skip): ")
    attempts += 1
    
    if score_input.lower() == 'skip':
        print("Skipping this score")
        continue  # Passa alla prossima iterazione
    
    try:
        score = int(score_input)
        
        if score < 0 or score > 100:
            print("Score must be between 0 and 100. Skipping.")
            continue  # Salta i punteggi non validi
        
        # Punteggio valido: elaboralo
        total_score += score
        score_count += 1
        print(f"Score recorded: {score}")
        
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
if score_count > 0:
    average = total_score / score_count
    print(f"\nAverage of {score_count} valid scores: {average:.1f}")
else:
    print("\nNo valid scores entered")

Questo esempio dimostra più usi di continue:

• salta quando l’utente inserisce "skip"
• salta quando il punteggio è fuori dall’intervallo valido
• salta quando l’input non è un numero valido

Ogni continue impedisce che il punteggio venga aggiunto al totale, ma il ciclo continua al tentativo successivo.

Combinare break e continue

Puoi usare sia break sia continue nello stesso ciclo per un controllo sofisticato:

# Elabora numeri finché la somma non supera 100, saltando i numeri negativi
total = 0
count = 0
 
while True:
    number_input = input("Enter a number (or 'done' to finish): ")
    
    if number_input.lower() == 'done':
        print("User finished entering numbers")
        break  # Esce dal ciclo
    
    try:
        number = int(number_input)
        
        if number < 0:
            print("Negative numbers not allowed. Skipping.")
            continue  # Passa alla prossima iterazione
        
        total += number
        count += 1
        print(f"Added {number}. Current total: {total}")
        
        if total > 100:
            print("Total exceeded 100. Stopping.")
            break  # Esce dal ciclo quando viene raggiunto il limite
            
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
print(f"\nFinal total: {total} (from {count} numbers)")

Questo ciclo dimostra:

• break per uscire quando l’utente digita "done"
• continue per saltare i numeri negativi
• continue per saltare input non valido
• break per uscire quando il totale supera 100

11.4) Usare else con i cicli while

Python ha una caratteristica unica che molti altri linguaggi di programmazione non hanno: puoi associare una clausola else a un ciclo while. Questo blocco else viene eseguito solo se il ciclo termina normalmente (cioè la condizione del ciclo diventa False senza incontrare un’istruzione break).

Sintassi di base di else con while

La sintassi è questa:

while condition:
    # Corpo del ciclo
else:
    # Questo viene eseguito solo se il ciclo termina normalmente
    # (non interrotto da break)

Vediamo un esempio semplice:

# Conta da 1 a 5 con clausola else
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1
else:
    print("Loop completed normally")
 
print("Program continues")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Loop completed normally
Program continues

Il blocco else viene eseguito perché il ciclo è andato avanti finché la sua condizione (count <= 5) non è diventata False. Il ciclo è terminato “normalmente” senza essere interrotto.

Quando else NON viene eseguito: l’istruzione break

Il comportamento chiave della clausola else è che non viene eseguita se il ciclo viene terminato da un’istruzione break:

# Cerca un numero con break
count = 1
target = 3
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Found 3!
Search complete

Nota che il blocco else ("Target not found in range") non è stato eseguito perché il ciclo è stato terminato da break. Questa è la distinzione cruciale: else viene eseguito solo quando il ciclo esce normalmente (la condizione diventa False), non quando esce tramite break.

Ora vediamo cosa succede quando il target non viene trovato:

# Cerca un numero che non esiste
count = 1
target = 7  # Non è nell'intervallo 1-5
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Checking: 4
Checking: 5
Target not found in range
Search complete

Questa volta, il ciclo ha completato tutte le iterazioni senza trovare il target, quindi la condizione count <= 5 alla fine è diventata False e il blocco else è stato eseguito.

Come else funziona con il completamento del ciclo

Ecco un diagramma di flusso che mostra i percorsi di esecuzione con la clausola else:

Il blocco else viene raggiunto solo quando la condizione del ciclo diventa False in modo naturale. Se viene incontrato break, il flusso salta direttamente oltre il blocco else al codice dopo il ciclo.

Uso pratico: operazioni di ricerca

La clausola else è particolarmente utile per operazioni di ricerca in cui vuoi sapere se qualcosa è stato trovato:

# Cerca una password valida in una lista di tentativi
valid_password = "python123"
max_attempts = 3
attempts = 0
 
while attempts < max_attempts:
    password = input(f"Enter password (attempt {attempts + 1}/{max_attempts}): ")
    attempts += 1
    
    if password == valid_password:
        print("Access granted!")
        break
else:
    print("Access denied. Maximum attempts exceeded.")
    print("Account locked.")

Se l’utente inserisce la password corretta, viene eseguito break e il blocco else viene saltato. Se tutti i tentativi vengono usati senza successo, il ciclo termina normalmente e viene eseguito il blocco else, indicando il fallimento.

else con continue

L’istruzione continue non impedisce l’esecuzione del blocco else. Solo break lo fa:

# continue non influisce sull'esecuzione di else
count = 0
while count < 5:
    count += 1
    if count == 3:
        print(f"Skipping {count}")
        continue  # Passa alla prossima iterazione
    print(f"Processing {count}")
else:
    print("Loop completed normally (continue doesn't prevent this)")

Output:

Processing 1
Processing 2
Skipping 3
Processing 4
Processing 5
Loop completed normally (continue doesn't prevent this)

Il blocco else viene eseguito perché il ciclo è terminato normalmente. L’istruzione continue influisce solo sulle singole iterazioni, non sul completamento complessivo del ciclo.

Confrontare else con e senza break

Vediamo un confronto affiancato:

# Esempio 1: Trovare un numero primo (con break)
print("Finding first number divisible by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
        break
    number += 1
else:
    print("No number divisible by 7 found in range")
print()
 
# Esempio 2: Controllare tutti i numeri (senza break)
print("Checking all numbers for divisibility by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
    number += 1
else:
    print("Finished checking all numbers")

Output:

Finding first number divisible by 7:
Found: 7
 
Checking all numbers for divisibility by 7:
Found: 7
Found: 14
Finished checking all numbers

Nel primo esempio, break ferma il ciclo dopo aver trovato la prima corrispondenza, quindi else non viene eseguito. Nel secondo esempio, il ciclo controlla tutti i numeri e termina normalmente, quindi else viene eseguito.

Quando usare else con i cicli while

La clausola else è più utile quando:

1. Operazioni di ricerca: vuoi sapere se qualcosa è stato trovato oppure no
2. Validazione con tentativi limitati: devi gestire il caso in cui tutti i tentativi siano esauriti
3. Elaborazione con uscita anticipata: vuoi un comportamento diverso tra “completato tutto” e “fermato in anticipo”

Tuttavia, else con i cicli può confondere i programmatori che provengono da altri linguaggi (dove questa funzionalità non esiste). A volte è più chiaro usare una variabile flag:

# Uso della clausola else
attempts = 0
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        break
else:
    print("Access denied")
 
# Equivalente usando una variabile flag (a volte più chiaro)
attempts = 0
access_granted = False
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        access_granted = True
        break
 
if not access_granted:
    print("Access denied")

Entrambi gli approcci funzionano. Scegli quello che rende il tuo codice più chiaro per la tua situazione specifica.

Comprendere else con i cicli while ti offre un altro strumento per scrivere codice chiaro ed espressivo, specialmente in scenari di ricerca e validazione in cui devi distinguere tra “trovato” e “non trovato” o “successo” e “fallimento dopo tutti i tentativi”.

In questo capitolo abbiamo esplorato in profondità i cicli while, imparando come:

• Strutturare cicli che ripetono codice in base a condizioni
• Evitare cicli infiniti aggiornando correttamente le variabili del ciclo
• Usare break per uscire dai cicli in anticipo quando necessario
• Usare continue per saltare iterazioni in base a condizioni
• Usare else per gestire i casi in cui i cicli terminano normalmente senza break

Questi strumenti ti danno un controllo potente sulla ripetizione nei tuoi programmi. Nel prossimo capitolo impareremo i cicli for, che offrono un modo più comodo per iterare su sequenze come stringhe, liste e intervalli.