Qu'est-ce que la gestion des exceptions ?

Un programme qui demande leur âge aux gens recevra tôt ou tard « twenty » au lieu de 20. Convertir ce texte provoque une erreur d'exécution : int("twenty") lève ValueError, et sans plan pour ce cas, le programme s'arrête. La gestion des exceptions, c'est ce plan. Tu marques le code qui peut échouer et tu écris le code qui s'exécute s'il échoue.

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 mauvaise réponse est signalée, et la boucle continue avec la suivante. Sans le try, le programme aurait affiché une ligne, puis un traceback.

Comment fonctionne la gestion des exceptions

1. Le code à l'intérieur du try s'exécute normalement.
2. Une opération échoue, et le runtime lève une exception : un objet avec un type (ValueError) et un message (invalid literal for int() with base 10: 'twenty').
3. Le bloc try s'arrête à cette ligne. Ses lignes restantes sont sautées, et c'est pour cela que « Next year you will be » n'est pas affiché pour « twenty ».
4. Le runtime compare le type de l'exception avec chaque clause except, de haut en bas, et exécute la première qui correspond.
5. Une fois le gestionnaire terminé, le programme continue à la première ligne après l'instruction try complète.
6. Si aucune clause ne correspond, l'exception quitte la fonction courante et la recherche continue dans la fonction qui l'a appelée, puis dans l'appelant de celle-ci. C'est ce qu'on appelle le déroulement de la pile d'appels. Si la recherche atteint le sommet du programme sans correspondance, le programme se termine avec un traceback.

L'étape 6 signifie que le gestionnaire n'a pas besoin d'être dans la fonction où l'erreur se produit. Ici, l'échec a lieu deux appels plus bas, et le gestionnaire en bas du fichier l'attrape quand même :

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") a échoué à l'intérieur de parse_price. Ni parse_price ni total n'avaient de gestionnaire, donc les deux ont été abandonnées, et « 3.20 » n'a jamais été analysé. C'est le principal choix de conception que te donne la gestion des exceptions : gérer une erreur là où tu sais quoi en faire, ce qui est souvent loin de l'endroit où elle s'est produite.

try, except, else et finally

L'instruction try de Python a deux parties facultatives de plus. else ne s'exécute que si le bloc try s'est terminé sans exception. finally s'exécute dans tous les cas : après un succès, après une exception gérée, et même quand la fonction retourne depuis l'intérieur du 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 est l'endroit du nettoyage : fermer un fichier, libérer un verrou, fermer une connexion à une base de données. En Python, l'instruction with fait ce nettoyage automatiquement pour les fichiers, et c'est le choix habituel dans ce cas.

Lever tes propres exceptions

Les exceptions ne servent pas qu'aux erreurs que le langage détecte. Quand ta propre fonction reçoit une entrée dont elle ne peut rien faire, elle peut lever une exception pour refuser, et l'appelant décide de la suite. Définir une petite classe d'exception donne à l'erreur un nom qui la décrit.

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 utilise raise. Java, C++ et JavaScript utilisent throw pour la même chose.

La gestion des exceptions dans d'autres langages

Le même exemple de conversion ressemble à ceci en Java :

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 sépare les exceptions en deux groupes. Les exceptions vérifiées, comme IOException, décrivent des problèmes hors du contrôle du programme, et le compilateur refuse de construire un code qui ne les attrape pas et ne les déclare pas. Les exceptions non vérifiées, sous-classes de RuntimeException comme NullPointerException, signalent généralement un bug, et le compilateur ne t'oblige pas à les gérer.

Erreurs fréquentes

• Tout attraper. Un except: nu en Python attrape aussi KeyboardInterrupt, donc Ctrl+C ne fonctionne plus, et except Exception: attrape des bugs que tu n'avais jamais prévus. Attrape le type précis que tu sais gérer.
• Avaler l'erreur. except ValueError: pass cache le problème. Au minimum, affiche ou journalise ce qui s'est mal passé.
• Un bloc try trop grand. N'enveloppe que les lignes qui peuvent lever l'exception que tu attrapes, pour qu'une erreur sans rapport ne soit pas gérée par erreur.
• Attraper les bugs au lieu de les corriger. Un IndexError venant d'une boucle qui va un pas trop loin est une faute dans le code. Le gérer maintient en vie le code faux.
• Compter sur catch pour empêcher un plantage en C ou C++. Une segmentation fault est un signal du système d'exploitation, pas une exception, et sous Linux et macOS un catch (...) C++ ne la voit jamais.

Pour aller plus loin

Les erreurs auxquelles répond la gestion des exceptions sont décrites sur la page erreur d'exécution, et le plantage qu'elle ne peut pas attraper sur la page segmentation fault. Pour la syntaxe complète, lis les guides sur les exceptions en Python, try et catch en Java, les exceptions en C++ et try et catch en JavaScript. Le cours Java et le cours Python les font pratiquer avec de vrais exercices.