Signaler des erreurs spécifiques dans son propre code

Pourquoi signaler des erreurs ? Informer l'appelant

Lorsque vous écrivez une fonction ou une méthode, il est important de signaler les erreurs et les conditions exceptionnelles qui peuvent se produire. Cela permet à l'appelant de la fonction (le code qui utilise votre fonction) de savoir qu'un problème est survenu et de réagir en conséquence (par exemple, en affichant un message d'erreur, en réessayant l'opération, ou en gérant l'erreur d'une autre manière).

En Python, la manière standard de signaler une erreur est de *lever une exception* en utilisant l'instruction `raise`.

Lever une exception interrompt le flux normal d'exécution et propage l'erreur vers le haut de la pile d'appels, jusqu'à ce qu'elle soit capturée par un bloc `try...except` (ou jusqu'à ce qu'elle provoque l'arrêt du programme si elle n'est pas capturée).

Signaler les erreurs de manière claire et précise est essentiel pour écrire du code robuste et facile à déboguer.

L'instruction raise : lever une exception

L'instruction `raise` permet de lever une exception.

Syntaxe de base :

raise ExceptionType("Message d'erreur")

• `raise` : Le mot-clé qui indique que vous voulez lever une exception.
• `ExceptionType` : Le type d'exception que vous voulez lever (par exemple, `ValueError`, `TypeError`, `IndexError`, ou une exception personnalisée).
• `"Message d'erreur"` : (Optionnel) Une chaîne de caractères qui décrit l'erreur. Ce message sera inclus dans l'objet exception et pourra être affiché à l'utilisateur ou enregistré dans un fichier de log.

Exemple :

def diviser(a, b):
    if b == 0:
        raise ZeroDivisionError("Division par zéro impossible")
    return a / b

# diviser(10, 0)  # Lèverait une ZeroDivisionError avec le message "Division par zéro impossible"

Dans cet exemple, la fonction `diviser` lève une `ZeroDivisionError` si le deuxième argument (`b`) est égal à zéro.

Vous pouvez aussi lever une exception sans message d'erreur :

raise ValueError

Ou réutiliser une exception existante

try:
  #...
except ValueError as e:
  #...
  raise # Relance la même exception.

Choisir le bon type d'exception

Lorsque vous signalez une erreur, il est important de choisir le type d'exception approprié. Python fournit de nombreuses exceptions intégrées (voir la section précédente), et vous devriez utiliser l'exception la plus spécifique qui correspond à la situation.

Utiliser le bon type d'exception permet à l'appelant de gérer l'erreur de manière précise (par exemple, en capturant uniquement les `ValueError` si c'est ce qui l'intéresse).

Voici quelques exemples d'exceptions courantes et de quand les utiliser :

• `ValueError` : Une valeur inappropriée est passée à une fonction (par exemple, une chaîne de caractères au lieu d'un nombre, ou un nombre négatif alors qu'un nombre positif est attendu).
• `TypeError` : Un type incorrect est utilisé (par exemple, essayer d'additionner un nombre et une chaîne de caractères).
• `IndexError` : Un indice est en dehors des limites d'une séquence (liste, tuple, chaîne).
• `KeyError` : Une clé est introuvable dans un dictionnaire.
• `FileNotFoundError` : Un fichier n'est pas trouvé.
• `AssertionError` : Utilisée par l'instruction `assert` pour signaler qu'une condition n'est pas remplie.

Si aucune des exceptions intégrées ne correspond à la situation, vous pouvez créer votre propre exception (voir section suivante).

Exemple : validation d'arguments dans une fonction

Un cas d'utilisation courant de `raise` est la validation des arguments d'une fonction.

Exemple :

def calculer_aire_rectangle(longueur, largeur):
    """Calcule l'aire d'un rectangle.

    Args:
        longueur (float or int): La longueur du rectangle.
        largeur (float or int): La largeur du rectangle.

    Raises:
        TypeError: Si longueur ou largeur n'est pas un nombre.
        ValueError: Si longueur ou largeur est négative.

    Returns:
        float: L'aire du rectangle.
    """
    if not isinstance(longueur, (int, float)) or not isinstance(largeur, (int, float)):
        raise TypeError("Les arguments doivent être des nombres.")
    if longueur < 0 or largeur < 0:
        raise ValueError("Les dimensions doivent être positives.")
    return longueur * largeur

# calculer_aire_rectangle("abc", 5)     # Lèverait une TypeError
# calculer_aire_rectangle(5, -2)        # Lèverait une ValueError
# calculer_aire_rectangle(5, 5)          # Retournerait 25

Dans cet exemple, la fonction `calculer_aire_rectangle` lève une `TypeError` si les arguments ne sont pas des nombres, et une `ValueError` si les arguments sont négatifs.

Bonnes pratiques

Voici quelques bonnes pratiques pour signaler des erreurs avec `raise` :

• Choisissez le bon type d'exception : Utilisez l'exception la plus spécifique qui correspond à la situation.
• Fournissez un message d'erreur clair et informatif : Le message doit expliquer ce qui s'est mal passé et, si possible, comment corriger l'erreur.
• Ne levez pas d'exceptions inutiles : N'utilisez pas les exceptions pour le contrôle de flux normal du programme. Les exceptions doivent être réservées aux situations *exceptionnelles*.
• Documentez les exceptions que votre fonction peut lever : Indiquez dans la docstring de votre fonction quelles exceptions peuvent être levées et dans quelles circonstances.
• Ne masquez pas les erreurs : Si vous ne pouvez pas gérer une exception, laissez-la se propager. Ne la capturez pas simplement pour l'ignorer.