Recherche de site Web

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 :

  1. Produit en rupture de stock : Lorsqu'un produit n'est pas disponible.
  2. ID de produit invalide : lorsque l'ID de produit n'existe pas.
  3. 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 !

Articles connexes