L’héritage

Lire la documentation ici

Les classes abstraites

Certaines classes sont abstraites: elles ne peuvent pas être instanciée. Elles servent de contrat: une implementation d’une classe abstraite doit implémenter un certain nombre de méthodes.

import abc

class iterator(abc.ABC):
    @abc.abstractmethod
    def __next__(self):
        pass

    def __iter__(self):
        return self

Pour instancier la classe iterator il faut absolument définir une méthode next:

class Constantes(iterator):
    def __init__(self, c):
        self.c = c

    def __next__(self):
        return self.c

C = Constantes(3)
print(next(C))

3

Si on ne respecte pas le contrat, cela déclanche une erreur:

class Plop(iterator):
    pass

Il est assez rare qu’on est besoin de définir des classes abstraites quand on utilise Python. Nous allons nous en servir pour simplifier l’écriture de structure de données.

Les collections abstraites

Python vient avec plusieurs structures de données concrètes

• tuple
• list
• dict
• set

Il y a également des classes abstraites pour en définir des nouvelles

Nous allons nous intéressé dans la suite aux classes abstraites suivantes:

• Iterable: implmente __iter__
• Iterator: hérite d’itérable et implémente __next__
• Container: contient des trucs implemente __contains__ (opérateur in)
• Sized: à une taille implémente __len__ (opérateur len)
• Reversible: peut changer de sens implemente __reversed__ (opérateur reversed)
• Callable: peut être utilisé comme une fonction implemente __call__

Et les structures de données de Python peuvent être redéfinit (plus simplement) grâce aux classes abstraites suivantes:

• Collection: hérite de Sized, Iterable et Container (typiquement une énumération d’éléments finis non mutable)
• Sequence: hérite de Reversible et Collection et implemente en plus __getitem__, __len__ (typiquement une suites d’éléments, la différence avec les collections c’est qu’on peut récupérer la ième valeur).
• MutableSequence: hérite de Sequence et implémente en plus __setitem__, __delitem__ et insert (la classe abstraite des listes classique)
• Set: hérite de Collection
• MutableSet: hérite de Set et implémente en plus add et discard (la classe abstraite des ensembles classiques)
• Mapping: hérite de collections et implémente en plus __getitem__
• MutableMapping: hérite de Mapping et implémente en plus __setitem__ et __delitem__ (la classe abstraite des dictionnaires)

Structures de données vs Interface

Lorsqu’on étudie des structures de données on mélange maladroitement l’interface et l’implémentation:

• L’interface: l’ensemble des opérations supportée et leur sémantique.
• L’implémentation: la manière de réaliser les opérations et leur complexité

Par exemple, quand on implémente un ensemble (type abstrait Set) on peut le faire de plusieurs manières:

• Avec des sequences ordonnées
• Avec une liste
• Avec une table de hashage
• …

Chaque implémentation a dont une efficacité différentes. À partir de maintenant nous allons étudiers les structures de données de la façon suivante:

• On aura une classe abstraites
• On évaluara la complexité des implémentation concrètes de la classe abstraites

Interface et réduction

Il est souvent possible d’implémenter une interface abstraire à l’aide d’une autre interface abstraite. Par exemple, on peut implémenter une MutableSequence avec une MutableMapping et réciproquement. On dit alors qu’on a une réduction de chaque interface. Ces réductions ont elle même une complexité qui dépend de la complexité des méthodes abstraites sous-jacentes.

Compiled the: dim. 07 janv. 2024 23:19:04 CET