Cos'è la gestione delle eccezioni?

Un programma che chiede l'età alle persone prima o poi riceverà "twenty" invece di 20. Convertire quel testo è un errore di runtime: int("twenty") solleva ValueError, e senza un piano per gestirlo il programma si ferma. La gestione delle eccezioni è quel piano. Delimiti il codice che potrebbe fallire e scrivi il codice da eseguire se succede.

answers = ["34", "twenty", "19"]

for text in answers:
    try:
        age = int(text)
        print("Next year you will be", age + 1)
    except ValueError:
        print("Not a number:", text)

print("Done")

Next year you will be 35
Not a number: twenty
Next year you will be 20
Done

La risposta sbagliata viene segnalata, e il ciclo prosegue con la successiva. Senza il try, il programma avrebbe stampato una riga e poi un traceback.

Come funziona la gestione delle eccezioni

1. Il codice dentro try viene eseguito normalmente.
2. Un'operazione fallisce, e il runtime solleva un'eccezione: un oggetto con un tipo (ValueError) e un messaggio (invalid literal for int() with base 10: 'twenty').
3. Il blocco try si ferma a quella riga. Le righe rimanenti vengono saltate, ed è per questo che "Next year you will be" non viene stampato per "twenty".
4. Il runtime confronta il tipo dell'eccezione con ogni clausola except, dall'alto verso il basso, ed esegue la prima che corrisponde.
5. Quando il gestore finisce, il programma continua dalla prima riga dopo l'intera istruzione try.
6. Se nessuna clausola corrisponde, l'eccezione esce dalla funzione corrente e la ricerca continua nella funzione che l'ha chiamata, poi in quella che ha chiamato quest'ultima. Si chiama svolgimento dello stack delle chiamate (stack unwinding). Se la ricerca arriva in cima al programma senza trovare corrispondenze, il programma termina con un traceback.

Il passo 6 significa che il gestore non deve per forza trovarsi nella funzione in cui avviene l'errore. Qui il fallimento avviene due chiamate più in profondità, e il gestore in fondo lo cattura comunque:

def parse_price(text):
    print("parsing", text)
    return float(text)

def total(prices):
    result = 0
    for p in prices:
        result += parse_price(p)
    return result

try:
    print(total(["4.50", "free", "3.20"]))
except ValueError as error:
    print("Could not add the prices:", error)

parsing 4.50
parsing free
Could not add the prices: could not convert string to float: 'free'

float("free") è fallito dentro parse_price. Né parse_price né total avevano un gestore, quindi sono state abbandonate entrambe, e "3.20" non è mai stato analizzato. Questa è la principale scelta di progettazione che la gestione delle eccezioni ti offre: gestire un errore dove sai cosa farne, che spesso è lontano da dove è successo.

try, except, else e finally

L'istruzione try di Python ha altre due parti facoltative. else viene eseguito solo quando il blocco try è terminato senza eccezioni. finally viene eseguito in ogni caso: dopo un successo, dopo un'eccezione gestita, e perfino quando la funzione fa return dall'interno del try.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("b was zero")
        return None
    else:
        print("no error")
        return result
    finally:
        print("finally runs either way")

print(divide(6, 3))
print(divide(6, 0))

no error
finally runs either way
2.0
b was zero
finally runs either way
None

finally è il posto per il codice di pulizia: chiudere un file, rilasciare un lock, chiudere una connessione al database. In Python l'istruzione with fa questa pulizia automaticamente per i file, ed è la scelta abituale in quel caso.

Sollevare eccezioni proprie

Le eccezioni non servono solo per gli errori che il linguaggio rileva. Quando una tua funzione riceve un input con cui non può lavorare, può sollevare un'eccezione per rifiutarlo, e chi la chiama decide cosa succede dopo. Definire una piccola classe di eccezione dà all'errore un nome che lo descrive.

class InsufficientFunds(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"cannot take {amount}, balance is {balance}")
    return balance - amount

print(withdraw(100, 30))

try:
    withdraw(100, 250)
except InsufficientFunds as error:
    print("Refused:", error)

70
Refused: cannot take 250, balance is 100

Python usa raise. Java, C++ e JavaScript usano throw per la stessa cosa.

La gestione delle eccezioni in altri linguaggi

Lo stesso esempio di conversione in Java è così:

try {
    int age = Integer.parseInt("twenty");
    System.out.println(age + 1);
} catch (NumberFormatException e) {
    System.out.println("Not a number: " + e.getMessage());
} finally {
    System.out.println("done");
}

Java divide le eccezioni in due gruppi. Le eccezioni controllate (checked), come IOException, descrivono problemi fuori dal controllo del programma, e il compilatore si rifiuta di compilare codice che non le cattura né le dichiara. Le eccezioni non controllate (unchecked), sottoclassi di RuntimeException come NullPointerException, di solito indicano un bug, e il compilatore non ti obbliga a gestirle.

Errori comuni

• Catturare tutto. Un except: senza tipo in Python cattura anche KeyboardInterrupt, quindi Ctrl+C smette di funzionare, e except Exception: cattura bug che non avevi mai previsto. Cattura il tipo specifico che sai come gestire.
• Ingoiare l'errore. except ValueError: pass nasconde il problema. Come minimo, stampa o registra cosa è andato storto.
• Un blocco try troppo grande. Avvolgi solo le righe che possono sollevare l'eccezione che stai catturando, così un errore che non c'entra non viene gestito per sbaglio.
• Catturare i bug invece di correggerli. Un IndexError causato da un ciclo che fa un passo di troppo è un errore nel codice. Gestirlo tiene in vita il codice sbagliato.
• Aspettarsi che catch fermi un crash in C o C++. Un segmentation fault è un segnale del sistema operativo, non un'eccezione, e su Linux e macOS un catch (...) di C++ non lo vede mai.

Cosa leggere dopo

Gli errori a cui risponde la gestione delle eccezioni sono descritti nella pagina sull'errore di runtime, e il crash che non può catturare nella pagina sul segmentation fault. Per la sintassi completa, leggi le guide alle eccezioni in Python, a try e catch in Java, alle eccezioni in C++ e a try e catch in JavaScript. Il corso Java e il corso Python le mettono in pratica con esercizi reali.