Cicli For

Qui il nuovo esercizio da scrivere per questo capitolo:

onetoten = range(1,11)
for count in onetoten:
        print count

E qui l'onnipresente output:

1
2
3
4
5
6
7
8
9
10

L'output è familiare ma il codice è diverso. La prima linea utilizza la funzione range, usa due argomenti, proprio come nell'esempio: range(inizio,fine). inizio è il primo numero che viene prodotto, mentre fine è maggiore di 1 dell'ultimo numero prodotto. Questo programma avrebbe anche potuto essere scritto più brevemente:

for count in range(1,11):
        print count

Ecco a voi alcuni esempi per comprendere meglio il funzionamento di range:

>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]

Avrete certamente notato la presenza di una nuova struttura di controllo, for count in onetoten:, gli esempi infatti usano la struttura for. La sintassi della struttura di controllo for è simile a for variabile in lista:. La lista viene quindi analizzata dal primo elemento sino all'ultimo. Mentre il ciclo for compie il suo tragitto, ogni elemento viene inserito in una variabile. Questo consente alla variabile di essere usata successivamente, in qualsiasi momento, in ogni ciclo for attivo. Qui un'altro esempio (non dovete scriverlo) per dimostrarlo:

demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print "The Current item is:",
    print item

L'output è:

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

Osservate come il ciclo for scorra tutti gli elementi nella lista - provate ad esempio a togliere la virgola alla fine dell'istruzione print o a cambiare il testo all'interno della stessa... Quindi, a cosa serve il for? Beh, serve a scorrere uno ad uno tutti gli elementi di una lista e a fare qualcosa con ognuno di essi. Questo è un esempio dove sono sommati tutti gli elementi:

list = [2,4,6,8]
sum = 0
for num in list:
        sum = sum + num
print "The sum is: ",sum

Con questo semplice output:

The sum is:  20

Altrimenti potreste scrivere un semplice programma per trovare i duplicati in una lista, come in questo programma:

list = [4, 5, 7, 8, 9, 1,0,7,10]
list.sort()
prev = list[0]
del list[0]
for item in list:
        if prev == item:
                print "Duplicate of ",prev," Found"
        prev = item

Il cui output è ovviamente:

Duplicate of  7  Found

Va bene, allora come funziona? Scriviamo il programma in modo che ritorni un risultato passaggio per passaggio, qualcosa di molto simile al debugging:

l = [4, 5, 7, 8, 9, 1,0,7,10]
print "l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l
l.sort()
print "l.sort()","\tl:",l
prev = l[0]
print "prev = l[0]","\tprev:",prev
del l[0]
print "del l[0]","\tl:",l
for item in l:
        if prev == item:
                print "Duplicate of ",prev," Found"
        print "if prev == item:","\tprev:",prev,"\titem:",item
        prev = item
        print "prev = item","\t\tprev:",prev,"\titem:",item

L'output è cambiato:

l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
Duplicate of  7  Found
if prev == item:        prev: 7         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10

La ragione per cui sono stati inseriti così tanti print nel codice è che in questo modo riusciamo a vedere il comportamento del programma linea per linea (quindi se non riuscite ad immaginare il problema di un programma malfunzionante tentate di mettere molti print per individuarlo con più facilità). Il programma inizia con la nostra solita noiosa e vecchia lista, ordinata nella seconda linea a seconda del valore degli elementi (dal minore al maggiore), in modo che ogni duplicato, se ce ne sono, sia vicino all'originale da cui proviene. Dopo questi primi passi viene inizializzata una variabile, prev(ious). Il primo elemento della lista (0) viene cancellato perché altrimenti sarebbe incorrettamente sembrato un duplicato della variabile prev. La linea successiva, come potete vedere, è un ciclo for. Ogni singolo elemento della lista viene in questo modo testato e confrontato con il precedente per riconoscere eventuali duplicati. Questo avviene memorizzando il valore del precedente elemento della lista nella variabile prev e confrontando quest'ultima con l'elemento corrente. prev viene quindi di volta in volta (ad ogni ciclo) riassegnato, in modo che l'elemento corrente venga sempre confrontato con quello appena precedente nella lista. Vengono rilevate 7 voci duplicate. Osservate anche come viene utilizzato \t per stampare una tabulazione.

Un'altro modo per utilizzare un ciclo for è ripetere la stessa azione un determinato numero di volte. Ecco il codice per visualizzare i primi 11 numeri della serie di Fibonacci:

a = 1
b = 1
for c in range(1,10):
        print a,
        n = a + b
        a = b
        b = n

Con il sorprendente output:

1 1 2 3 5 8 13 21 34

Tutto quello che potete fare con i cicli for potete farlo anche con while ma grazie ai cicli for è più semplice scorrere tra tutti gli elementi di una lista o compiere un'azione un determinato numero di volte.