Classes abstraites en Python

Cet article explique les classes abstraites en Python.

Nous expliquerons le mécanisme de base des classes abstraites en utilisant le module abc, fournirons des exemples pratiques et décrirons tout avec du code associé.

YouTube Video

Classes abstraites en Python

Le module abc de Python (Abstract Base Classes) fait partie de la bibliothèque standard et est utilisé pour définir des classes abstraites, fournissant un modèle pour les méthodes qu'une classe doit implémenter. L'utilisation de ce module améliore la flexibilité et la robustesse dans la conception des classes.

Qu'est-ce qu'une classe abstraite ?

Les classes abstraites sont des classes utilisées pour définir une interface commune pour les classes concrètes (instanciables). Les classes abstraites ne peuvent pas être instanciées par elles-mêmes ; une implémentation concrète doit être fournie dans les sous-classes dérivées.

Le module abc vous permet de définir des méthodes ou propriétés abstraites et d'imposer leur implémentation dans les classes qui en héritent. Si une seule méthode abstraite n'est pas implémentée, la classe ne peut pas être instanciée.

Comment utiliser le module abc

Pour créer une classe abstraite en utilisant le module abc, héritez de la classe ABC et définissez des méthodes abstraites en utilisant le décorateur @abstractmethod.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"

Ici, la classe Animal est définie comme une classe abstraite et inclut une méthode abstraite appelée sound. Cette méthode doit être concrètement implémentée dans les sous-classes. Dog et Cat héritent de Animal et implémentent chacune la méthode sound.

Instantiation des classes abstraites

Les classes abstraites ne peuvent pas être instanciées directement. Par exemple, tenter d'instancier la classe Animal elle-même entraînera une erreur.

1animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods sound

• Lorsqu'on tente d'instancier une classe abstraite, Python détermine qu'il existe des méthodes abstraites non implémentées et renvoie une TypeError. Si toutes les méthodes abstraites requises sont implémentées dans la sous-classe, l'instanciation devient possible.

Méthodes abstraites multiples

Il est également possible qu'une classe ait plusieurs méthodes abstraites. À moins que toutes les méthodes abstraites ne soient implémentées dans une sous-classe, la classe reste abstraite.

 1from abc import ABC, abstractmethod
 2
 3class Vehicle(ABC):
 4
 5    @abstractmethod
 6    def start_engine(self):
 7        pass
 8
 9    @abstractmethod
10    def stop_engine(self):
11        pass
12
13class Car(Vehicle):
14    def start_engine(self):
15        return "Car engine started"
16
17    def stop_engine(self):
18        return "Car engine stopped"

Dans cet exemple, la classe Vehicle possède deux méthodes abstraites, et la classe Car ne peut être instanciée qu'après avoir implémenté les deux méthodes.

Définir des propriétés abstraites

Le module abc prend en charge non seulement les méthodes abstraites, mais aussi les propriétés abstraites. Cela permet de garantir l'implémentation des propriétés dans les classes dérivées.

 1from abc import ABC, abstractmethod
 2
 3class Shape(ABC):
 4
 5    @property
 6    @abstractmethod
 7    def area(self):
 8        pass
 9
10class Circle(Shape):
11    def __init__(self, radius):
12        self.radius = radius
13
14    @property
15    def area(self):
16        return 3.14159 * (self.radius ** 2)

• Dans cet exemple, la classe Shape possède une propriété abstraite area, et la sous-classe Circle concrétise cette propriété. De cette manière, utiliser des classes abstraites pour imposer l'implémentation de propriétés aide à maintenir la cohérence du code.

Utiliser isinstance() et issubclass()

En utilisant des classes abstraites, vous pouvez confirmer les relations d'héritage de classe avec isinstance() ou issubclass(), améliorant ainsi la sécurité et la flexibilité du code.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"
18
19class Vehicle(ABC):
20
21    @abstractmethod
22    def start_engine(self):
23        pass
24
25    @abstractmethod
26    def stop_engine(self):
27        pass
28
29class Car(Vehicle):
30    def start_engine(self):
31        return "Car engine started"
32
33    def stop_engine(self):
34        return "Car engine stopped"
35
36print("Dog() is an Animal? -> ", isinstance(Dog(), Animal))   # True
37print("Dog is subclass of Animal? -> ", issubclass(Dog, Animal))  # True
38print("Cat() is a Vehicle? -> ", isinstance(Cat(), Vehicle))  # False

isinstance() est utilisé pour vérifier si un objet est une instance d'une classe spécifiée, et issubclass() est utilisé pour vérifier si une classe est une sous-classe d'une classe spécifiée.

Résumé

En concevant des classes abstraites avec le module abc, vous pouvez clarifier l'interface entre les classes et imposer l'implémentation des méthodes et propriétés requises. Cela aide à maintenir la cohérence du code et réduit les erreurs, ce qui est particulièrement utile pour les projets de grande envergure.

Les classes abstraites sont un outil important en Python qui prend en charge une programmation orientée objet flexible, améliorant ainsi la réutilisabilité et la maintenabilité des classes.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video