parte 2° alfabeto informatico

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.

10. Espressioni booleane
Questo è un piccolo esempio di espressioni booleane (non dovete scriverlo):
a = 6
b = 7
c = 42
print 1, a == 6
print 2, a == 7
print 3,a == 6 and b == 7
print 4,a == 7 and b == 7
print 5,not a == 7 and b == 7
print 6,a == 7 or b == 7
print 7,a == 7 or b == 6
print 8,not (a == 7 and b == 6)
print 9,not a == 7 and b == 6
Questo è l'output:
1 1
2 0
3 1
4 0
5 1
6 1
7 0
8 1
9 0
Cosa succede? Il programma consiste in una serie di istruzioni print. Ogni istruzione print visualizza un numero e un'espressione. Il numero serve a farvi capire quale istruzione viene eseguita. Potete notare che ogni espressione consiste in uno 0 o in un 1. In Python equivalgono a falso (0) e a vero (1).
Le linee:
print 1, a == 6
print 2, a == 7
Restituiscono infatti vero e falso, esattamente come dovrebbero fare finché la prima affermazione è vera e la seconda è falsa. La terza istruzione print è un po' diversa: print print 3,a == 6 and b == 7. L'operatore and indica che se entrambe le affermazioni prima e dopo l'operatore logico sono vere tutta l'espressione è vera, altrimenti tutta l'espressione è falsa. L'espressione successiva, print 4,a == 7 and b == 7, dimostra che se una parte dell'espressione and è falsa, tutta l'espressione sarà falsa. Il significato di and può essere riassunto come segue:
espressione risultato
vero and vero vero
vero and falso falso
falso and vero falso
falso and falso falso
Potete notare che se la prima espressione è falsa Python non esegue un controllo sulla seconda espressione perché sa già che tutta l'espressione è falsa.
La linea successiva, print 5,not a == 7 and b == 7, utilizza l'operatore not che restituisce semplicemente l'opposto dell'espressione. L'espressione può infatti essere riscritta semplicemente come print 5,a != 7 and b == 7. Questa è la tabella:
espressione risultato
not vero falso
not falso vero
Le due linee seguenti, print 6,a == 7 or b == 7 e print 7,a == 7 o b == 6, utilizzano l'operatore logico or che ritorna vero se una delle affermazioni (o entrambe) è vera. Questa è la tabella:
espressione risultato
vero or vero vero
vero or falso vero
falso or vero vero
falso or falso falso
Anche qui Python non esegue il controllo sulla seconda espressione se riconosce la prima come vera dato che anche se la seconda affermazione risultasse falsa l'intera espressione sarebbe comunque vera.
Le ultime due linee, print 8,not (a == 7 and b == 6)e print 9,not a == 7 and b == 6, mostrano come le parentesi possano raggruppare espressioni e forzarne l'esecuzione prima di altre al di fuori dalle parentesi. Potete osservare infatti che le parentesi cambiano il valore dell'espressione da falso a vero, visto che obbligano l'operatore not a valutare l'intera espressione anziché solamente la porzione a == 7.
Ecco un esempio sull'utilizzo delle espressioni booleane:
list = ["Life","The Universe","Everything","Jack","Jill","Life","Jill"]

# Crea una copia della lista. Vedi il capitolo ``Ancora sulle liste''
# per una spiegazione del costrutto [:].
copy = list[:]
# Ordina la copia.
copy.sort()
prev = copy[0]
del copy[0]

count = 0

# Esamina la lista per trovare una corrispondenza.
while count < len(copy) and copy[count] != prev:
prev = copy[count]
count = count + 1

# Se non viene trovata una corrispondenza allora count non può essere
# < len(copy) in quel momento, quindi usciamo dal ciclo while.
if count < len(copy):
print "First Match: ",prev
Ecco l'output:
First Match: Jill
Questo programma continua a scorrere la lista cercando duplicati (while count < len(copy and copy[count]). Quando uno dei due contatori è più grande dell'ultimo indice di copy o viene trovato un duplicato, l'operatore and non risulta più vero e si esce dal ciclo. if si occupa semplicemente di accertarsi che l'uscita dal ciclo while sia dovuta alla presenza di un duplicato