Qu'est-ce qu'une classe abstraite?

Une classe abstraite est une classe, mais pas une à partir de laquelle vous pouvez créer des objets directement. Son but est de définir à quoi les autres classes devraient ressembler, c'est-à-dire quelles méthodes et propriétés elles sont censées avoir.

Les méthodes et propriétés définies (mais non implémentées) dans une classe abstraite sont appelées méthodes abstraites et propriétés abstraites . Toutes les méthodes et propriétés abstraites doivent être implémentées dans une classe enfant afin de pouvoir créer des objets à partir de celle-ci.

Nous pouvons créer une classe abstraite en héritant de la ABCclasse qui fait partie du abcmodule .

from abc import (
  ABC,
  abstractmethod,
)

class BasicPokemon(ABC):
  def __init__(self, name):
    self.name = name
    self._level = 1
@abstractmethod
  def main_attack(self):
    ...

Que se passe-t-il si vous essayez de créer un objet BasicPokemondirectement ? TypeError!

Maintenant, vous remarquerez que BasicPokemonla __init__méthode attend un nameargument , donc le code ci-dessus n'aura pas fonctionné de toute façon. La chose à noter ici est qu'il ne va même pas à la __init__méthode pour vérifier cela. Le fait qu'il ait une méthode abstraite qui n'a pas été implémentée est prioritaire et il échoue à cause de cela !

C'est ainsi que l'on utiliserait la BasicPokemonclasse.

from collections import namedtuple

Attack = namedtuple('Attack', ('name', 'damage'))

class Pikachu(BasicPokemon):
  def main_attack(self):
    return Attack('Thunder Shock', 5)

class Charmander(BasicPokemon):
  def main_attack(self):
    return Attack('Flame Thrower', 5)

Notez que vous pouvez également créer des propriétés abstraites en utilisant le même abstractmethoddécorateur.

from abc import (
  ABC,
  abstractmethod,
)

class BasicPokemon(ABC):
  def __init__(self, name):
    self.name = name
  @property
  @abstractmethod
  def level(self):
    ...
  @abstractmethod
  def main_attack(self):
    ...

class Pikachu(BasicPokemon):
  @property
  def level(self):
    return 1
def main_attack(self):
    return Attack('Thunder Shock', 5)

Certains d'entre vous se demandent peut-être pourquoi nous ne pouvons pas simplement utiliser une classe normale (c'est-à-dire ne pas hériter de ABC) et lever un NotImplementerErrorpour les méthodes qui n'ont pas été implémentées, comme dans l'exemple ci-dessous.

class NotAbstractBasicPokemon:
  def __init__(self, name):
    self.name = name
    self._level = 1
def main_attack(self):
    raise NotImplementedError()

En revanche, essayer de créer un objet à partir de BasicPokemongénère immédiatement une erreur, comme nous l'avons vu précédemment.

Quand dois-je utiliser une classe abstraite ?

Dans l'exemple que nous avons utilisé dans cet article, BasicPokemonle but de était d'être utilisé comme modèle pour créer d'autres classes pour des types spécifiques de Pokémon. Il y a quelques avantages évidents à avoir une classe abstraite dont tout le monde doit hériter pour créer un nouveau Pokémon :

• Éviter la duplication de code.
• Assurez la cohérence dans la façon dont les autres implémentent les sous-classes.
• Assurez-vous que personne n'oublie d'implémenter des méthodes et des propriétés critiques dans les sous-classes.

Conclusion

Dans cet article, nous avons examiné les classes abstraites de Python et comment elles nous permettent de décrire comment nous nous attendons à ce que les sous-classes soient implémentées et avertissent les utilisateurs (c'est-à-dire d'autres programmeurs ou nous-mêmes futurs) lorsque des parties critiques ne sont pas définies.

• Suivez-moi sur Medium pour les mises à jour.
• Rejoignez Medium avec mon lien de parrainage pour un accès illimité aux publications. Votre cotisation me soutient directement, ainsi que les auteurs que vous lisez.

[1]https://docs.python.org/3/library/abc.html

[2]https://realpython.com/python-interface/

Plus du même auteur.

Calcul de à l'aide de simulations de Monte-Carlo