Tutorial sui cicli in Python

Ciclo for

Puoi affrontare il ciclo for allo stesso modo del ciclo while. Come probabilmente ti aspettavi, il componente "for" in "for loop" si riferisce a qualcosa che fai per un certo numero di volte.

Se tieni a mente quanto sopra, puoi definire facilmente il ciclo for come segue:

Un ciclo for è un concetto di programmazione che, quando implementato, esegue un pezzo di codice più e più volte "per" un certo numero di volte, basandosi su una sequenza.

A differenza del ciclo while, non c'è alcuna condizione attivamente coinvolta: esegui semplicemente un pezzo di codice ripetutamente per un certo numero di volte. In altre parole, mentre il ciclo while continua a eseguire il blocco di codice contenuto al suo interno solo finché la condizione è True, il ciclo for esegue il codice contenuto al suo interno solo per un numero specifico di volte. Questo "numero di volte" è determinato da una sequenza o da una lista ordinata di elementi.

Imparerai di più sulla differenza tra cicli while e for tra poco, ma per ora concentrati sui seguenti elementi di cui hai bisogno per creare un ciclo for:

• La parola chiave for
• Una variabile
• La parola chiave in
• La funzione range(), che è una funzione built-in della libreria Python per creare una sequenza di numeri
• Il codice che vuoi eseguire ripetutamente

Cicli for in Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

# Thank you
# Thank you
# Thank you
# Thank you
# Thank you

Come puoi vedere, i componenti che hai visto nella sezione precedente ritornano in questo piccolo esempio di ciclo for in Python: la parola chiave for, la variabile number, la parola chiave in, la funzione range() e il codice che vuoi eseguire più volte, print("Thank you").

Non è poi così difficile, vero?

Consideriamo un altro esempio di ciclo for, in cui utilizzi due variabili per definire il flusso di controllo:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

Come puoi vedere, inizi il ciclo con la parola chiave for. Poi usi le variabili index e languages, la parola chiave in e la funzione range() per creare una sequenza di numeri. Inoltre, in questo caso usi anche la funzione len(), dato che la lista languages non è numerica. Il pezzo di codice che vuoi eseguire ripetutamente è un'istruzione di stampa, cioè print('Current language :', languages[index]).

Nel ciclo sopra, intendi esprimere che per ogni indice nell'intervallo len(languages) vuoi stampare il linguaggio di programmazione per la data science. Ora, len(languages) è 5, quindi l'istruzione si potrebbe anche riscrivere così:

for index in range(5):
    print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

E anche questa volta ottieni lo stesso risultato!

While vs for in Python

Rivediamo di nuovo il primissimo esempio di ciclo while per determinare quali siano esattamente le differenze tra cicli while e for. Hai già letto sopra che la differenza sta nella condizione che è o non è coinvolta, ma come si riflette questo nel codice e come puoi magari passare da uno all'altro?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

# Thank you
# Thank you
# Thank you

Puoi usare un ciclo for per stampare l'istruzione "Thank you" in modo più controllato:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

# Thank you
# Thank you
# Thank you

Visto quanto è stato facile convertire il ciclo while in un ciclo for equivalente?

Come funziona, ti chiedi? È semplice.

In un ciclo for, l'intero indicato all'interno della funzione range è l'intervallo o il numero di volte in cui il controllo deve ciclare ed eseguire il codice nella clausola del for.

Nota che il conteggio della funzione range() parte da 0 e non da 1. Ciò significa che, nell'esempio sopra, il conteggio sarà 0,1,2 e non 1,2,3. È così che funziona il conteggio in memoria per un computer. Quindi, quando progetti un ciclo for, tieni sempre a mente che devi considerare il conteggio dell'intervallo a partire da 0 e non da 1.

Consiglio: vale lo stesso per le liste in Python, per esempio. Se vuoi saperne di più sulle liste Python, dai un'occhiata al tutorial di DataCamp 18 domande più comuni sulle liste in Python.

Ora, c'è un'altra differenza interessante tra un ciclo for e un ciclo while. Un ciclo for è più veloce di un ciclo while. Per capirlo guarda l'esempio qui sotto.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

# 267.0804728891719

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

# 884.9233417965908

Nel blocco di codice sopra hai due cicli con circa 10000 iterazioni. A prima vista sembrano uguali, finché non guardi dietro le quinte e capisci come funzionano questi due cicli. Suggerimento: la funzione timeit() ti dà un indizio su quale potrebbe essere la differenza!

Ricorda: tutto il codice Python viene compilato con un compilatore C, il che significa che il codice che vedi sopra viene prima scomposto in bytecode e poi elaborato dal compilatore C sottostante.

Quando inizia l'esecuzione del ciclo for nell'esempio sopra, l'interprete Python parla con il compilatore C sottostante e poi crea un oggetto lista di dimensione 10000. Successivamente, chiama un iteratore per toccare l'indice di ognuno dei 10000 elementi della lista.

