Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger5. Il debuggerp. 110

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.

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")
Linea Menta, tratta di prova: 9300 metri

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

Il disegno. Le variabili in quel momento, prima della riga gialla:

TRATTE = [("Porta Codice", 2400), ("Via Variabile", 1800), ("Largo Lista", 3100), ("Ponte Ciclo", 2000)] metri = 4200 stazione = "Largo Lista" distanza = 3100TRATTEmetristazionedistanzalist0123tuple"Porta Codice"024001tuple"Via Variabile"018001tuple"Largo Lista"031001tuple"Ponte Ciclo"020001int4200str"Largo Lista"int3100
Le variabili alla terza fermata, 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:

  1. apri Run and Debug (il triangolo con l'insetto, nella barra a sinistra);
  2. clicca create a launch.json file;
  3. scegli Python Debugger;
  4. scegli Python File.

Il file che ottieni è questo, con il nome che abbiamo scelto noi:

JSON
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Il file aperto",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        }
    ]
}
RigaVuol 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

  1. Apri il file e clicca a sinistra del numero della riga dove vuoi fermarti: compare il pallino rosso. Un altro clic lo toglie.
  2. Premi F5 (sul Mac, fn+F5; oppure il triangolo verde in alto).
  3. 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.

PulsanteNomeTastoCosa fa
▶ContinueF5Va avanti fino al prossimo breakpoint, o fino in fondo
↷Step OverF10Esegue una riga e si ferma sulla successiva. Una funzione chiamata la esegue tutta d'un colpo
↓Step IntoF11Come F10, ma se la riga chiama una tua funzione, entra dentro e si ferma sulla sua prima riga
↑Step OutShift+F11Finisce la funzione in cui sei e torna a chi l'ha chiamata
↻RestartCtrl+Shift+F5Ferma e riparte da capo (sul Mac Cmd+Shift+F5)
■StopShift+F5Chiude 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:

Python
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, 0 senza è un numero. Sembrano uguali, per Python no;
  • gli spazi nascosti: 'B-07 ' ha uno spazio in fondo, che a occhio non vedi nel print e 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:

  1. nel pannello WATCH clicca il segno +;
  2. scrivi un'espressione, per esempio distanza > 3000 oppure len(TRATTE);
  3. premi Invio. A ogni fermata trovi la risposta aggiornata.

Qualche domanda che torna sempre:

In WATCH scriviPer sapere
codice in orarise quel codice è una chiave del dizionario
len(coda)quanti elementi ha la lista a questo giro
metri + distanzacosa 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:

  1. Prevedi. Prima di premere F10 o F5, dì a mente cosa ti aspetti.
  2. Guarda. VARIABLES, WATCH.
  3. 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.json dice 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.