Lever des exceptions avec raise / Classes d'exceptions personnalisées

Dans l'article précédent sur try / except, on a regardé le côté réception d'une exception.

Cet article couvre raise — le côté émission, où tu fais apparaître une exception toi-même. Quand tu lèves une exception sur une saisie invalide ou un état inattendu, l'appelant est garanti de la remarquer via try / except.

Les bases de raise

Écrire raise ClasseException("message") lève cette exception tout de suite. À l'instant où raise s'exécute, le reste du code est sauté et le contrôle saute vers l'except correspondant.

Le message est optionnel, mais inclure pourquoi ça a échoué permet au receveur de le lire via except ... as e.

# Lève un ValueError et attrape-le côté réception
try:
    raise ValueError("Âge invalide")
    print("jamais atteint")
except ValueError as e:
    print(f"Attrapé : {e}")
# Sortie : Attrapé : Âge invalide

# N'importe quelle exception built-in fonctionne telle quelle
# Courantes : ValueError / TypeError / KeyError / IndexError

Fais le plus petit aller-retour de raise et try / except.

① Dans try, exécute raise KeyError("user_id introuvable").

② Attrape-le avec except KeyError as e: et affiche "Type : KeyError / Détails : {e}" sur une ligne.

③ Après try / except, appelle print("Poursuite…") pour confirmer que le programme ne s'est pas arrêté.

(L'explication apparaît une fois que tu auras exécuté le code correctement.)

Valider avec if + raise

raise est le plus souvent utilisé pour la validation de saisie. Quand un if repère quelque chose d'invalide, raise immédiatement et rends la main à l'appelant. C'est une technique idiomatique dans les fonctions (couvert plus tard), où lever à l'intérieur d'une fonction notifie l'appelant de mauvais arguments.

Le flux — le chemin normal passe ; le chemin anormal lève et s'arrête — est le motif de base de la validation en production.

# Valider un prix de produit : 0 ou moins est une erreur
price = -500

try:
    if price < 0:
        raise ValueError(f"Le prix doit être 0 ou plus (reçu : {price})")
    if not isinstance(price, int):
        raise TypeError(f"Le prix doit être un entier (type reçu : {type(price).__name__})")
    print(f"Enregistré : {price}")
except ValueError as e:
    print(f"Erreur de valeur : {e}")
except TypeError as e:
    print(f"Erreur de type : {e}")
# Sortie : Erreur de valeur : Le prix doit être 0 ou plus (reçu : -500)

Un guide approximatif pour quelle exception built-in lever : utilise ValueError quand la valeur est mauvaise, TypeError quand le type ne correspond pas à ce qui est attendu, et KeyError / IndexError quand la clé ou l'élément cible est manquant dans un dict ou une liste.

Valide un nom d'utilisateur.

① Définis user_name = "".

② Dans try, lève ValueError("Le nom d'utilisateur est requis") quand user_name est une chaîne vide, et ValueError("Le nom d'utilisateur doit faire 20 caractères ou moins") quand len(user_name) > 20. Si ni l'un ni l'autre, affiche "Enregistré : {user_name}".

③ Attrape avec except ValueError as e: et affiche "Erreur de saisie : {e}".

Définir une classe d'exception personnalisée

Les exceptions built-in seules rendent parfois difficile de dire quelle validation a échoué. Définir ta propre classe d'exception te permet de l'attraper précisément côté except.

La forme est class NomErreur(Exception): avec pass (vide) comme corps — c'est tout. On couvrira les classes en détail dans le chapitre à venir sur la programmation orientée objet, mais pour les classes d'exception, cette seule ligne suffit.

# Définit une exception personnalisée (1 ligne suffit)
class InvalidAgeError(Exception):
    pass

class DuplicateUserError(Exception):
    pass

registered_users = ["alice", "bob"]
new_user = "alice"
new_age = -1

try:
    if new_age < 0:
        raise InvalidAgeError(f"L'âge doit être 0 ou plus : {new_age}")
    if new_user in registered_users:
        raise DuplicateUserError(f"Déjà enregistré : {new_user}")
    print(f"Enregistré : {new_user}")
except InvalidAgeError as e:
    print(f"Erreur d'âge : {e}")
except DuplicateUserError as e:
    print(f"Erreur de doublon : {e}")
# Sortie : Erreur d'âge : L'âge doit être 0 ou plus : -1

Les exceptions personnalisées définissent Exception comme classe parente

Le Exception entre parenthèses nomme la classe parente. Mettre Exception à cet endroit fait que ta classe personnalisée récupère automatiquement les fonctionnalités standard d'une exception — elle peut transporter un message, elle est attrapable par un except Exception générique, etc. Le mécanisme parent / enfant lui-même (héritage) est couvert dans le chapitre sur la programmation orientée objet, mais cette seule ligne suffit pour définir une exception.

Fais une exception dédiée « rupture de stock » et lève-la pendant un flux d'achat.

① Définis class OutOfStockError(Exception): pass.

② Mets en place stock = {"pomme": 3, "pain": 0} et want = "pain".

③ Dans try, quand stock[want] == 0, lève OutOfStockError(f"Rupture de stock : {want}") ; sinon affiche "Acheté : {want}".

④ Attrape avec except OutOfStockError as e: et affiche "Avis : {e}".

Dans cet article, tu as appris comment lever des exceptions toi-même avec raise, le motif if + raise pour la validation, et comment définir une classe d'exception personnalisée avec Exception comme classe parente.

Ensuite, on regardera def — qui est déjà apparu plusieurs fois — comme sujet à part entière et on apprendra à regrouper et réutiliser la logique avec des fonctions.