Classes abstraites en Python : guide du débutant

Une classe abstraite est un modèle pour les classes apparentées. Il ne peut pas être instancié mais n'est accessible que par héritage. Une sous-classe qui hérite d'une classe abstraite est requise pour implémenter ses méthodes abstraites. Sinon, le compilateur signalera une erreur.

Les méthodes abstraites sont des méthodes sans implémentation. Une classe abstraite peut avoir des méthodes abstraites ou des méthodes concrètes (normales).

Python ne prend pas directement en charge les méthodes abstraites, mais vous pouvez y accéder via le module abc (abstract base class).

Utiliser le module abc en Python

Pour définir une classe abstraite en Python, vous devez importer le module abc.

Voir l'exemple ci-dessous :

 from abc import ABC
 class AbstractClassName(ABC):
 pass

Remarquez le mot – clé pass . Ce mot-clé est utilisé pour remplacer le code vide. Le laisser de côté donnera une erreur de compilation.

Connexes : Julia fera-t-elle une offre pour le trône de Python ?

Les définitions de classe, les définitions de méthode, les boucles et les instructions if attendent des implémentations de code. Donc, les laisser de côté donne une erreur de compilation. Pour éviter cela, utilisez pass pour remplacer le code vide.

Pour définir une méthode abstraite en Python, utilisez le décorateur @abstractmethod :

 from abc import ABC, abstractmethod
 class AbstractClassName(ABC):
 @abstractmethod
 def abstractMethod(self):
 pass

À ce stade, il serait bon de mentionner que, contrairement à Java, les méthodes abstraites en Python peuvent avoir une implémentation. Cette implémentation est accessible dans la méthode de redéfinition à l'aide de la méthode super() .

 import abc
 class AbstractClass(ABC):
 def __init__(self, value):
 self.value = value
 super().__init__()
 @abc.abstractmethod
 def some_action(self):
 print("This is the parent implementation.")
 class MySubclass(AbstractClassExample):
 def some_action(self):
 super().some_action()
 print("This is the subclass implementation. ")
 x = MySubclass()
 x.some_action()

Il est intéressant de noter que vous pouvez définir un constructeur dans une classe abstraite.

À la ligne 9, vous pouvez observer que @abc.abstractmethod a été utilisé comme décorateur de méthode abstraite. C'est une autre façon de le faire que la forme précédente. Notez également que la ligne 1 est plus courte ( import abc ) que l'ancienne ligne 1 import que vous avez utilisée.

Tout est une question de choix. Cependant, beaucoup peuvent trouver la deuxième méthode plus courte.

Gestion des exceptions en Python

Notez qu'il n'y a aucun moyen de capturer les erreurs dans l'exemple de code donné ci-dessus. Les bugs se produisent le plus souvent, et avoir un moyen fiable de les obtenir peut changer la donne.

Ces événements qui perturbent le déroulement normal du programme sont appelés « exceptions » et leur gestion est appelée « traitement des exceptions ». Le prochain sur votre liste de lecture Python devrait être la gestion des exceptions.