Classes abstraites Python : Un guide complet avec des exemples

La programmation orientée objet (POO), qui permet aux programmeurs d'organiser le code de manière évolutive, modulaire et réutilisable, est un élément clé du développement des logiciels modernes. Les classes abstraites sont l'un des nombreux concepts de la POO qui sont essentiels pour créer un modèle que d'autres classes peuvent utiliser. Ce billet vous expliquera les classes abstraites, leurs avantages et comment utiliser le module abc de Python pour les construire avec succès.

Nouveau à Python ? Apprenez à travailler avec des modules et des paquets, à utiliser des types de données intégrés et à écrire des fonctions personnalisées.

Qu'est-ce qu'une classe abstraite ?

D'autres classes utilisent une classe abstraite comme modèle. Bien qu'il ne fournisse pas leur implémentation, il spécifie les méthodes que ses sous-classes doivent utiliser. Cela permet aux programmeurs de garantir que toutes les sous-classes respectent un contrat particulier en imposant une interface uniforme pour les différentes implémentations.

Par exemple, une classe abstraite comme Shape pourrait définir des méthodes comme area et perimeter. La mise en œuvre de ces fonctions serait ensuite fournie pour chaque forme distincte, telle qu'un cercle ou un rectangle.

Vous voulez passer à la vitesse supérieure en ce qui concerne vos compétences en matière de POO ? Inscrivez-vous à notre cours de programmation intermédiaire orientée objet en Python. 

Pourquoi utiliser des classes abstraites en Python ?

Les classes abstraites sont utiles lorsque vous souhaitez :

• Appliquer la mise en œuvre de la méthode : Les méthodes d'une classe abstraite fonctionnent comme un contrat, exigeant de chaque sous-classe qu'elle fournisse sa propre implémentation. Cela réduit la possibilité d'implémentations incohérentes ou manquantes en garantissant que la fonctionnalité spécifique est présente dans toutes les classes dérivées.
• Encourager la réutilisation du code : les classes abstraites peuvent avoir des méthodes concrètes et abstraites. Les méthodes concrètes réduisent considérablement la duplication du code et encouragent les principes DRY (Do not Repeat Yourself) en fournissant des fonctionnalités partagées qui peuvent être héritées par toutes les sous-classes.
• Améliorer la lisibilité et la maintenabilité : Les classes abstraites aident les développeurs à mieux comprendre la structure et la fonctionnalité du logiciel en fournissant un cadre cohérent et transparent. Cette structure facilite la maintenance du code en appliquant des principes de conception tels que la responsabilité unique et la séparation des responsabilités.
• Encouragez le polymorphisme : Les classes abstraites permettent d'écrire un code général qui fonctionne bien avec une variété de sous-classes. Grâce à cette flexibilité, les développeurs peuvent créer des fonctions ou des méthodes capables de gérer n'importe quelle sous-classe de la classe abstraite, ce qui accroît l'extensibilité du code et son adaptabilité aux changements futurs.

Vous pouvez vous assurer que toute sous-classe, telle que Dog ou Cat, implémente son implémentation de la méthode speak, par exemple, si vous avez une classe abstraite Animal avec une méthode abstraite speak. Votre code devient fiable et prévisible grâce à cette uniformité.

Devenez un développeur pro Python en suivant notre cours de développeur Python dès aujourd'hui. 

Le module abc en Python

Le module abc de Python offre un support intégré solide pour les classes abstraites. Le module, qui signifie "Classes de base abstraites", fournit aux programmeurs les outils nécessaires pour créer des classes abstraites, notamment le décorateur abstractmethod et la classe ABC. 

En définissant des méthodes abstraites et en exigeant leur mise en œuvre dans les sous-classes, ces outils vous aident à maintenir l'uniformité et la conformité à une interface prédéterminée. En exigeant l'implémentation des méthodes essentielles dans toutes les classes dérivées et en autorisant l'implémentation partielle des fonctionnalités communes dans les classes de base abstraites, le module encourage également l'amélioration des modèles de conception. 

Pour cette raison, le module ABC est un composant crucial pour l'organisation d'applications Python évolutives, robustes et stables.

Création d'une classe abstraite Python

Deux éléments essentiels sont introduits dans le module ABC :

Classe de base abstraite, ou ABC

La classe ABC est une fonctionnalité intégrée de Python qui sert de base fondamentale au développement de classes abstraites. Vous devez hériter de ABC pour définir une classe abstraite. La classe est abstraite et ne peut être instanciée directement, comme l'indique cet héritage. En agissant comme des modèles, les classes abstraites garantissent que toute sous-classe concrète respecte un ensemble de règles.

Vous pouvez définir des méthodes abstraites à l'intérieur d'une classe abstraite en utilisant le décorateur abstractmethod. Toute sous-classe concrète doit implémenter et surcharger les méthodes abstraites, qui sont des espaces réservés. Cela rend le code cohérent et prévisible en garantissant que toutes les classes dérivées offrent des fonctionnalités pour les méthodes désignées. Le décorateur abstractmethod est un outil utile pour exiger la mise en œuvre d'une méthode tout en donnant aux sous-classes une certaine souplesse dans la manière de répondre à ces exigences.

