Tutoriel Classes abstraites en Python (12)

Python est langage de développement devenu très populaire dans le développement d’application. Nous allons continuer à avancer en regardant la notion de classes abstraites en python et comment les manipuler.

Précédent tutoriel : #11 – Héritage

Ce tutoriel est également disponible en vidéo :

Classes abstraites

Une classe abstraite en programmation orientée objet (POO) est une classe qui ne peut pas être instanciée elle-même et qui sert de modèle pour d’autres classes. Elle peut contenir des méthodes abstraites, c’est-à-dire des méthodes qui n’ont pas de corps dans la classe abstraite et doivent être implémentées par les classes filles.

Voici quelques caractéristiques clés des classes abstraites :

1. Non instanciable : On ne peut pas créer d’objets directement à partir d’une classe abstraite. Elle sert de modèle pour d’autres classes.

2. Méthodes abstraites : Une classe abstraite peut contenir des méthodes abstraites. Ces méthodes n’ont pas de définition dans la classe abstraite, mais toutes les classes dérivées doivent les implémenter. Cela permet de définir une interface commune pour plusieurs classes.

3. Héritage : Les classes qui héritent d’une classe abstraite doivent fournir des implémentations pour toutes les méthodes abstraites de la classe parente.

Exemple :

from abc import ABC

class Aliment(ABC):
    nom = ''

    def afficheNom():
        print('Aliment')

banane = Aliment('banane') 

banane.afficheNom()

Pour faire une classe abstraite en Python il faut importer un nouveau module. Pour insérer un module complémentaire il faut écrire en début de programme : from abc import ABC.

Afin que la classe bénéficie cette abstraction, il faut hériter la classe à ABC afin de devenir une classe abstraite d’où la ligne Aliment(ABC):.

En revanche, la classe perdant sa notion d’instance, les méthodes de la classe abstraite ne peuvent plus passer le self qui est ma propre instance par défaut. C’est la raison du pourquoi, nous l’avons enlevé dans def afficheNom():. Ceci est vrai car nous essayons de créer un objet à partir de la classe Aliment.

Cependant en l’état c’est assez limité car nous pouvons bel et bien instancier la méthode de la classe mère si elle est surchargée par la classe fille. Il faudra alors lui indiquer en premier paramètre self car celle-ci sera appelée à partir d’une classe instanciée.

from abc import ABC

class Aliment(ABC):
    nom = ''

    def afficheNom(self):
        print(self.nom)

class Fruit(Aliment):
    estFruite = ''

    def __init__ (self, nom, estFruite):
        self.nom = nom
        self.estFruite = estFruite

    def afficheNom(self):
        super().afficheNom()

banane = Fruit('banane') 

banane.afficheNom()

Certains vous diront que pour des raisons de lisibilité, il est préférable de créer une classe intermédiaire et laisser la classe abstraite intégralement non instanciée. Je vous laisserais vous faire votre propre avis sur le sujet.

Cependant, le Python avec le module abstractmethod permet de définit également des méthodes abstraires donc des méthodes non instanciées. Les méthodes abstraites ne peuvent pas recevoir par défaut le paramètre self qui représente une instance.

Nous avons donc importé un nouveau module abstractmethod, ajoutez l’indication @abstractmethod (on appelle cela une annotation) pour appliquer cette abstraction sur la méthode afficheNom. Ceci impose alors à toutes les classes filles d’implémenter obligatoirement une méthode afficheNom(self).

from abc import ABC, abstractmethod

class Aliment(ABC):
    nom = ''

    @abstractmethod
    def afficheNom(self):
        pass

class Fruit(Aliment):
    estFruite = ''

    def __init__ (self, nom, estFruite):
        self.nom = nom
        self.estFruite = estFruite

def afficheNom(self):
      print(self.nom)

banane = Fruit('banane') 

banane.afficheNom()

Ceci est fort pratique pour imposer un modèle minimum aux classes filles qui devront toujours implémenter les méthodes définie en abstraction dans la classe abstraite. Cela permet d’éviter des erreurs de développement quand on est sur des programmes de plus en plus gros.

Les classes abstraites utilisées de cette façon deviennent des modèles imposés.

Conclusion

Nous avons vu de nouvelles notions utiles sur les objets en Python qui sont indispensables à connaitre pour faire des programmes de qualité. Nous irons plus loin dès le prochain chapitre dans notre apprentissage sur le python qui proposent encore de nombreux secrets.

Prochain chapitre : #13 – Typage d’objets