Liste e cicli
Una fila di scatole, un dito che le indica
- 12 minuti di lettura
Una variabile tiene un valore. Ma la Linea Menta ha cinque fermate, e il treno M12 fa venti corse al giorno: non scriverai venti variabili. Ti serve una lista: tanti valori in fila, sotto un nome solo.
fermate = ["Porta Codice", "Via Variabile", "Largo Lista", "Ponte Ciclo", "Piazza Query"]
ritardi = [0, 3, 12, 1] # i minuti di ritardo di quattro treni
vuota = [] # una lista senza niente dentro, per oraE per fare la stessa cosa con ogni valore della fila, uno alla volta, ti serve un ciclo: il for.
Il disegno
Lo disegniamo come in Etichette e scatole: l'etichetta a sinistra, la scatola a destra. Una lista è una fila di scatole numerate. Il numero di una scatola si chiama indice, e si parte da 0. Si conta anche da destra, con i numeri negativi: -1 è l'ultima.
Gli indici sono 0, 1, 2, 3 da sinistra e -4, -3, -2, -1 da destra.
Il for è un dito che indica le scatole una alla volta, da sinistra a destra. A ogni giro, il nome che hai scritto dopo for (qui ritardo) vale quello che c'è nella scatola indicata. Quando le scatole finiscono, finisce il ciclo.
for ritardo in ritardi:
┌─────┬─────┬─────┬─────┐
│ 0 │ 3 │ 12 │ 1 │
└─────┴─────┴─────┴─────┘
giro 1 ▲ ritardo = 0
giro 2 ▲ ritardo = 3
giro 3 ▲ ritardo = 12
giro 4 ▲ ritardo = 1Le mosse
Tutto quello che si fa con una lista sta in questa tabella. Ogni riga parte dalla stessa lista: ritardi = [0, 3, 12, 1].
| Mossa | Si scrive | Cosa succede | Attenzione |
|---|---|---|---|
| Leggere una scatola | ritardi[1] | dà 3 | Una posizione che non c'è: IndexError |
| Leggere l'ultima | ritardi[-1] | dà 1 | Va bene con liste di qualunque lunghezza |
| Contare le scatole | len(ritardi) | dà 4 | L'ultima posizione è len(ritardi) - 1, cioè 3 |
| Prendere una fetta | ritardi[1:3] | dà [3, 12] | La fine è esclusa: la scatola 3 non c'è |
| Chiedere se c'è | 12 in ritardi | dà True | Cerca tra i valori, non tra le posizioni. Il contrario: 12 not in ritardi dà False |
| Cambiare una scatola | ritardi[0] = 5 | diventa [5, 3, 12, 1] | |
| Aggiungere in fondo | ritardi.append(7) | diventa [0, 3, 12, 1, 7] | Un valore per volta |
| Inserire in un posto | ritardi.insert(0, 2) | diventa [2, 0, 3, 12, 1] | Le altre scatole scorrono a destra |
| Togliere un valore | ritardi.remove(12) | diventa [0, 3, 1] | Toglie il primo che trova. Se non c'è: ValueError |
| Togliere una posizione | ritardi.pop() | dà 1, e resta [0, 3, 12] | pop(0) toglie la prima. Su una lista vuota: IndexError |
Le fette funzionano come per le stringhe: ritardi[:2] sono i primi due, ritardi[2:] dal terzo in poi, ritardi[-2:] gli ultimi due. Una fetta è una lista nuova: quella di partenza non cambia.
Il for
for ritardo in ritardi:
print("ritardo:", ritardo)
print("fine")ritardo: 0
ritardo: 3
ritardo: 12
ritardo: 1
fineTre cose da guardare:
ritardoè un nome nuovo, lo inventi tu. Usa il singolare della lista:for fermata in fermate,for corsa in corse.- Le righe rientrate sono il corpo del ciclo: si ripetono a ogni giro.
- La riga senza rientro parte una volta sola, dopo l'ultimo giro.
Contare i giri: range ed enumerate
range dà una fila di numeri interi, senza doverli scrivere. Come nelle fette, la fine è esclusa.
for numero in range(3): # 0, 1, 2
print(numero)
for numero in range(1, 4): # 1, 2, 3
print(numero)
for i in range(len(ritardi)): # 0, 1, 2, 3: proprio gli indici di ritardi
print(i, ritardi[i])Con gli indici puoi guardare anche la scatola accanto. Per esempio, di quanto cambia il ritardo da un treno al successivo:
for i in range(1, len(ritardi)): # da 1: la scatola 0 non ha una scatola prima
print(ritardi[i] - ritardi[i - 1]) # 3, poi 9, poi -11Se ti servono insieme la posizione e il valore, c'è enumerate, che ti dà le due cose in coppia. Con start=1 conta da 1, come si conta a voce:
for numero, fermata in enumerate(fermate, start=1):
print(numero, fermata) # 1 Porta Codice, 2 Via Variabile, …while e break, in breve
Il while ripete finché una condizione è vera. Serve quando non sai in anticipo quanti giri farai.
posti = 3
while posti > 0:
print("sale un passeggero")
posti = posti - 1
print("treno pieno")Stampa tre volte sale un passeggero, poi treno pieno.
break esce dal ciclo subito, anche se restano scatole da guardare. Serve per fermarsi al primo che trovi:
for ritardo in ritardi:
if ritardo > 10:
print("primo ritardo grave:", ritardo) # 12
break # l'1 dopo non lo guarda nessunoQuattro schemi che tornano sempre
Quasi ogni esercizio con le liste è uno di questi quattro, o due in fila. Lo scheletro ha sempre tre tempi: prima del for il punto di partenza, dentro l'aggiornamento a ogni giro, dopo il risultato.
L'accumulatore: sommare, contare.
totale = 0 # prima: da dove si parte
in_ritardo = 0
for ritardo in ritardi:
totale = totale + ritardo # dentro: a ogni giro
if ritardo > 0:
in_ritardo = in_ritardo + 1
print(totale, in_ritardo) # dopo, senza rientro: 16 3Il setaccio: tenere solo alcuni valori, in una lista nuova.
gravi = []
for ritardo in ritardi:
if ritardo >= 5:
gravi.append(ritardo)
print(gravi) # [12]Il massimo (o il minimo): il migliore visto finora.
peggiore = ritardi[0] # si parte dal primo, non da un numero inventato
for ritardo in ritardi:
if ritardo > peggiore:
peggiore = ritardo
print(peggiore) # 12La trasformazione: una lista nuova, lunga uguale, con ogni valore cambiato.
in_secondi = []
for ritardo in ritardi:
in_secondi.append(ritardo * 60)
print(in_secondi) # [0, 180, 720, 60]Quando li sai scrivere a mano, Python ha le scorciatoie. Per l'accumulatore e il massimo:
sum(ritardi) # 16
max(ritardi) # 12
min(ritardi) # 0Per il setaccio e la trasformazione c'è la comprehension: le quattro righe (lista vuota, for, if, append) diventano una.
gravi = [ritardo for ritardo in ritardi if ritardo >= 5] # [12]
in_secondi = [ritardo * 60 for ritardo in ritardi] # [0, 180, 720, 60]Si legge così: «ritardo * 60, per ogni ritardo in ritardi». L'if in fondo è il setaccio, e si può non mettere. Se non sta in una riga che si legge bene, torna al for: la chiarezza viene prima.
sorted o .sort()?
Tutti e due mettono in ordine, ma in due modi diversi.
ritardi = [0, 3, 12, 1]
in_ordine = sorted(ritardi) # una lista NUOVA, in ordine
print(in_ordine) # [0, 1, 3, 12]
print(ritardi) # [0, 3, 12, 1]: quella di prima non è cambiata
ritardi.sort() # mette in ordine PROPRIO ritardi, e non restituisce niente
print(ritardi) # [0, 1, 3, 12]Per l'ordine dal più grande: sorted(ritardi, reverse=True), oppure ritardi.sort(reverse=True).
Non togliere scatole dalla lista che stai scorrendo
corse = ["07:00", "soppressa", "soppressa", "07:45"]
for corsa in corse:
if corsa == "soppressa":
corse.remove(corsa)
print(corse) # ['07:00', 'soppressa', '07:45']Una «soppressa» è rimasta. Quando togli una scatola, quelle dopo scivolano indietro di un posto; il dito invece va avanti, e ne salta una. Il disegno, giro per giro, è nell'esempio G degli esercizi spiegati.
La regola: mentre scorri una lista, non toglierle né aggiungerle scatole. Costruisci una lista nuova, con il setaccio:
partono = [corsa for corsa in corse if corsa != "soppressa"]Tuple e spacchettamento
Una tupla è una fila corta che non cambia, tra parentesi tonde. Serve per tenere insieme cose che vanno in coppia, come un treno e il suo ritardo.
arrivo = ("M12", 4)
print(arrivo[0]) # M12: gli indici funzionano come nelle liste
treno, ritardo = arrivo # spacchettare: un nome per ogni pezzo, nell'ordine
print(treno, ritardo) # M12 4Si spacchetta anche nel for, quando la lista è fatta di coppie:
arrivi = [("M12", 4), ("M14", 0), ("M16", 9)]
for treno, ritardo in arrivi:
print(treno, "ha", ritardo, "minuti di ritardo") # M12 ha 4 minuti di ritardo, …Una funzione che restituisce due cose, in realtà ne restituisce una: una tupla. return prima, ultima è lo stesso di return (prima, ultima).
Due liste lunghe uguali si scorrono insieme con zip, che le accoppia una posizione alla volta:
orari = ["07:00", "07:04", "07:09"]
for fermata, ora in zip(fermate, orari):
print(ora, fermata) # 07:00 Porta Codice, 07:04 Via Variabile, 07:09 Largo ListaSe una delle due è più corta, zip si ferma lì: fermate ha cinque scatole, ma i giri sono tre.
Dopo le liste
Una lista trova le cose per posizione: «qual è la terza fermata?». Quando ti servirà trovarle per nome («quanti vagoni ha M14?»), arriva il dizionario: è il capitolo I dizionari. I quattro schemi di questa pagina tornano lì quasi identici.
Ricorda
- Si conta da 0: la prima è
[0], l'ultima[-1]. - Il
forè un dito: una scatola per giro. Il nome lo scegli tu. - Prima del
foril punto di partenza, dentro l'aggiornamento, dopo il risultato. Anche ilreturnva dopo. - Accumulatore, setaccio, massimo, trasformazione. Poi
sum,max,mine la comprehension. sorted(x)dà una lista nuova;x.sort()cambiaxe dàNone.- Mentre scorri una lista non toglierle scatole: costruiscine una nuova.