Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Python4. Liste e ciclip. 97

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:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
  2. In italiano: cosa fa il programma, a parole.
  3. Passo per passo: cosa c'è nelle scatole a ogni giro.
  4. 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.

Python
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, -2 la 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.

Python
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.

Rigacoda dopo la rigaCosa è 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
coda = ["M12", "M16"] uscito = "M10"codauscitolist"M12"0"M16"1str"M10"
Alla fine

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?

Python
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.

inizio saliti = [12, 0, 7, 3] totale = 0 senza_nessuno = 0 per ogni quanti in saliti totale = totale + quanti se quanti == 0 sì: senza_nessuno = senza_nessuno + 1 mostra print(totale, senza_nessuno)saliti = [12, 0, 7, 3]totale = 0senza_nessuno = 0per ogni quanti in salititotale = totale + quantiquanti == 0senza_nessuno =senza_nessuno + 1mostra print(totale,senza_nessuno)nosìfiniti
Il totale e i treni vuoti
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
22 1

In italiano.

  1. Prima del ciclo, i due conti partono da zero.
  2. A ogni treno, aggiungo i suoi passeggeri al totale.
  3. Se non è salito nessuno, aggiungo uno al conto dei treni «senza nessuno».
  4. Dopo il ciclo, stampo i due conti.

Passo per passo.

Giroquantitotale dopo il giroquanti == 0?senza_nessuno dopo il giro
prima—0—0
1120 + 12 = 12no0
2012 + 0 = 12sì1
3712 + 7 = 19no1
4319 + 3 = 22no1

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.

Python
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:

inizio presto = [] per ogni minuti in attese se minuti <= 5 sì: presto.append(minuti) mostra print(presto)presto = []per ogni minuti in atteseminuti <= 5presto.append(minuti)mostra print(presto)nosìfiniti
Il setaccio dei treni vicini

Passo per passo, il setaccio:

Girominutiminuti <= 5?presto dopo il giro
prima——[]
14sì[4]
212no[4]
32sì[4, 2]
49no[4, 2]
attese = [4, 12, 2, 9] presto = [4, 2]atteseprestolist401212293list4021
Dopo il setaccio

Lo stesso, con la comprehension. Le quattro righe di ogni ciclo diventano una:

Python
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.

Python
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 51

In italiano.

  1. Il più pieno, per ora, è il primo vagone: 34 passeggeri, vagone 1.
  2. Per ogni vagone, con il suo numero:
  3. se ha più passeggeri del più pieno visto finora, diventa lui il più pieno, e mi segno il suo numero.

Il disegno.

inizio piu_pieno = vagoni[0] quale = 1 per ogni numero, passeggeri in enumerate(vagoni, start=1) se passeggeri > piu_pieno sì: piu_pieno = passeggeri quale = numero mostra print(quale, piu_pieno)piu_pieno = vagoni[0]quale = 1per ogni numero, passeggeriin enumerate(vagoni,start=1)passeggeri >piu_pienopiu_pieno = passeggeriquale = numeromostra print(quale,piu_pieno)nosìfiniti
Il vagone più pieno

Passo per passo.

GironumeropasseggeriConfrontopiu_pieno dopoquale dopo
prima———341
113434 > 34? no341
225151 > 34? sì512
334747 > 51? no512
445151 > 51? no512

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.

Python
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 chiusura

In 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.

Girovagone, liberiliberi > 0?Cosa succede
1"A", 0nosi va avanti
2"B", 0nosi va avanti
3"C", 6sì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.

Python
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]
  • sorted costruisce una lista nuova in ordine: ritardi resta com'era.
  • .sort() mette in ordine proprio ritardi, e non restituisce niente: risultato vale None.

E adesso i guasti. Vogliamo togliere dalla lista tutti i "guasto".

Python
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 finisce

La correzione. Non togliere: costruisci. Un setaccio in una lista nuova, e la lista di partenza resta intera.

Python
funzionanti = []
for treno in treni:
    if treno != "guasto":
        funzionanti.append(treno)

Con treni = ["M12", "guasto", "guasto", "M16"], funzionanti vale ['M12', 'M16'].

treni = ["M12", "guasto", "guasto", "M16"] funzionanti = ["M12", "M16"]trenifunzionantilist"M12"0"guasto"1"guasto"2"M16"3list"M12"0"M16"1
Dopo la correzione

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.