Leggere i messaggi di errore e un piccolo progetto

Un traceback di Python si legge dal fondo: l'ultima riga indica l'errore e la riga di codice subito sopra mostra dove si è verificato.

Una falena incollata in un registro nel 1947

Oggi la maggior parte dei bug sono errori nel codice, e Python sa segnalarti quelli che riesce a rilevare. I principianti spesso vedono un errore rosso come un verdetto. È più vicino a una bolla di consegna: che cosa è andato storto, su quale riga, e in quale pezzo di codice. Il trucco è sapere dove guardare.

Leggi un traceback dal fondo verso l'alto

total = 0
count = 0
print(total / count)

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    print(total / count)
          ~~~~~~^~~~~~~
ZeroDivisionError: division by zero

Parti dall'ultima riga. ZeroDivisionError: division by zero dà il tipo di errore e una breve spiegazione. Poi sali alla riga File: il nome del file (sul tuo computer compare il percorso completo della cartella; qui è abbreviato in main.py) e il numero di riga, 3. La riga sotto è il codice stesso, e Python 3.12 segna l'operazione esatta che è fallita con ^ sotto il segno /. Solo dopo aver letto tutte e tre dovresti cominciare a cambiare le cose. Quando l'errore avviene dentro una funzione, il traceback elenca ogni chiamata fatta per arrivarci, e la riga File più in basso è di solito quella da guardare per prima.

Un SyntaxError è diverso dagli altri. Python lo trova prima di eseguire qualsiasi cosa, quindi non viene eseguita nemmeno la riga 1, e non c'è l'intestazione «Traceback». Tutti gli altri avvengono mentre il programma gira, dopo che le righe precedenti hanno già fatto il loro lavoro. Quando ti aspetti un particolare errore, puoi catturarlo con try ed except, che il tutorial tratta nel suo capitolo sugli errori: Python prova il blocco rientrato, e se quell'errore avviene, esegue il blocco except invece di fermarsi.

print("before")
n = int("abc")
print("after")

before
Traceback (most recent call last):
  File "main.py", line 2, in <module>
    n = int("abc")
        ^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

text = "abc"
try:
    n = int(text)
except ValueError:
    n = 0
print(n)

0

Gli errori più difficili non danno alcun messaggio. Un errore logico è un programma che gira e stampa la risposta sbagliata, come il programma di valutazione dell'unità sull'if che dava una C a 85. Python non può sapere che cosa intendevi. Per questi, torna alla tabella di traccia, oppure aggiungi righe print temporanee che mostrano le variabili a ogni passo, poi toglile quando il bug è trovato.

Piccolo progetto: un registro della paghetta

Il progetto usa qualcosa da quasi ogni unità: un dizionario delle spese, una funzione che restituisce un totale, un ciclo for, una f-string e un if. Scrivilo, eseguilo, poi rendilo tuo: cambia le voci, aggiungi una categoria, o avvisa quando una singola voce costa più di metà della paghetta.

def total(spent):
    t = 0
    for amount in spent.values():
        t += amount
    return t

allowance = 30000
spent = {"snacks": 4500, "bus card": 10000, "notebook": 2500}
used = total(spent)
left = allowance - used
for item, amount in spent.items():
    print(f"{item}: {amount} won")
print(f"Spent {used}, left {left}")
if left < 15000:
    print("Less than half left")

snacks: 4500 won
bus card: 10000 won
notebook: 2500 won
Spent 17000, left 13000
Less than half left

Prima di cambiarlo, scrivi una tabella di traccia per used e left, e prevedi che cosa succede se aggiungi una voce da 6000 won. Poi fai debug di proposito: cancella i due punti dopo la riga def, sbaglia una volta a scrivere spent e dividi used per zero. Leggi ogni traceback dal fondo prima di correggere. Saper rompere un programma e aggiustarlo di nuovo è la vera abilità che questo corso ha costruito.