Il debugger, esercizi spiegati
Cinque esempi, uno strumento alla volta
- 20 minuti di lettura
Cinque esempi, ognuno con uno strumento del debugger. Lo stesso ritmo di sempre:
- Prevedi: leggi il programma e scrivi su un foglio cosa ti aspetti di vedere, prima di aprire la risposta.
- In italiano: cosa fa il programma, e dove ci fermiamo.
- Passo per passo: cosa mostrano i pannelli, fermata per fermata.
- Cosa portiamo a casa: la cosa da ricordare.
Per provarli, copia il programma in un file .py dentro la cartella dello zip del capitolo (così hai già il launch.json), mettiti dentro il file e premi F5. I valori che trovi qui vengono da un debugger vero: se i tuoi sono uguali, hai fatto bene.
A · Il primo breakpoint
Il programma somma i metri di quattro tratte. È quello della teoria.
TRATTE = [("Porta Codice", 2400), ("Via Variabile", 1800), ("Largo Lista", 3100), ("Ponte Ciclo", 2000)]
metri = 0
for stazione, distanza in TRATTE:
metri = metri + distanza
print("Linea Menta, tratta di prova:", metri, "metri")Metti il pallino rosso sulla riga metri = metri + distanza (la riga 5) e premi F5. Poi F5 ancora, a ogni fermata.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Quante volte si ferma? Quattro: una per ogni giro del for. E quanto vale metri a ogni fermata, guardando VARIABLES?
fermata 1: metri = 0
fermata 2: metri = 2400
fermata 3: metri = 4200
fermata 4: metri = 7300Alla prima fermata metri vale 0, non 2400: la riga gialla non è ancora stata eseguita. Il 9300 arriva solo alla fine, nel TERMINAL, quando dopo la quarta fermata premi F5 e il programma finisce.
In italiano. Il pallino sta dentro il ciclo, quindi il programma si ferma una volta per giro, sempre prima di aggiungere la distanza.
Passo per passo. A ogni fermata trovi in VARIABLES questi tre valori:
| Fermata | stazione | distanza | metri (prima della riga gialla) | metri (dopo, alla fermata dopo) |
|---|---|---|---|---|
| 1 | 'Porta Codice' | 2400 | 0 | 2400 |
| 2 | 'Via Variabile' | 1800 | 2400 | 4200 |
| 3 | 'Largo Lista' | 3100 | 4200 | 7300 |
| 4 | 'Ponte Ciclo' | 2000 | 7300 | 9300 |
Guarda le due ultime colonne: sono la stessa colonna, spostata di un giro. Il valore «dopo» di una fermata è il valore «prima» della successiva.
Cosa portiamo a casa. In VARIABLES leggi sempre lo stato di prima. Per sapere cosa succede dopo la riga gialla, o la esegui (F10) o ti fai la domanda in WATCH.
B · F10 dentro un if
Il capotreno conta i ritardi gravi (dieci minuti o più) e quelli lievi.
RITARDI = [2, 11, 4, 15]
gravi = 0
lievi = 0
for minuti in RITARDI:
if minuti >= 10:
gravi = gravi + 1
else:
lievi = lievi + 1
print("Gravi:", gravi, "· lievi:", lievi)Questa volta il pallino va sulla riga del for (la riga 5). Premi F5: si ferma. Poi premi F10, una riga alla volta, e guarda dove va la riga gialla.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Nel secondo giro minuti vale 11. Che strada fa la riga gialla? Dal for (riga 5) all'if (riga 6), poi dentro il primo ramo (riga 7), e di nuovo al for. La riga 9, quella dell'else, viene saltata: non diventa mai gialla.
Nel primo giro, con minuti = 2, è il contrario: riga 5, riga 6, riga 9, riga 5.
In italiano. F10 esegue la riga gialla e passa alla successiva. L'if ha due rami, e ne vedi uno solo per giro: quello che la riga gialla sceglie. È il modo più rapido per sapere quale ramo prende un if, senza aggiungere nessun print.
Il disegno.
Passo per passo. Le prime righe gialle dei primi due giri:
| Premi F10 | Riga gialla | minuti | gravi | lievi |
|---|---|---|---|---|
| (F5, parte e si ferma) | 5 for | — | 0 | 0 |
| 1 | 6 if | 2 | 0 | 0 |
| 2 | 9 lievi = … | 2 | 0 | 0 |
| 3 | 5 for | 2 | 0 | 1 |
| 4 | 6 if | 11 | 0 | 1 |
| 5 | 7 gravi = … | 11 | 0 | 1 |
| 6 | 5 for | 11 | 1 | 1 |
Due cose da notare. Quando la riga gialla torna sul for, minuti vale ancora il valore del giro appena finito: cambia solo dopo, quando il for ha eseguito. E lievi passa da 0 a 1 dopo la riga 9, non durante: di nuovo la riga gialla non ancora eseguita.
Cosa portiamo a casa. F10 è un print della strada che il programma prende: ti fa vedere quali righe girano e quali no.
C · F10 contro F11
Una funzione che arrotonda il ritardo al multiplo di cinque minuti più basso, per il tabellone.
def arrotonda(minuti):
resto = minuti % 5
return minuti - resto
previsto = 7
reale = 13
ritardo = reale - previsto
ritardo_tabellone = arrotonda(ritardo)
print("Sul tabellone:", ritardo_tabellone, "minuti")Pallino sulla riga 8 (ritardo = reale - previsto), F5, e F10 fino alla riga 9, la chiamata. Ora ci sono due strade: F10 o F11.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
- F10: la riga gialla va alla riga 10.
arrotondaha lavorato, ma tu non l'hai visto. - F11: la riga gialla entra nella funzione, sulla riga 2. VARIABLES cambia: non vedi più
previstoereale, maminutie (dopo un passo)resto.
In italiano. La riga 9 contiene una chiamata a una funzione tua. F10 la considera una riga come le altre, e la esegue tutta. F11 ti ci porta dentro.
Passo per passo. Entrando con F11, poi F11 ancora:
| Premi | Riga gialla | Dove sei | Cosa vedi in VARIABLES |
|---|---|---|---|
| F11 sulla riga 9 | 2 | dentro arrotonda | minuti = 6 |
| F11 | 3 | dentro arrotonda | minuti = 6, resto = 1 |
E il CALL STACK adesso ha due righe:
CALL STACK
arrotonda partenza.py 3
<module> partenza.py 9In cima c'è dove sei, sotto chi ti ha chiamato. minuti vale 6 (il ritardo vero: 13 meno 7), resto vale 1, e il valore che esce da arrotonda è 6 - 1, cioè 5: il tabellone dice 5. Ti basta Shift+F11 per uscire e tornare nel programma.
Cosa portiamo a casa. F10 per saltare una funzione di cui ti fidi, F11 per guardare dentro quella di cui dubiti. Se il pallino sta già dentro la funzione, non serve nemmeno entrare: F5 ti ci porta.
D · WATCH, la domanda in sospeso
Il tabellone cerca l'orario di ogni treno che arriva. Un treno compare in tabella, uno no.
ORARI = {"M12": "06:10", "M14": "06:25", "M16": "06:40"}
ARRIVI = ["M12", "m16", "M14"]
for codice in ARRIVI:
if codice in ORARI:
print(codice, "parte alle", ORARI[codice])
else:
print(codice, "non è in tabella")M12 parte alle 06:10
m16 non è in tabella
M14 parte alle 06:25Il treno M16 c'è in ORARI. Perché dice «non è in tabella»? Pallino sulla riga 5 (if codice in ORARI:), F5. Nel pannello WATCH aggiungi due domande: codice in ORARI e codice.upper() in ORARI.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Alla seconda fermata il codice è 'm16', con la m minuscola. La prima domanda risponde False: per Python m16 e M16 sono due testi diversi. La seconda, con .upper() (tutto maiuscolo), risponde True: il treno è quello, ma scritto in minuscolo.
Il disegno. Le variabili alla seconda fermata:
In italiano. Non ci serve guardare tutto: ci serve sapere, a ogni giro, se la chiave c'è e se c'è mettendo a posto le maiuscole. Sono due domande, e le scriviamo una volta sola in WATCH.
Passo per passo.
| Fermata | codice | codice in ORARI | codice.upper() in ORARI |
|---|---|---|---|
| 1 | 'M12' | True | True |
| 2 | 'm16' | False | True |
| 3 | 'M14' | True | True |
Il giro sbagliato è il 2: le due domande litigano. Dove due domande danno risposte diverse c'è il dato sporco.
Cosa portiamo a casa. In WATCH puoi provare la correzione prima di scriverla nel codice: se codice.upper() in ORARI dà True, sai già che .upper() risolve.
E · F5 senza breakpoint, e la DEBUG CONSOLE
Il tabellone dei binari. Questa volta il programma si rompe.
BINARI = {"M12": 1, "M14": 2, "M16": 1}
IN_ARRIVO = ["M14", "M12", "M22", "M16"]
for treno in IN_ARRIVO:
print("Il", treno, "arriva al binario", BINARI[treno])
print("Annunci finiti")Non metti nessun pallino: apri il file e premi F5.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Il programma annuncia i primi due treni, poi si ferma sul terzo.
Il M14 arriva al binario 2
Il M12 arriva al binario 1
Traceback (most recent call last):
File "/home/lucia/linea-menta/binari.py", line 5, in <module>
print("Il", treno, "arriva al binario", BINARI[treno])
~~~~~~^^^^^^^
KeyError: 'M22'In VS Code vedi una cosa in più: la riga 5 diventa gialla, e un riquadro dice KeyError: 'M22'.
In italiano. Il traceback ti dice che M22 non è in BINARI. Ma non ti dice come mai sei arrivato a cercarlo: è in coda alla lista, o è l'unico che manca? Con F5 senza pallino il programma resta fermo sull'errore, e puoi farti domande.
Passo per passo. In VARIABLES hai treno = 'M22':
Poi nella DEBUG CONSOLE, in basso, scrivi una riga alla volta e premi Invio:
> treno in BINARI
False
> list(BINARI)
['M12', 'M14', 'M16']
> IN_ARRIVO.index(treno)
2
> IN_ARRIVO[:IN_ARRIVO.index(treno)]
['M14', 'M12']treno in BINARIconferma: la chiave non c'è.list(BINARI)mostra quali ce ne sono: tre treni.IN_ARRIVO.index(treno)dice che è il terzo della lista (posizione 2, si conta da 0).- L'ultima è la lista dei treni già annunciati:
M14eM12. Corrisponde a quello che il programma ha stampato.
Adesso sai che non è un bug del programma: il tabellone dei binari non conosce M22. Se quel treno può davvero arrivare, è una situazione prevista e si gestisce, come vedi in Correggere o gestire.
Cosa portiamo a casa. Il traceback ti dice cosa e dove. Il debugger fermo sull'errore ti dice anche con quali valori, e la DEBUG CONSOLE ti lascia chiedere il resto.