Voici un exemple simple :

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Uncommenting the following line will raise an error because we’re missing method implementations
# shape = Shape() # TypeError: Can't instantiate abstract class Shape with abstract methods #area, perimeter

circle = Circle(5)
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}")
Area: 78.53975
Perimeter: 31.4159

Si vous recherchez des projets Python plus pratiques, consultez notre liste des 60 meilleurs projets Python pour les développeurs de tous niveaux. 

Comment le module abc assure la mise en œuvre des méthodes

Toute sous-classe d'une classe abstraite est assurée d'implémenter les méthodes décorées grâce au décorateur abstractmethod. Par précaution, il empêche la création de sous-classes qui n'ont pas les capacités nécessaires. 

Python signale un TypeError lorsqu'on tente d'instancier une sous-classe qui ne surcharge pas toutes les méthodes abstraites. Cette application stricte réduit la probabilité de défauts et améliore la stabilité du code en aidant les développeurs à identifier rapidement les défauts de mise en œuvre. 

Elle garantit également que toutes les sous-classes concrètes suivent le comportement et la conception prévus par la classe abstraite.

Par exemple :

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # Missing area and perimeter implementation

# This will raise an error
rectangle = Rectangle(5, 10)
TypeError: Can't instantiate abstract class Rectangle with abstract methods area, perimeter

Méthodes des classes abstraites en Python

En Python, la définition d'une classe abstraite implique l'utilisation du décorateur abstractmethod et la création d'une sous-classe à partir de ABC. Ce faisant, les programmeurs peuvent jeter les bases d'autres classes en définissant les méthodes qui doivent être utilisées. 

Voici une procédure complète, étape par étape :

• Apportez les modules nécessaires : L'importation de ABC et abstractmethod à partir du moduleABC doit être effectuée en premier lieu. Ces outils sont nécessaires pour définir des classes et des méthodes abstraites.
• Construisez une classe basée sur ABC: Créez une nouvelle classe et définissez ABC comme son héritier. La classe est abstraite et ne peut être instanciée directement, comme l'indique cet héritage.
• Définir des méthodes abstraites à l'aide de @abstractmethod: Pour spécifier les méthodes que les sous-classes doivent remplacer, utilisez le décorateur @abstractmethod. Essentiellement, ces méthodes servent de placeholders, garantissant que toutes les classes dérivées effectuent les opérations nécessaires.

Exemple de définition d'une classe abstraite, étape par étape

Voici un exemple pratique :

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Car(Vehicle):
    def start_engine(self):
        print("Car engine started")

    def stop_engine(self):
        print("Car engine stopped")

# Instantiating the abstract class directly will raise an error
# vehicle = Vehicle()

car = Car()
car.start_engine()
car.stop_engine()

Car engine started
Car engine stopped

Cela garantit que les fonctions start_engine et stop_engine sont mises en œuvre par n'importe quelle sous-classe de véhicule.

Exemple pratique : mise en œuvre d'une classe abstraite

Jetez un coup d'œil à une illustration plus complète en utilisant une classe Vehicle:

from abc import ABC, abstractmethod

class Vehicle(ABC):
    def __init__(self, brand):
        self.brand = brand

    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Motorcycle(Vehicle):
    def start_engine(self):
        print(f"{self.brand} motorcycle engine started")

    def stop_engine(self):
        print(f"{self.brand} motorcycle engine stopped")

motorcycle = Motorcycle("Yamaha")
motorcycle.start_engine()
motorcycle.stop_engine()
Yamaha motorcycle engine started
Yamaha motorcycle engine stopped

Cela illustre la manière dont les classes abstraites permettent une certaine souplesse d'implémentation tout en imposant une interface cohérente.

Exemple de classe de base abstraite en Python

Maintenant que nous avons vu comment les classes de base abstraites définissent un contrat pour les sous-classes, examinons comment les classes concrètes répondent à ces exigences en implémentant toutes les méthodes abstraites.

Classe concrète héritant d'une classe abstraite

Une sous-classe qui implémente toutes les méthodes abstraites d'une classe abstraite est appelée classe concrète. Cela signifie que la classe concrète fournit des implémentations spécifiques pour toutes les méthodes nécessaires, remplissant ainsi le contrat établi par la classe abstraite. 

Par exemple :

from abc import ABC, abstractmethod

