Etre spécifique dans la capture des exceptions

Pourquoi être spécifique ? Les dangers du except générique

Lorsque vous utilisez un bloc `try...except`, il est crucial d'être *spécifique* dans les types d'exceptions que vous capturez. Cela signifie que vous devez spécifier le type d'exception (ou les types d'exceptions) que vous voulez gérer après le mot-clé `except`.

Evitez à tout prix le bloc `except` générique (sans type d'exception spécifié) :

try:
    # ...
except:
    # Code pour gérer N'IMPORTE QUELLE exception
    # ...

Pourquoi est-ce une mauvaise pratique ?

• Masquage d'erreurs : Un `except` générique capture *toutes* les exceptions, y compris celles que vous n'avez pas prévues et que vous ne savez pas gérer. Cela peut masquer des bugs et rendre le débogage beaucoup plus difficile.
• Gestion inappropriée : Vous risquez de gérer de la même manière des erreurs très différentes, ce qui peut conduire à un comportement incorrect du programme.
• Perte d'informations : Vous perdez l'information sur le type précis d'erreur qui s'est produite.

Un `except` générique est comme un filet de pêche à mailles trop larges : il attrape tout, y compris les poissons que vous ne voulez pas (et qui peuvent même être dangereux).

Capturer des exceptions spécifiques : except ExceptionType:

La bonne pratique est de capturer uniquement les exceptions que vous savez gérer et pour lesquelles vous avez une stratégie de traitement appropriée.

Utilisez la syntaxe `except ExceptionType:` pour spécifier le type d'exception que vous voulez capturer.

Exemple :

try:
    x = int(input("Entrez un nombre : "))
    resultat = 10 / x
except ValueError:
    print("Erreur : Vous devez entrer un nombre entier.")
except ZeroDivisionError:
    print("Erreur : Division par zéro.")
else:
    print("Résultat :", resultat)

Dans cet exemple, le code capture spécifiquement `ValueError` (si l'utilisateur n'entre pas un nombre entier) et `ZeroDivisionError` (si l'utilisateur entre 0). D'autres types d'exceptions (par exemple, `TypeError` si `input` retournait autre chose qu'une chaîne, ce qui est improbable) ne seraient *pas* capturés et provoqueraient l'arrêt du programme (ce qui est souvent préférable à un comportement incorrect et silencieux).

En étant spécifique, vous vous assurez que vous ne gérez que les erreurs que vous comprenez et que vous savez traiter. Les autres erreurs, potentiellement inattendues, seront signalées, ce qui vous aidera à les identifier et à les corriger.

Capturer plusieurs exceptions spécifiques : except (Type1, Type2):

Si vous voulez gérer plusieurs types d'exceptions *de la même manière*, vous pouvez utiliser un seul bloc `except` avec un tuple de types d'exceptions :

Syntaxe :

try:
    # ...
except (TypeError, ValueError):
    # Code pour gérer les TypeError et les ValueError
    # ...

Exemple :

try:
    x = int(input("Entrez un nombre : "))
    y = 10 / x
except (ValueError, ZeroDivisionError) as e:
    print("Erreur de saisie ou division par zéro :", e)

Dans cet exemple, le même code sera exécuté si une `ValueError` ou une `ZeroDivisionError` est levée.

L'exception Exception : un compromis (parfois) acceptable

Si vous voulez capturer *toutes* les exceptions *non-système* (c'est-à-dire la plupart des exceptions que vous rencontrerez en pratique), vous pouvez utiliser `except Exception:`.

Les exceptions non-système héritent de `Exception`. Les exceptions systèmes (`SystemExit`, `KeyboardInterrupt`) héritent de `BaseException` mais pas de `Exception`.

try:
    # ...
except Exception as e:
    print("Une erreur s'est produite :", e)

C'est un compromis entre le `except` générique (qui est *toujours* une mauvaise pratique) et la capture spécifique de chaque type d'exception possible (qui peut être fastidieux).

`except Exception:` est acceptable dans certains cas, par exemple :

• Pour logger toutes les erreurs non gérées avant de quitter le programme.
• Dans un niveau très élevé de votre application, pour éviter qu'une erreur non gérée ne fasse planter l'ensemble du programme.

Cependant, même dans ces cas, il est préférable d'être aussi spécifique que possible. Si vous savez que certaines exceptions spécifiques peuvent se produire, capturez-les explicitement *avant* de capturer `Exception`.

Exemple : combiner capture spécifique et capture plus générale

Voici un exemple qui combine la capture d'exceptions spécifiques et une capture plus générale de `Exception` :

try:
    # Code qui peut lever différentes exceptions...
    x = int(input("Entrez un nombre : "))
    y = 10 / x
    liste = [1, 2, 3]
    print(liste[x])
except ValueError:
    print("Erreur : Vous devez entrer un nombre entier.")  # Gestion spécifique
except ZeroDivisionError:
    print("Erreur : Division par zéro.")  # Gestion spécifique
except IndexError:
    print("Erreur : Indice hors limites.") # Gestion spécifique
except Exception as e:
    print("Une erreur inattendue s'est produite :", e)  # Gestion générique
    # Enregistrement de l'erreur dans un fichier de log, etc.
    # ...

Dans cet exemple :

• Les exceptions `ValueError`, `ZeroDivisionError`, et `IndexError` sont gérées spécifiquement.
• Toute autre exception (non prévue) sera capturée par le bloc `except Exception as e`, ce qui permet d'afficher un message d'erreur et (éventuellement) d'enregistrer l'erreur pour un débogage ultérieur.

C'est une bonne pratique de combiner la capture spécifique d'exceptions connues avec une capture plus générale d'exceptions inattendues, pour rendre votre code plus robuste et plus facile à déboguer.