Comment (et pourquoi) créer des exceptions personnalisées en Python
Ce didacticiel explique comment créer et utiliser des exceptions personnalisées en Python pour gérer des conditions d'erreur spécifiques avec un exemple pratique.
En Python, vous pouvez utiliser des exceptions pour anticiper et gérer les erreurs qui perturbent le déroulement normal d'un programme. Bien que Python propose de nombreuses exceptions intégrées (exceptions courantes telles que ValueError
, TypeError
et KeyError
), il existe des cas où des exceptions personnalisées sont nécessaires pour la gestion. conditions d'erreur uniques spécifiques à votre application.
La création d'exceptions personnalisées améliore à la fois la lisibilité et la maintenabilité du code. Ceux-ci facilitent également le débogage en vous permettant de gérer les erreurs spécifiques à votre application, lorsque les exceptions intégrées peuvent être trop génériques.
Dans ce didacticiel, nous apprendrons comment créer des exceptions personnalisées en Python en codant un système d'inventaire simple pour le commerce électronique.
Création d'exceptions personnalisées en Python
Vous pouvez créer une exception personnalisée en Python en sous-classant la classe intégrée Exception
.
class MyCustomError(Exception):
"""Custom exception for a specific error"""
pass
Implémentons maintenant des exceptions personnalisées pour un exemple de système de gestion des stocks.
Création d'exceptions personnalisées pour un système d'inventaire de commerce électronique
Vous pouvez suivre le code de ce didacticiel sur GitHub.
Nous allons simuler un système d'inventaire de commerce électronique simple et créer des exceptions personnalisées pour les cas suivants :
- Produit en rupture de stock : Lorsqu'un produit n'est pas disponible.
- ID de produit invalide : lorsque l'ID de produit n'existe pas.
- Limite d'achat dépassée : lorsque l'utilisateur tente d'acheter plus que la quantité autorisée.
Définir des classes d'exception personnalisées
Nous définirons trois exceptions personnalisées pour gérer ces cas :
OutOfStockError
: déclenché lorsqu'un produit est en rupture de stock ; lorsque son compte tombe à zéro.InvalidProductIDError
: déclenché lorsque l'ID de produit fourni n'est pas valide ou n'existe pas dans l'inventaire.PurchaseLimitExceededError
: déclenché lorsqu'un utilisateur tente de dépasser la limite d'achat autorisée pour un produit.
class OutOfStockError(Exception):
"""Exception raised when the product is out of stock"""
def __init__(self, product_name):
self.product_name = product_name
super().__init__(f"'{self.product_name}' is out of stock")
class InvalidProductIDError(Exception):
"""Exception raised for invalid product IDs"""
def __init__(self, product_id):
self.product_id = product_id
super().__init__(f"Product ID '{self.product_id}' is not valid")
class PurchaseLimitExceededError(Exception):
"""Exception raised when purchase limit is exceeded"""
def __init__(self, product_name, limit):
self.product_name = product_name
self.limit = limit
super().__init__(
f"Cannot purchase more than {self.limit} units of '{self.product_name}'"
)
Configurer une classe d'inventaire
Ensuite, nous allons créer une classe Inventaire
pour simuler la disponibilité des produits, les niveaux de stock et les limites d'achat.
class Inventory:
def __init__(self):
self.products = {
'P001': {'name': 'Laptop', 'stock': 5, 'max_purchase_limit': 2},
'P002': {'name': 'Smartphone', 'stock': 0, 'max_purchase_limit': 5},
}
Le dictionnaire produits
contient les identifiants de produits avec les noms de produits associés, le stock disponible et les limites d'achat.
Implémenter la logique d'achat et générer des exceptions personnalisées
Ensuite, nous ajouterons une méthode purchase
à la classe Inventory
qui vérifie les ID de produit valides, la disponibilité des stocks et les limites d'achat. Sur la base de ces conditions, des exceptions personnalisées seront levées.
def purchase(self, product_id, quantity):
if product_id not in self.products:
raise InvalidProductIDError(product_id)
product = self.products[product_id]
if product['stock'] == 0:
raise OutOfStockError(product['name'])
# Check if the quantity exceeds the max purchase limit
if quantity > product['max_purchase_limit']:
raise PurchaseLimitExceededError(product['name'], product['max_purchase_limit'])
# Process purchase
if quantity <= product['stock']:
product['stock'] -= quantity
print(f"Successfully purchased {quantity} unit(s) of {product['name']}.")
else:
raise OutOfStockError(product['name'])
La méthode vérifie si l'ID du produit existe. Sinon, cela génère une InvalidProductIDError
. Si le produit est en rupture de stock, une OutOfStockError
est générée.
Si la quantité demandée dépasse la limite, une PurchaseLimitExceededError
est générée. Si toutes les conditions sont remplies, il diminue le stock et imprime un message de réussite.
Tester et gérer les exceptions
Testons maintenant le système avec différents scénarios, en gérant les exceptions si nécessaire.
Comme vu, nous gérons les exceptions à l'aide de blocs try-sauf
et imprimons les messages d'erreur correspondants.
# Testing the system
inventory = Inventory()
try:
inventory.purchase('P001', 1) # Successful purchase
inventory.purchase('P002', 1) # OutOfStockError
except OutOfStockError as e:
print(f"Error: {e}")
except InvalidProductIDError as e:
print(f"Error: {e}")
except PurchaseLimitExceededError as e:
print(f"Error: {e}")
Nous essayons d'acheter une unité d'ordinateur portable (P001), ce qui réussit. Ensuite, nous essayons d'acheter un smartphone (P002), qui est en rupture de stock, ce qui génère une OutOfStockError
.
Successfully purchased 1 unit(s) of Laptop.
Error: 'Smartphone' is out of stock
Testons également ce qui se passe lorsque l'utilisateur tente de dépasser la limite d'achat.
try:
inventory.purchase('P001', 3) # PurchaseLimitExceededError
except OutOfStockError as e:
print(f"Error: {e}")
except InvalidProductIDError as e:
print(f"Error: {e}")
except PurchaseLimitExceededError as e:
print(f"Error: {e}")
Ici, nous essayons d'acheter trois unités d'un ordinateur portable (P001), mais la limite n'est que de deux. Cela génère une PurchaseLimitExceededError
, qui est interceptée et gérée.
Error: Cannot purchase more than 2 units of 'Laptop'
Conclusion
Les exceptions personnalisées constituent un moyen efficace de gérer des conditions d'erreur spécifiques dans vos applications Python. Dans ce didacticiel, nous avons défini des exceptions personnalisées pour un système d'inventaire de commerce électronique. Pour résumer:
- Les exceptions personnalisées vous permettent de décrire les erreurs d'une manière (beaucoup) plus significative que les exceptions génériques, améliorant ainsi la lisibilité du code.
- Vous pouvez identifier et isoler les problèmes plus facilement lorsque les erreurs sont adaptées à des situations spécifiques.
- Vous pouvez regrouper les erreurs associées sous une seule classe d’exceptions ou les gérer différemment en fonction du cas d’utilisation.
Le code de ce tutoriel est sur GitHub. Maintenant que vous avez appris les bases, essayez d'implémenter des exceptions personnalisées dans vos propres projets pour gérer les erreurs spécifiques aux applications. Bon codage !