L'esecuzione del ciclo while, invece, non crea alcun oggetto lista. Infatti, il compilatore C sottostante chiama l'operatore di confronto booleano per la condizione i<10000 per 9999 volte.

Puoi già immaginare che iterare su un oggetto lista già creato con 10000 elementi sia più facile per il compilatore che eseguire un'operazione booleana ripetutamente per 9999 volte: le prestazioni temporali di un ciclo for sono migliori di quelle di un ciclo while. Questo si riflette chiaramente nel tempo di esecuzione: il tempo necessario al ciclo for per completare è molto inferiore al tempo richiesto al ciclo while.

Ora prova il ciclo for! Nota che vuoi specificare l'intervallo da 0 a 11, dato che vuoi visualizzare solo i numeri nella sequenza fino a 55, che è l'11º numero della sequenza.

Cicli annidati

Come puoi notare in un esempio sopra, c'è una condizione if-else all'interno del ciclo while che ti permette di introdurre ulteriori condizioni nel tuo codice.

Fermo lì!

Non è l'unico modo in cui puoi personalizzare il tuo ciclo. Puoi anche includere altri cicli while all'interno del codice esistente: questo è noto come ciclo annidato. Puoi modificare l'esempio precedente per includere un altro ciclo while come sotto:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

Nell'esempio sopra c'è un altro ciclo while "annidato" dentro il ciclo esterno; questo ciclo interno aggiunge un ulteriore controllo per vedere se il number % (mod) 2 è 0.

In altre parole, controlla se il numero è pari e poi stampa l'istruzione "The number is even".

Ma c'è un tranello: se guardi da vicino, puoi vedere che, come nel codice precedente, questa volta manca l'istruzione number=number+1. Poiché non incrementi la variabile number da nessuna parte, il valore della variabile rimane lo stesso ogni volta e il codice entra in un ciclo infinito. Ciò significa che, una volta entrato nel ciclo, non ne esce mai e stampa l'istruzione un numero infinito di volte perché la variabile number sarà sempre impostata a 2. Questo numero è, ovviamente, minore di 5 e un numero pari.

Vediamo ora come appare un ciclo for annidato:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

Il codice sopra è una versione modificata del primo esempio di ciclo for. Nota come un secondo ciclo for viene utilizzato all'interno del ciclo esterno.

Vai avanti ed esegui il codice.

Scoprirai che il controllo entra nel primo ciclo for e il valore della variabile number viene inizializzato a 0. Viene stampata la prima istruzione di stampa, quindi il controllo entra nel secondo ciclo for, dove il valore della variabile another_number viene inizializzato a 0. La prima istruzione di stampa nel secondo ciclo for viene stampata una volta.

Ora, il controllo ritorna nuovamente al ciclo for interno e il valore di another_number viene di nuovo inizializzato all'intero successivo, per poi stampare l'istruzione all'interno della funzione print().

Il processo descritto continua finché il controllo ha attraversato la fine della funzione range(), che in questo caso è 5, dopodiché il controllo ritorna al ciclo più esterno, inizializza la variabile number all'intero successivo, stampa l'istruzione all'interno della funzione print(), visita il ciclo interno e poi ripete tutti i passaggi sopra finché la funzione range() viene attraversata.

Questo "viaggio" del controllo che va dal ciclo più esterno, attraversa il ciclo interno e poi torna di nuovo al ciclo for esterno continua finché il controllo ha coperto l'intero intervallo, cioè 3 volte nel tuo caso.

Ora che hai letto alcune spiegazioni sui cicli annidati, è il momento di metterti all'opera! Scrivi un programma Python per costruire il seguente pattern, usando un ciclo for annidato:

break e continue: creare cicli infiniti

Puoi usare break e continue in qualsiasi ciclo tu crei. Queste parole chiave non sono limitate all'interruzione di cicli infiniti intenzionali, ma andrebbero usate con cautela. Entrambe rendono più difficile per gli altri —e per te stesso tra qualche mese quando riguarderai il tuo codice— capire il flusso di controllo nel ciclo e dove finisce la condizione. Inoltre, non devi usare le parole chiave break e continue: come hai visto finora, te la sei cavata benissimo senza!

Tuttavia, in alcuni casi può essere più chiaro scrivere cicli infiniti intenzionali piuttosto che i tradizionali cicli for e while che hai visto finora. Ovviamente, in quei casi l'uso di queste parole chiave è incoraggiato!

Interrompere e continuare i cicli while in Python

Fortunatamente, c'è un modo per uscire dalla situazione di ciclo infinito sopra, ed è usare la parola chiave break.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Quando esegui il codice sopra non entra più in un ciclo infinito.

"Che stregoneria è mai questa!" esclami. - Tranquillo, non è stregoneria.

Quello che succede è che, quando il controllo incontra la parola chiave break, capisce che deve uscire dal ciclo (in questo caso quello interno) ed eseguire la riga di codice successiva. Quindi esce dal ciclo while interno e torna al ciclo esterno, continuando a fare il suo solito lavoro finché la condizione del ciclo while esterno rimane vera.

Dovresti considerare il fatto che deve esistere una riga di codice dopo la parola chiave break, altrimenti non avrà alcun effetto. Prova a rimuovere la riga di codice dopo la parola chiave break nell'esempio sopra ed esegui il codice.

E se inserissi di soppiatto la parola chiave continue dopo l'istruzione break? Puoi seguire il codice qui sotto:

number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

Il codice sopra è una versione leggermente modificata dell'esempio con la parola chiave break.

Quando esegui il codice sopra, incontrerai di nuovo un ciclo infinito. Prima di strapparsi i capelli dalla frustrazione, guarda più da vicino. Noterai che c'è una parola chiave continue dopo il break. Quello che fa continue è trasferire il controllo di nuovo al ciclo più esterno ancora prima che la variabile number venga incrementata e, per questo motivo, il codice entra in un ciclo infinito.

Interrompere e continuare i cicli for

E se non volessi eseguire il ciclo for interno nell'esempio sopra per l'intero intervallo? Puoi usare un'istruzione break in modo simile a quanto fatto nel caso del ciclo while.

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Nell'esempio sopra, la parola chiave break dopo il ciclo interno istruisce il controllo a uscire dal ciclo interno, dopodiché il controllo torna al ciclo esterno.

Esegui il seguente esempio di codice:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Nel codice sopra viene eseguito solo il ciclo più esterno e il controllo non tocca nemmeno il ciclo interno.

"Perché?" chiedi.

Guarda più da vicino il codice. C'è una parola chiave continue subito dopo la seconda istruzione di stampa nel ciclo più esterno. Quello che fa è istruire il controllo a saltare indietro al ciclo for esterno e ricominciare da capo, ed è per questo che il controllo non tocca mai il ciclo interno.

A differenza del ciclo while, non hai bisogno di un pezzo di codice dopo la parola chiave break nel ciclo for. Un break da solo funzionerà benissimo all'interno di un ciclo for.

range() vs xrange()

Queste due funzioni sono simili tra loro, ma se stai usando Python 3 avrai a disposizione solo la funzione range(). In Python 3.x, la funzione xrange() è stata rinominata in range(). Ciò significa che se provi a usare la funzione xrange() con Python 3, otterrai l'errore NameError: name 'xrange' is not defined.

Per capire come queste due funzioni siano simili, considera il seguente esempio:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

# I am number : 5
# I am number : 7
# I am number : 9

Eseguendo il codice sopra, vedrai come il valore della variabile number salta di 2, e questo è dovuto ai parametri nella funzione range().

Il primo parametro di questa funzione è il parametro di inizio. È il punto da cui il controllo inizia a contare. Il secondo parametro è quello di fine, cioè il punto in cui il controllo deve fermarsi, e l'ultimo parametro è lo step, che definisce di quanto il controllo deve saltare durante il conteggio.

Quindi, nel caso sopra, il controllo parte da 5, poi attraversa il ciclo fino a 9 aggiungendo 2 a ogni conteggio. Questo significa 5, 5+2=7, 7+2=9.

Hai imparato come la funzione range() viene usata per definire quante volte il tuo codice deve ciclare. Ora, in Python 2.x, troverai anche un altro modo per farlo, ovvero con la funzione xrange(). Esegui il codice qui sotto:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

Che differenza hai visto nell'output del codice sopra rispetto a quello senza la funzione xrange()? Nessuna differenza?

Esatto. Non vedrai alcuna differenza nell'output del codice.

Allora perché dovresti usare la funzione xrange()? Ci arriverai un po' più avanti nel tutorial. Prima esegui il codice qui sotto:

print(xrange(10))
print(range(10))

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Puoi vedere che nell'output del codice sopra c'è una differenza tra i due print. Nell'istruzione di stampa che contiene la funzione xrange(), viene stampato l'oggetto funzione xrange(). Diverso invece nell'istruzione che usa la funzione range(): lì ottieni una lista di interi da 0 a 9.

Ora, questa è esattamente la differenza tra la funzione range() e la funzione xrange().

Quando definisci la funzione range(), un elenco dell'intero intervallo viene memorizzato nella RAM e presentato a te. Tuttavia, quando definisci la funzione xrange(), un elenco non viene memorizzato in memoria. Invece, la funzione xrange() genera gli interi dell'intero intervallo quando ne hai bisogno. In questo modo, la funzione xrange() aiuta a conservare memoria in sistemi con risorse limitate.

Affina le tue skill di Python!

Congratulazioni, sei arrivato alla fine di questo tutorial. Ora che hai imparato a usare i cicli in Python, vai avanti e fai pratica. Più pratichi, meglio è!