Les classes abstraites en Python sont un concept fondamental dans la programmation orientée objet (POO) qui permet de définir des structures pour d'autres classes sans implémenter toutes leurs méthodes.
Elles sont utilisées pour créer un cadre sur lequel d’autres classes vont s’appuyer.
Elles sont essentielles lorsqu’on souhaite imposer certaines méthodes à toutes les classes dérivées, garantissant ainsi une certaine cohérence et structure dans le code.
À noter
En Python, les classes abstraites ne peuvent pas être instanciées directement, ce qui signifie qu'on ne peut pas créer d'objets de ces classes.
Au lieu de cela, elles servent de modèle pour les sous-classes, qui doivent implémenter toutes les méthodes abstraites de la classe abstraite mère pour pouvoir être instanciées.
Créer une classe abstraite
Pour créer une classe abstraite en Python, on utilise le module abc (Abstract Base Classes) qui fournit les mécanismes nécessaires pour définir les méthodes abstraites.
Une méthode devient abstraite quand elle est décorée avec le décorateur @abstractmethod.
Exemple simple d'utilisation des classes abstraites :
from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def parler(self): pass class Chien(Animal): def parler(self): return "Wouf Wouf" class Chat(Animal): def parler(self): return "Miaou" # Tentative d'instanciation de la classe abstraite animal = Animal() # Cela lèvera une erreur # Utilisation des sous-classes mon_chien = Chien() mon_chat = Chat() print(mon_chien.parler()) # Affichera "Wouf Wouf" print(mon_chat.parler()) # Affichera "Miaou"
À noter
Dans cet exemple, la classe Animal est abstraite et définit une méthode abstraite parler.
Les classes Chien et Chat héritent de Animal et implémentent donc la méthode parler().
L'instanciation directe de la classe Animal lèverait une erreur car il s'agit d'une classe abstraite, tandis que créer des objets à partir des sous-classes Chien et Chat est possible car ces dernières ont fourni une implémentation concrète de la méthode abstraite.
from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def parler(self): pass class Chien(Animal): def parler(self): return "Wouf Wouf" class Chat(Animal): pass mon_chat = Chat() mon_chat.parler() # TypeError: Can't instantiate abstract class Chat without an implementation for abstract method 'parler'
Mais alors, à quoi ça sert ? 🤔
L'utilité des classes abstraites réside dans leur capacité à définir un contrat pour les sous-classes, forçant l'implémentation de méthodes spécifiques tout en permettant l'élaboration de logiques complexes dans un environnement structuré et cohérent.
