Classes et méthodes abstraites

Les classes abstraites sont des classes qui ne peuvent pas être instanciées directement et qui contiennent des méthodes abstraites que les sous-classes doivent implémenter.

Imagine que c’est un formulaire : une classe abstraite ressemble à un formulaire obligatoire dont certains champs sont requis (les méthodes abstraites) et d’autres facultatifs (les méthodes concrètes). Tu ne peux pas soumettre le formulaire lui-même : tu dois d’abord remplir tous les champs requis. De même, tu ne peux pas créer d’instances d’une classe abstraite tant que toutes les méthodes abstraites n’ont pas été implémentées dans une sous-classe.

Importez le module abc pour créer des classes abstraites :

from abc import ABC, abstractmethod

Crée une classe abstraite avec des méthodes abstraites :

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass
    
    def describe(self):
        return "This is a shape"  # Méthode concrète (possède une implémentation)

Le décorateur @abstractmethod marque les méthodes qui doivent être implémentées par les sous-classes : ce sont les « champs obligatoires » de votre formulaire. Les méthodes ordinaires comme describe() peuvent avoir une implémentation et sont héritées telles quelles : ce sont les « champs préremplis ».

Pourquoi utiliser des classes abstraites ? Elles imposent un contrat. Si tu crées une classe Shape, tu affirmes que « chaque forme DOIT pouvoir calculer son aire et son périmètre ». Cela évite les bogues qui pourraient survenir si tu oubliais d’implémenter des méthodes essentielles.

Essaie de créer une instance de la classe abstraite :

# Cela provoquera une erreur :
# shape = Shape()  # TypeError: Can't instantiate abstract class

Cette erreur est intentionnelle : c’est comme essayer de soumettre un formulaire vide. Python dit : « Tu n’as pas encore rempli les champs obligatoires (les méthodes area et perimeter) ! »

Crée une sous-classe concrète qui implémente toutes les méthodes abstraites :

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14 * self.radius

Maintenant, nous avons « rempli tous les champs obligatoires » : nous avons implémenté à la fois area() et perimeter(). La classe Circle est désormais une classe concrète complète qui peut être instanciée.

Vous pouvez maintenant créer des instances de la classe concrète :

circle = Circle(5)
print(circle.area())
print(circle.perimeter())
print(circle.describe())  # Méthode concrète héritée

Crée une autre sous-classe concrète :

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width  self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

rectangle = Rectangle(4, 6)
print(rectangle.area())
print(rectangle.perimeter())

Sortie :

78.5
31.400000000000002
This is a shape
24
20

Les classes abstraites définissent un contrat que les sous-classes doivent respecter. Utilisez ABC et @abstractmethod pour créer des classes abstraites. Les sous-classes doivent implémenter toutes les méthodes abstraites, sinon elles seront elles aussi abstraites. Cela garantit la cohérence et évite les implémentations incomplètes.