Il debugger
Fermare il programma per guardarci dentro
- 10 minuti di lettura
Fino a qui hai letto quello che Python ti dice quando si rompe: il traceback, il nome dell'errore. Ma il guaio peggiore è un altro: il programma gira fino in fondo, non dà nessun errore, e il numero che stampa è sbagliato.
Come lo trovi? Puoi riempire il codice di print. Oppure puoi usare il tasto pausa: il debugger ferma il programma su una riga che scegli tu, e ti fa guardare dentro tutte le variabili, in quel momento. Poi lo fai andare avanti una riga alla volta.
Il debugger è dentro VS Code, e non c'è niente da installare oltre a quello che hai già: se non lo hai fatto, le estensioni e l'interprete sono in VS Code.
Come programma di prova usiamo questo. Somma i metri di quattro tratte della Linea Menta.
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")Linea Menta, tratta di prova: 9300 metriIl disegno: il programma fermo
Ecco cosa vedi in VS Code quando il programma è fermo alla terza fermata del for. Non ci sono screenshot: lo disegniamo.
3 metri = 0
4 for stazione, distanza in TRATTE:
●▶ 5 metri = metri + distanza ← la riga gialla: non ancora eseguita
6 print("Linea Menta, tratta di prova:", metri, "metri")
VARIABLES
metri = 4200
stazione = 'Largo Lista'
distanza = 3100
CALL STACK
<module> metri.py 5Il disegno. Le variabili in quel momento, prima della riga gialla:
- Il pallino rosso
●è il breakpoint: lo hai messo tu, cliccando a sinistra del numero di riga. - La freccia
▶sulla riga evidenziata di giallo dice dove si è fermato. - Il pannello VARIABLES elenca le etichette e i loro valori, in quel preciso momento.
Prima di tutto: launch.json
Il debugger ha bisogno di sapere cosa lanciare. Lo dice un file piccolo, .vscode/launch.json: la configurazione di lancio.
Nello zip di ogni capitolo c'è già. Se un giorno lo dovessi creare da solo, VS Code lo fa per te:
- apri Run and Debug (il triangolo con l'insetto, nella barra a sinistra);
- clicca create a launch.json file;
- scegli Python Debugger;
- scegli Python File.
Il file che ottieni è questo, con il nome che abbiamo scelto noi:
{
"version": "0.2.0",
"configurations": [
{
"name": "Il file aperto",
"type": "debugpy",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal"
}
]
}| Riga | Vuol dire |
|---|---|
"name": "Il file aperto" | Il nome che vedi nel menu di Run and Debug. Lo scegli tu |
"type": "debugpy" | Il debugger di Python |
"request": "launch" | Lancia un programma (non agganciarti a uno già acceso) |
"program": "${file}" | Il programma è il file in primo piano: quello su cui hai cliccato per ultimo |
"console": "integratedTerminal" | I print escono nel TERMINAL di VS Code, come quando lanci tu |
Per questo, prima di F5, clicca dentro il file che vuoi fermare. Se il file in primo piano è un altro, parte quello.
Il breakpoint e F5
- Apri il file e clicca a sinistra del numero della riga dove vuoi fermarti: compare il pallino rosso. Un altro clic lo toglie.
- Premi F5 (sul Mac,
fn+F5; oppure il triangolo verde in alto). - Il programma parte e si ferma prima di eseguire la riga col pallino. Quella riga diventa gialla.
Il pallino va su una riga che viene eseguita: se la metti su una riga vuota o su un commento, il programma non si ferma mai e arriva in fondo.
Nel for il pallino sulla riga metri = metri + distanza ferma il programma a ogni giro: quattro giri, quattro fermate. Con F5 vai alla prossima.
I sei pulsanti
Compaiono in alto, in una barra, appena il debugger parte.
| Pulsante | Nome | Tasto | Cosa fa |
|---|---|---|---|
| ▶ | Continue | F5 | Va avanti fino al prossimo breakpoint, o fino in fondo |
| ↷ | Step Over | F10 | Esegue una riga e si ferma sulla successiva. Una funzione chiamata la esegue tutta d'un colpo |
| ↓ | Step Into | F11 | Come F10, ma se la riga chiama una tua funzione, entra dentro e si ferma sulla sua prima riga |
| ↑ | Step Out | Shift+F11 | Finisce la funzione in cui sei e torna a chi l'ha chiamata |
| ↻ | Restart | Ctrl+Shift+F5 | Ferma e riparte da capo (sul Mac Cmd+Shift+F5) |
| ■ | Stop | Shift+F5 | Chiude il debugger |
Sul Mac i tasti F sono spesso del volume e della luminosità: usa fn+F10, fn+F11, oppure clicca i pulsanti. Su Windows con WSL sono F10 e F11 normali.
La coppia da ricordare è F10 e F11. Stessa riga, due scelte:
ritardo_tabellone = arrotonda(ritardo)- F10: non mi interessa come lavora
arrotonda, vado alla riga dopo. - F11: voglio vedere cosa succede dentro
arrotonda. Entro.
Se sei entrato dove non serviva, Shift+F11 ti riporta fuori.
VARIABLES
Il pannello che hai già visto. Elenca le variabili del posto in cui sei fermo: dentro una funzione vedi quelle della funzione, nel programma principale quelle del programma.
Si leggono con tre occhi:
- il valore:
metri = 4200; - il tipo, dalle virgolette:
'0'con gli apici è un testo,0senza è un numero. Sembrano uguali, per Python no; - gli spazi nascosti:
'B-07 'ha uno spazio in fondo, che a occhio non vedi nelprinte qui sì.
Le liste e i dizionari si aprono con la freccetta a sinistra, e vedi cosa c'è dentro.
WATCH: la domanda che ti fai
VARIABLES mostra tutto. WATCH mostra solo quello che chiedi tu, e lo ricalcola a ogni fermata. Si scrive una domanda in Python:
- nel pannello WATCH clicca il segno +;
- scrivi un'espressione, per esempio
distanza > 3000oppurelen(TRATTE); - premi Invio. A ogni fermata trovi la risposta aggiornata.
Qualche domanda che torna sempre:
| In WATCH scrivi | Per sapere |
|---|---|
codice in orari | se quel codice è una chiave del dizionario |
len(coda) | quanti elementi ha la lista a questo giro |
metri + distanza | cosa varrebbe metri dopo la riga gialla |
type(ritardo) | se è un numero o un testo |
Una domanda che dà un errore (per esempio un nome che non esiste ancora) non rompe niente: WATCH scrive l'errore accanto e va avanti.
DEBUG CONSOLE: Python dal vivo
In basso, accanto al TERMINAL, c'è la DEBUG CONSOLE. Quando il programma è fermo, ci scrivi una riga di Python e premi Invio: risponde subito, con i valori di quel momento.
> distanza
3100
> metri + distanza
7300
> len(TRATTE)
4È WATCH con la tastiera: una domanda al volo, senza lasciarla appesa. Serve solo a programma fermo: se il programma è arrivato in fondo non c'è più niente da chiedere.
CALL STACK: dove sei
Il pannello CALL STACK dice in quale funzione sei e chi ti ha chiamato. In cima c'è il posto dove sei fermo, sotto chi l'ha chiamato, in fondo il programma principale (<module>). Per ora ti basta guardare la prima riga. Torna utile quando entri con F11: vedi la funzione sopra e il programma sotto, e con un clic sul programma torni a guardare le sue variabili.
F5 senza breakpoint: si ferma sull'errore
Un'ultima cosa utile. Se il programma si rompe, non serve il pallino: lancia con F5 e basta. Il debugger si ferma sulla riga dove è successo, con un riquadro che dice il nome dell'errore.
Non vedi solo il traceback: vedi anche VARIABLES nel momento in cui è esploso. Quale stazione stava elaborando? Che valore aveva quel codice? Le risposte sono lì, e puoi farti altre domande nella DEBUG CONSOLE.
Il metodo
Il debugger non trova il bug al posto tuo: ti fa vedere cosa succede davvero. Il gesto è sempre lo stesso:
- Prevedi. Prima di premere F10 o F5, dì a mente cosa ti aspetti.
- Guarda. VARIABLES, WATCH.
- Confronta. Il bug sta nel punto in cui quello che vedi non coincide con quello che prevedevi.
Il metodo completo, per i bug che non danno nessun errore, lo vedi in I bug silenziosi. E il debugger dentro una richiesta di FastAPI e nei test è in Il debugger su FastAPI e nei test.
Ricorda
- Il pallino rosso ferma il programma prima di eseguire la riga: la riga gialla non è ancora stata eseguita.
launch.jsondice cosa lanciare; con"program": "${file}"parte il file in primo piano.- F5 va avanti, F10 una riga (salta le funzioni), F11 entra nella funzione, Shift+F11 ne esce.
- VARIABLES mostra tutto, WATCH solo la domanda che scegli tu, DEBUG CONSOLE risponde a una domanda al volo.
- Con le virgolette un valore è un testo, senza è un numero; gli spazi nascosti si vedono solo qui.
- F5 senza breakpoint su un programma che si rompe: si ferma sull'errore, con le variabili di quel momento.