Python Academy · Leçon

Classes d’exception personnalisées

Définissez vos propres types d’exception pour communiquer les erreurs plus clairement.

Classes d’exception personnalisées est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Introduction

Les classes d’exception personnalisées rendent votre gestion des erreurs explicite, auto-documentée et facile à traiter précisément pour les appelants.

Pourquoi créer des exceptions personnalisées ?

Les exceptions intégrées sont trop générales. Les exceptions personnalisées permettent aux appelants d’intercepter uniquement les erreurs propres à YOUR, sans intercepter les erreurs sans rapport.

class AppError(Exception):
    pass
raise AppError('something went wrong')

Hériter d’Exception

class MyError(Exception): pass suffit. Héritez toujours d’Exception, et non de BaseException.

class ValidationError(Exception):
    pass
try:
    raise ValidationError('email is invalid')
except ValidationError as e:
    print(e)

Ajouter des attributs personnalisés

class APIError(Exception): def __init__(self, status, message): self.status = status; super().__init__(message)

class APIError(Exception):
    def __init__(self, status, message):
        self.status = status
        super().__init__(message)
try:
    raise APIError(404, 'Not found')
except APIError as e:
    print(e.status, e)

Hiérarchie des exceptions

Construisez une hiérarchie : class DBError(AppError): pass — les appelants peuvent intercepter AppError pour toute erreur de l’application, ou DBError spécifiquement.

class AppError(Exception): pass
class DBError(AppError): pass
class NetworkError(AppError): pass
try:
    raise DBError('timeout')
except AppError as e:
    print('app error:', e)

Méthode str personnalisée

Surchagez __str__ pour contrôler l’apparence du message de l’exception lors de son affichage.

class RangeError(ValueError):
    def __init__(self, val, lo, hi):
        self.val, self.lo, self.hi = val, lo, hi
    def __str__(self):
        return f'{self.val} not in [{self.lo}, {self.hi}]'
print(RangeError(15, 0, 10))

Lever des exceptions personnalisées

Utilisez raise dans vos fonctions pour signaler des erreurs propres au domaine. Cela crée une API claire pour les appelants.

class InsufficientFundsError(Exception):
    def __init__(self, needed, available):
        super().__init__(f'Need {needed}, have {available}')
def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount
try:
    withdraw(100, 200)
except InsufficientFundsError as e:
    print(e)

Intercepter par la classe de base

except AppError intercepte toutes les sous-classes : DBError, NetworkError, etc. La hiérarchie permet aux appelants de choisir le niveau de précision.

class AppError(Exception): pass
class DBError(AppError): pass
try:
    raise DBError('conn failed')
except AppError:
    print('any app error')

Exception avec un gestionnaire de contexte

Les exceptions personnalisées s’intègrent aux gestionnaires de contexte : class suppressed: __exit__ renvoie True pour supprimer l’exception.

class SuppressValue(Exception): pass
try:
    raise SuppressValue('ignored')
except SuppressValue:
    pass  # suppress silently
print('continued')

Documenter les exceptions personnalisées

Documentez WHEN lever l’exception et WHAT signifient les attributs. De bonnes chaînes de documentation rendent les exceptions personnalisées faciles à utiliser.

class ConfigError(Exception):
    """Raised when configuration is invalid.
    Attributes:
        key: The invalid config key
    """
    def __init__(self, key, msg):
        super().__init__(msg)
        self.key = key

Bonnes pratiques

Gardez une hiérarchie peu profonde (2 ou 3 niveaux). Héritez toujours d’Exception. Utilisez des noms descriptifs se terminant par Error. Placez-les dans un module exceptions.py dédié.

# Good structure:
class AppError(Exception): pass
class ValidationError(AppError): pass
class NotFoundError(AppError): pass
print('hierarchy demo')

Vérification rapide

De quelle classe les exceptions personnalisées doivent-elles hériter pour éviter d’intercepter les événements qui arrêtent le système ?

Récapitulatif

Les exceptions personnalisées héritent d’Exception, ajoutent leurs attributs dans __init__ et redéfinissent __str__. Construisez des hiérarchies pour faciliter leur interception. Placez-les dans le module exceptions.py.

Poursuivez

Excellent travail ! Passez à la leçon suivante pour continuer votre progression.

Questions Fréquemment Posées

La leçon « Classes d’exception personnalisées » est-elle gratuite ?

Oui — le texte complet de « Classes d’exception personnalisées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Classes d’exception personnalisées » ?

Définissez vos propres types d’exception pour communiquer les erreurs plus clairement. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Classes d’exception personnalisées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy