This document is for an old version of Python that is no longer supported. You should upgrade and read the Python documentation for the current stable release.

# 28.8. `abc` — Classes de Base Abstraites

Nouveau dans la version 2.6.

Code source: Lib/abc.py

Le module fournit l’infrastructure pour définir les classes de bases abstraites (Abstract Base Class ou ABC en anglais) en Python, tel qu’indiqué dans la PEP 3119; voir la PEP pour la raison de son ajout à Python. (Voir également la PEP 3141 et le module `numbers` pour ce qui concerne la hiérarchie de types pour les nombres basés sur les classes de base abstraites). Par la suite nous utiliserons l’abréviation ABC (Abstract Base Class) pour désigner une classe de base abstraite.

The `collections` module has some concrete classes that derive from ABCs; these can, of course, be further derived. In addition, the `collections` module has some ABCs that can be used to test whether a class or instance provides a particular interface, for example, if it is hashable or if it is a mapping.

This module provides the following class:

class `abc.``ABCMeta`

  Métaclasse pour définir des classes de base abstraites (ABC).

  Utilisez cette métaclasse pour créer une ABC. Il est possible d’hériter d’une ABC directement, cette classe de base abstraite fonctionne alors comme une classe mixin. Vous pouvez également enregistrer une classe concrète sans lien (même une classe native) et des ABC comme « sous-classes virtuelles » – celles-ci et leur descendantes seront considérées comme des sous-classes de la classe de base abstraite par la fonction native `issubclass()`, mais les ABC enregistrées n’apparaitront pas dans leur ordre de résolution des méthodes (MRO pour Method Resolution Order en anglais). Les implémentations de méthodes définies par l’ABC ne seront pas appelable (pas même via `super()`). 1

  Les classes dont la métaclasse est `ABCMeta` possèdent les méthodes suivantes :

  `register`(subclass)

    Enregistrer subclass en tant que sous-classe virtuelle de cette ABC. Par exemple :

        from abc import ABCMeta

        class MyABC:
            __metaclass__ = ABCMeta

        MyABC.register(tuple)

        assert issubclass(tuple, MyABC)
        assert isinstance((), MyABC)

  Vous pouvez également redéfinir cette méthode dans une ABC :

  `__subclasshook__`(subclass)

    (Doit être définie en tant que méthode de classe.)

    Vérifie si subclass est considérée comme une sous-classe de cette ABC. Cela signifie que vous pouvez personnaliser le comportement de `issubclass` sans nécessiter d’appeler `register()` pour chacune des classes que vous souhaitez considérer comme sous-classe de l’ABC. (Cette méthode de classe est appelée par la méthode `__subclasscheck__()` de la classe de base abstraite).

    Cette méthode doit renvoyer `True`, `False` ou `NotImplemented`. Si elle renvoie `True`, subclass est considérée comme sous-classe de cette ABC. Si elle renvoie `False`, la subclass n’est pas considérée une sous-classe de cette ABC même si elle l’aurait été en temps normal. Si elle renvoie `NotImplemented`, la vérification d’appartenance à la sous-classe continue via le mécanisme habituel.

  Pour une illustration de ces concepts, voir cet exemple de définition de ABC :

      class Foo(object):
          def __getitem__(self, index):
              ...
          def __len__(self):
              ...
          def get_iterator(self):
              return iter(self)

      class MyIterable:
          __metaclass__ = ABCMeta

          @abstractmethod
          def __iter__(self):
              while False:
                  yield None

          def get_iterator(self):
              return self.__iter__()

          @classmethod
          def __subclasshook__(cls, C):
              if cls is MyIterable:
                  if any("__iter__" in B.__dict__ for B in C.__mro__):
                      return True
              return NotImplemented

      MyIterable.register(Foo)

  L’ABC `MyIterable` définit la méthode d’itération `__iter__()` comme méthode abstraite. L’implémentation qui lui est donnée ici peut être appelée depuis les sous-classes. La méthode `get_iterator()` fait également partie de la classe de base abstraite `MyIterable`, mais elle n’a pas à être redéfinie dans les classes dérivées non-abstraites.

  La méthode de classe `__subclasshook__()` définie ici dit que toute classe qui possède la méthode `__iter__()` dans son `__dict__` (ou dans une de ses classes de base, accédée via la liste `__mro__`) est considérée également comme un `MyIterable`.

  Enfin, la dernière ligne fait de `Foo` une sous-classe virtuelle de `MyIterable`, même si cette classe ne définit pas de méthode `__iter__()` (elle utilise l’ancien protocole d’itération qui se définit en termes de `__len__()` et `__getitem__()`). A noter que cela ne rendra pas le `get_iterator` de `MyIterable` disponible comme une méthode de `Foo`, `get_iterator` est donc implémenté séparément.

It also provides the following decorators:

`abc.``abstractmethod`(function)

  Un décorateur marquant les méthodes comme abstraites.

  Using this decorator requires that the class’s metaclass is `ABCMeta` or is derived from it. A class that has a metaclass derived from `ABCMeta` cannot be instantiated unless all of its abstract methods and properties are overridden. The abstract methods can be called using any of the normal “super” call mechanisms.

  Python ne gère pas l’ajout dynamique de méthodes abstraites à une classe, il n’est pas non plus possible de modifier l’état d’abstraction d’une méthode ou d’une classe une fois celle-ci créée. `abstractmethod()` n’affecte que les sous-classes dérivées utilisant l’héritage classique. Les « sous-classes virtuelles » enregistrées avec la méthode `register()` de l’ABC ne sont pas affectées.

  Utilisation :

      class C:
          __metaclass__ = ABCMeta
          @abstractmethod
          def my_abstract_method(self, ...):
              ...

  Note

  Contrairement aux méthodes abstraites Java, ces méthodes abstraites peuvent être implémentées. Cette implémentation peut être appelée via le mécanisme `super()` depuis la classe qui la redéfinit. C’est typiquement utile pour y appeler super et ainsi coopérer correctement dans un environnement utilisant de l’héritage multiple.

`abc.``abstractproperty`([fget[, fset[, fdel[, doc]]]])

  Sous-classe de `property()`, qui indique une propriété abstraite.

  Using this function requires that the class’s metaclass is `ABCMeta` or is derived from it. A class that has a metaclass derived from `ABCMeta` cannot be instantiated unless all of its abstract methods and properties are overridden. The abstract properties can be called using any of the normal “super” call mechanisms.

  Utilisation :

      class C:
          __metaclass__ = ABCMeta
          @abstractproperty
          def my_abstract_property(self):
              ...

  This defines a read-only property; you can also define a read-write abstract property using the “long” form of property declaration:

      class C:
          __metaclass__ = ABCMeta
          def getx(self): ...
          def setx(self, value): ...
          x = abstractproperty(getx, setx)

Notes

1

  Les développeurs C++ noteront que le concept Python de classe de base virtuelle ( virtual base class ) n’est pas le même que celui de C++.