Liste e cicli, esercizi spiegati
Sette esempi, un giro alla volta
- 25 minuti di lettura
Sette esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa c'è nelle scatole a ogni giro.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi provare ogni esempio nel terminale di Python (python3, poi incolla) o su Python Tutor, che disegna le scatole e il dito per te, un giro alla volta.
A · Le fermate della Linea Menta
Indici, fette, len e in sulla lista delle fermate.
fermate = ["Porta Codice", "Via Variabile", "Largo Lista", "Ponte Ciclo", "Piazza Query"]
print(fermate[2])
print(fermate[-2])
print(len(fermate))
print(fermate[:2])
print(fermate[3:])
print("Vecchia Fiera" in fermate)
print(fermate[5])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Largo Lista
Ponte Ciclo
5
['Porta Codice', 'Via Variabile']
['Ponte Ciclo', 'Piazza Query']
False
IndexError: list index out of range- Riga 1: si parte da 0, quindi la scatola 2 è la terza fermata.
- Riga 2:
-1è l'ultima,-2la penultima. - Riga 3: cinque scatole, numerate da 0 a 4.
- Righe 4 e 5:
[:2]sono le scatole 0 e 1 (la 2 è esclusa);[3:]va dalla 3 alla fine. Una fetta è sempre una lista, anche quando prendi una scatola sola. - Riga 6: Vecchia Fiera è chiusa al pubblico, non è sulla lista.
- Riga 7: la scatola 5 non esiste, l'ultima è la 4. Il programma si ferma.
Cosa portiamo a casa. Con 5 scatole, l'ultima è la numero 4: len(fermate) - 1. Quando ti serve l'ultima, [-1] ti evita il conto.
B · La coda del deposito
Al deposito di Porta Codice i treni escono in fila. Ogni riga cambia la coda.
coda = ["M12", "M14"]
coda.append("M16")
coda.insert(0, "M10")
uscito = coda.pop(0)
coda.remove("M14")
print(uscito)
print(coda)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
M10
['M12', 'M16']Passo per passo. Qui non ci sono giri: guardiamo la coda dopo ogni riga.
| Riga | coda dopo la riga | Cosa è successo |
|---|---|---|
coda = ["M12", "M14"] | ["M12", "M14"] | Due treni in coda |
coda.append("M16") | ["M12", "M14", "M16"] | M16 si mette in fondo |
coda.insert(0, "M10") | ["M10", "M12", "M14", "M16"] | M10 passa davanti a tutti: gli altri scorrono di un posto |
uscito = coda.pop(0) | ["M12", "M14", "M16"] | Il primo esce dalla coda, e uscito vale "M10" |
coda.remove("M14") | ["M12", "M16"] | M14 va in officina: tolto per nome, ovunque fosse |
pop è l'unica delle quattro che restituisce qualcosa: la scatola che ha tolto. Le altre cambiano la lista e basta.
Cosa portiamo a casa. append, insert, remove e pop cambiano la lista sul posto: non serve il =.
C · I passeggeri di Ponte Ciclo
Il contapersone di Ponte Ciclo segna quanti passeggeri salgono su ogni treno. Quanti in tutto? E su quanti treni non è salito nessuno?
saliti = [12, 0, 7, 3]
totale = 0
senza_nessuno = 0
for quanti in saliti:
totale = totale + quanti
if quanti == 0:
senza_nessuno = senza_nessuno + 1
print(totale, senza_nessuno)Il disegno.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
22 1In italiano.
- Prima del ciclo, i due conti partono da zero.
- A ogni treno, aggiungo i suoi passeggeri al totale.
- Se non è salito nessuno, aggiungo uno al conto dei treni «senza nessuno».
- Dopo il ciclo, stampo i due conti.
Passo per passo.
| Giro | quanti | totale dopo il giro | quanti == 0? | senza_nessuno dopo il giro |
|---|---|---|---|---|
| prima | — | 0 | — | 0 |
| 1 | 12 | 0 + 12 = 12 | no | 0 |
| 2 | 0 | 12 + 0 = 12 | sì | 1 |
| 3 | 7 | 12 + 7 = 19 | no | 1 |
| 4 | 3 | 19 + 3 = 22 | no | 1 |
Sono due accumulatori nello stesso giro: uno somma i valori, l'altro conta le volte. Per la somma da sola, Python ha già sum(saliti), che dà 22.
Cosa portiamo a casa. Tre posti, tre compiti: prima del for il punto di partenza, dentro l'aggiornamento, dopo il risultato.
D · Il tabellone dei prossimi treni
Sul tabellone di Piazza Query: tra quanti minuti passano i prossimi treni. Prima teniamo solo quelli vicini, poi scriviamo le righe del tabellone.
attese = [4, 12, 2, 9]
presto = []
for minuti in attese:
if minuti <= 5:
presto.append(minuti)
print(presto)
righe = []
for minuti in attese:
righe.append(f"tra {minuti} min")
print(righe)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
[4, 2]
['tra 4 min', 'tra 12 min', 'tra 2 min', 'tra 9 min']In italiano. Il primo ciclo è un setaccio: passa solo chi rispetta l'if, e la lista nuova può essere più corta. Il secondo è una trasformazione: ogni valore diventa un'altra cosa, e la lista nuova è lunga uguale.
Il disegno, per il setaccio:
Passo per passo, il setaccio:
| Giro | minuti | minuti <= 5? | presto dopo il giro |
|---|---|---|---|
| prima | — | — | [] |
| 1 | 4 | sì | [4] |
| 2 | 12 | no | [4] |
| 3 | 2 | sì | [4, 2] |
| 4 | 9 | no | [4, 2] |
Lo stesso, con la comprehension. Le quattro righe di ogni ciclo diventano una:
presto = [minuti for minuti in attese if minuti <= 5]
righe = [f"tra {minuti} min" for minuti in attese]E si possono fare le due cose insieme:
[ f"tra {minuti} min" for minuti in attese if minuti <= 5 ]
└── cosa metto ───┘ └─ da dove prendo ─┘ └ chi tengo ─┘
nella lista nuova i valori (facoltativo)Il risultato: ['tra 4 min', 'tra 2 min'].
Cosa portiamo a casa. Setaccio: l'append sta dentro l'if. Trasformazione: l'append c'è sempre, e cambia il valore. La comprehension è una scorciatoia per tutti e due: prima sappili scrivere con il for.
E · Il vagone più pieno
Il treno M16 ha quattro vagoni, e il contapersone sa quanti passeggeri c'erano in ognuno. Quale vagone era il più pieno? Vogliamo il numero del vagone, contato da 1 come sulle porte.
vagoni = [34, 51, 47, 51]
piu_pieno = vagoni[0]
quale = 1
for numero, passeggeri in enumerate(vagoni, start=1):
if passeggeri > piu_pieno:
piu_pieno = passeggeri
quale = numero
print(quale, piu_pieno)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
2 51In italiano.
- Il più pieno, per ora, è il primo vagone: 34 passeggeri, vagone 1.
- Per ogni vagone, con il suo numero:
- se ha più passeggeri del più pieno visto finora, diventa lui il più pieno, e mi segno il suo numero.
Il disegno.
Passo per passo.
| Giro | numero | passeggeri | Confronto | piu_pieno dopo | quale dopo |
|---|---|---|---|---|---|
| prima | — | — | — | 34 | 1 |
| 1 | 1 | 34 | 34 > 34? no | 34 | 1 |
| 2 | 2 | 51 | 51 > 34? sì | 51 | 2 |
| 3 | 3 | 47 | 47 > 51? no | 51 | 2 |
| 4 | 4 | 51 | 51 > 51? no | 51 | 2 |
Il vagone 4 ha gli stessi passeggeri del 2, ma con > non lo scavalca: a pari merito vince il primo. Con >= vincerebbe l'ultimo, e la risposta sarebbe 4 51.
max(vagoni) dà 51 in una parola, e min(vagoni) dà 34. Ma ti dicono solo quanto, non quale vagone: per quello serve il ciclo.
Cosa portiamo a casa. Il massimo a mano: si parte dal primo, si scavalca solo chi è più grande. Se ti serve anche il posto, te lo segni insieme al valore.
F · Il primo vagone con posto
Il capotreno annuncia dove salire. Ha due liste lunghe uguali: i vagoni e i loro posti liberi. Basta il primo vagone con un posto.
vagoni = ["A", "B", "C", "D"]
posti_liberi = [0, 0, 6, 2]
for vagone, liberi in zip(vagoni, posti_liberi):
print("controllo il vagone", vagone)
if liberi > 0:
print("salite sul vagone", vagone)
break
print("porte in chiusura")Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
controllo il vagone A
controllo il vagone B
controllo il vagone C
salite sul vagone C
porte in chiusuraIn italiano. zip accoppia le due liste, posizione per posizione: a ogni giro ho un vagone e i suoi posti. Appena trovo un vagone con posto lo annuncio, e break chiude il ciclo: il programma continua dalla prima riga dopo il for.
Passo per passo.
| Giro | vagone, liberi | liberi > 0? | Cosa succede |
|---|---|---|---|
| 1 | "A", 0 | no | si va avanti |
| 2 | "B", 0 | no | si va avanti |
| 3 | "C", 6 | sì | l'annuncio, poi break: il ciclo finisce qui |
| — | "D", 2 | — | non lo guarda nessuno |
Senza break, il giro 4 arriva al vagone D, che ha 2 posti, e il capotreno annuncia due vagoni: salite sul vagone C, poi salite sul vagone D.
Cosa portiamo a casa. zip per scorrere due liste insieme; break quando basta il primo. Se ti servono tutti quelli giusti, è un setaccio, e il break non c'entra.
G · Ordinare e togliere
Due modi di mettere in ordine i ritardi, e un modo sbagliato di togliere i treni guasti.
ritardi = [7, 0, 12, 3]
in_ordine = sorted(ritardi)
print(in_ordine)
print(ritardi)
risultato = ritardi.sort()
print(risultato)
print(ritardi)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
[0, 3, 7, 12]
[7, 0, 12, 3]
None
[0, 3, 7, 12]sortedcostruisce una lista nuova in ordine:ritardiresta com'era..sort()mette in ordine proprioritardi, e non restituisce niente:risultatovaleNone.
E adesso i guasti. Vogliamo togliere dalla lista tutti i "guasto".
treni = ["M12", "guasto", "guasto", "M16"]
for treno in treni:
if treno == "guasto":
treni.remove(treno)
print(treni)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
['M12', 'guasto', 'M16']Un «guasto» è rimasto, e nessun errore te lo dice.
Passo per passo. Il dito va avanti di una scatola a ogni giro, ma il remove sposta le scatole sotto il dito.
giro 1 il dito è sulla scatola 0
┌───────┬──────────┬──────────┬───────┐
│ "M12" │ "guasto" │ "guasto" │ "M16" │ "M12": niente da fare
└───────┴──────────┴──────────┴───────┘
▲
giro 2 il dito passa alla scatola 1
┌───────┬──────────┬──────────┬───────┐
│ "M12" │ "guasto" │ "guasto" │ "M16" │ "guasto": remove
└───────┴──────────┴──────────┴───────┘
▲
dopo il remove, le scatole che seguono scivolano indietro di un posto
┌───────┬──────────┬───────┐
│ "M12" │ "guasto" │ "M16" │ il secondo "guasto" ora è nella
└───────┴──────────┴───────┘ scatola 1: lì il dito è già passato
giro 3 il dito passa alla scatola 2
┌───────┬──────────┬───────┐
│ "M12" │ "guasto" │ "M16" │ "M16": niente da fare
└───────┴──────────┴───────┘
▲
giro 4 la scatola 3 non c'è più: il ciclo finisceLa correzione. Non togliere: costruisci. Un setaccio in una lista nuova, e la lista di partenza resta intera.
funzionanti = []
for treno in treni:
if treno != "guasto":
funzionanti.append(treno)Con treni = ["M12", "guasto", "guasto", "M16"], funzionanti vale ['M12', 'M16'].
Cosa portiamo a casa. Prima di cambiare una lista, chiediti: è mia? Se te l'hanno passata, o la stai scorrendo, non toccarla: sorted e una lista nuova.
Pronto? Gli stessi schemi ti aspettano nella palestra: otto esercizi da scaricare, con i test.