class Appliance(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class WashingMachine(Appliance):
    def turn_on(self):
        print("Washing machine is now ON")

    def turn_off(self):
        print("Washing machine is now OFF")

machine = WashingMachine()
machine.turn_on()
machine.turn_off()

Washing machine is now ON
Washing machine is now OFF

Création d'instances et application de règles

Python vous empêche d'instancier immédiatement une classe abstraite. Il s'agit d'un aspect essentiel des classes abstraites, car il garantit que toute sous-classe générée à partir de la classe abstraite adhérera au contrat nécessaire fourni par ses méthodes abstraites. 

Par exemple, un message TypeError sera envoyé si vous essayez d'instancier appliance = Appliance()

Cette limitation garantit que les classes abstraites ne fonctionnent que comme des modèles et qu'elles sont exemptes d'abus. Python permet de créer des instances de WashingMachine tout en maintenant le contrat spécifié dans Appliance en implémentant toutes les méthodes abstraites de WashingMachine. En garantissant que chaque caractéristique spécifiée dans la classe abstraite est entièrement mise en œuvre dans ses sous-classes concrètes, cette application améliore l'intégrité de la base de code.

Propriétés abstraites et initialisation

Sur cette base, nous allons examiner plus en détail comment Python prend en charge les propriétés abstraites à l'aide des décorateurs @property’ and @abstractmethod', ce qui permet aux développeurs d'assurer la cohérence des attributs avec les méthodes.

Utiliser des propriétés abstraites en Python

Les classes abstraites peuvent spécifier des propriétés que les sous-classes doivent implémenter en plus des méthodes. Cette fonctionnalité permet aux développeurs d'imposer une interface uniforme pour les propriétés que les sous-classes doivent déclarer en plus des méthodes. 

Pour garantir que chaque sous-classe fournit son implémentation, les propriétés abstraites peuvent être spécifiées à l'aide du décorateur @property en combinaison avec @abstractmethod. Cette méthode est particulièrement utile lorsque vous créez des classes qui ont besoin d'attributs en lecture seule ou calculés qui sont essentiels au fonctionnement de la classe.

Exemple : classe abstraite avec propriétés

En voici un exemple :

from abc import ABC, abstractmethod

class Animal(ABC):
    @property
    @abstractmethod
    def sound(self):
        pass

class Bird(Animal):
    @property
    def sound(self):
        return "Chirp"

bird = Bird()
print(bird.sound)

Chirp

La condition de la classe abstraite Animal est remplie par la fonction sound de la classe Bird.

Quand utiliser les classes abstraites de Python ?

Les classes abstraites sont idéales pour des scénarios tels que

• Lors de la conception de cadres ou de bibliothèques où un comportement particulier doit être appliqué: Dans les systèmes complexes, les classes abstraites peuvent établir un ensemble unifié de lignes directrices ou d'interfaces que toutes les sous-classes doivent respecter, ce qui garantit la cohérence et réduit les erreurs.
• Mise en œuvre d'API cohérentes entre les classes: Les développeurs peuvent garantir que toutes les classes dérivées offrent un moyen normalisé et prévisible de communiquer avec l'application ou la bibliothèque en définissant des méthodes abstraites.
• Fournir un cadre de base pour une hiérarchie de classes: Une hiérarchie de classes apparentées peut être créée en utilisant les classes abstraites comme guide. En autorisant la personnalisation des sous-classes et en permettant aux développeurs de déclarer des comportements et des caractéristiques partagés dans la classe abstraite, cette structure encourage la réutilisation et minimise la duplication.

Meilleures pratiques

Lorsqu'un contrat précis doit être établi pour les sous-classes, utilisez des classes abstraites. Les classes abstraites sont utiles lorsque vous devez appliquer une structure ou un comportement spécifique à plusieurs classes dérivées. Elles permettent de s'assurer que chaque sous-classe adhère à une conception standard, ce qui améliore la prévisibilité du code et facilite la maintenance.

Si chaque méthode peut avoir une implémentation par défaut, n'utilisez pas de classes abstraites. Dans certaines situations, une classe de base concrète peut être une meilleure option pour réduire la complexité tout en préservant la possibilité de réutiliser des fonctionnalités partagées.

Veillez à ce que les classes abstraites soient claires et simples, en ne définissant que les attributs et les méthodes les plus importants. La construction et la maintenance d'une classe abstraite peuvent s'avérer difficiles si elle comporte trop de critères. Concentrez-vous plutôt sur les aspects essentiels que les classes dérivées doivent posséder.

Conclusion

La boîte à outils OOP de Python comprend des classes abstraites, qui constituent un outil puissant permettant aux programmeurs de créer des programmes fiables et faciles à maintenir. Vous pouvez favoriser la clarté, la réutilisation et l'extensibilité de vos applications en définissant des classes abstraites et en imposant une interface uniforme aux sous-classes à l'aide du module ABC. La mise en œuvre de classes abstraites permet d'écrire un code plus fiable et de meilleure qualité, quelle que soit la taille du système sur lequel vous travaillez.

Que vous conceviez des programmes orientés objet robustes, que vous appliquiez des interfaces cohérentes ou que vous créiez des applications évolutives, la maîtrise des classes abstraites de Python améliore votre capacité à écrire un code efficace et facile à maintenir. Améliorez vos connaissances en Python dès aujourd'hui grâce à notre programme complet cursus complet sur les bases de Python.