Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger5. Il debuggerp. 116

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:

  1. Prevedi: leggi il programma e scrivi su un foglio cosa ti aspetti di vedere, prima di aprire la risposta.
  2. In italiano: cosa fa il programma, e dove ci fermiamo.
  3. Passo per passo: cosa mostrano i pannelli, fermata per fermata.
  4. 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.

Python
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 = 7300

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

Fermatastazionedistanzametri (prima della riga gialla)metri (dopo, alla fermata dopo)
1'Porta Codice'240002400
2'Via Variabile'180024004200
3'Largo Lista'310042007300
4'Ponte Ciclo'200073009300

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.

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

inizio gravi = 0, lievi = 0 per ogni minuti in RITARDI se minuti >= 10 sì: gravi = gravi + 1 no: lievi = lievi + 1 mostra print(gravi, lievi)gravi = 0, lievi = 0per ogni minuti in RITARDIminuti >= 10lievi = lievi + 1gravi = gravi + 1mostra print(gravi, lievi)nosìfiniti
Il giro del for con l'if

Passo per passo. Le prime righe gialle dei primi due giri:

Premi F10Riga giallaminutigravilievi
(F5, parte e si ferma)5 for—00
16 if200
29 lievi = …200
35 for201
46 if1101
57 gravi = …1101
65 for1111

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.

Python
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. arrotonda ha lavorato, ma tu non l'hai visto.
  • F11: la riga gialla entra nella funzione, sulla riga 2. VARIABLES cambia: non vedi più previsto e reale, ma minuti e (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:

PremiRiga giallaDove seiCosa vedi in VARIABLES
F11 sulla riga 92dentro arrotondaminuti = 6
F113dentro arrotondaminuti = 6, resto = 1

E il CALL STACK adesso ha due righe:

CALL STACK
  arrotonda   partenza.py   3
  <module>    partenza.py   9

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

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

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

ORARI = {"M12": "06:10", "M14": "06:25", "M16": "06:40"} ARRIVI = ["M12", "m16", "M14"] codice = "m16"ORARIARRIVIcodicedict"M12""06:10""M14""06:25""M16""06:40"list"M12"0"m16"1"M14"2str"m16"
VARIABLES 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.

Fermatacodicecodice in ORARIcodice.upper() in ORARI
1'M12'TrueTrue
2'm16'FalseTrue
3'M14'TrueTrue

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.

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

BINARI = {"M12": 1, "M14": 2, "M16": 1} IN_ARRIVO = ["M14", "M12", "M22", "M16"] treno = "M22"BINARIIN_ARRIVOtrenodict"M12"1"M14"2"M16"1list"M14"0"M12"1"M22"2"M16"3str"M22"
VARIABLES quando il programma si ferma sull'errore

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 BINARI conferma: 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: M14 e M12. 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.