Concepts avancés Python

Pour stipuler la classe mère, rien de bien compliqué. Cela se passe à la définition de la classe fille :

…
class MaClasseFille(MaClasseMere):
    …

Une fois la classe mère définie, il va vous falloir l'initialiser. Pour cela, il suffit d'appeler le constructeur de la classe mère dans le constructeur de la classe fille :

…
class MaClasseFille(MaClasseMere):
    def __init__(self):
        MaClasseMere.__init__(self)
        …

…
class MaClasseFille(MaClasseMere):
    def __init__(self):
        super().__init__()
        …

Surcharger un attribut est très simple, puisqu'il suffit de redéfinir sa valeur au sein de la classe fille.

…
class MaClasseFille(MaClasseMere):
    def __init__(self):
        MaClasseMere.__init__(self)
        self.attribut_classe_mere = 'nouvelle valeur'

Tout comme pour les attributs, pour surcharger une fonction, il suffit de la redéfinir.

Le MRO pour Method Resolution Order est la fonctionnalité des langages objet à héritage multiple qui permet de déterminer dans quel ordre effectuer un héritage multiple.

Le MRO repose sur un algorithme qui a été modifié dans Python 2.3. Dans un souci de rétrocompatibilité, les deux algorithmes ont vécu côte à côte, dans la branche 2. La distinction se fait alors lors de la déclaration d'une classe

class A():
    pass

class B():
    pass

class C(A, B):
    pass

class A(object):
    pass

class B(object):
    pass

class C(A, B):
    pass

Comme vous pouvez le constater, la différence se fait lors de la déclaration des classes mères. Si on explicite qu'on désire hériter de la classe « object », alors on fait systématiquement appel au nouvel algorithme lors de la création de la classe C. Dans le cas contraire, Python utilisera d'office l'ancien algorithme.

Cependant, dans la branche 3, c'est systématiquement le nouvel algorithme qui est utilisé, que l'on explicite « object » ou non.

Dans ce tutoriel, seul le nouvel algorithme sera considéré.

Afin de pouvoir déboguer lors d'erreurs avec l'héritage multiple, il est possible de connaître l'ordre d'héritage. Pour cela, on utilise la méthode « __mro__ ».

class A(object):
    pass

class B(object):
    pass

class C(A, B):
    pass

if __name__ == '__main__':
    # Attention, __mro__ est un attribut special de classe.
    # Il doit donc etre recupere depuis la classe
    print(C.__mro__)

L'exécution de ce code vous renverra

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)

Comme on peut le voir, on retrouve d'abord la classe qu'on interroge, notre classe C, puis on voit ensuite qu'on hérite de la classe A avant d'hériter de la classe B.

Ce cas est fort simple, et pour hériter à l'inverse, il suffirait d'inverser B et A dans l'ordre d'héritage. Mais cela n'est pas toujours aussi simple.

L'exemple que je vais vous proposer ici est inspiré de celui de la documentation officielle (voir le lien dans l'encadré suivant).

Nous allons effectuer des héritages multiples plus ou moins complexes qui vous montreront l'utilité de pouvoir lire l'ordre d'héritage.

class A(object):
    pass

class B(object):
    pass

class C(A, B):
    pass

class D(B,A):
    pass

class E(D,A):
    pass

try:
    class F(A,D):
        pass
except Exception as e:
    print("Voici l'erreur a la creation de la classe F")
    print(e)

if __name__ == '__main__':
    print("\nVoici l'execution du main")
    print(C.__mro__)
    print(D.__mro__)
    print(E.__mro__)

Je vous invite à exécuter ce code. Le résultat est alors le suivant :

Voici l'erreur a la creation de la classe F
Error when calling the metaclass bases
    Cannot create a consistent method resolution order (MRO) for bases D, A

Voici l'execution du main
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>)
(<class '__main__.E'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>)

Passons tout d'abord au résultat du main. Aucun souci. Nous voyons, comme vu précédemment l'ordre d'héritage.

Cela peut s'avérer utile lorsque vous utilisez une classe, sans savoir de quelles autres classes elle peut hériter.

Mais penchons-nous plus avant sur l'erreur générée au début du code. On voit qu'il est fait question de « métaclasses ». Les explications à ce sujet sont dans le chapitre suivant. Nous ferons donc l'impasse à ce sujet dans l'immédiat.

Ce qu'il faut regarder plus précisément c'est l'erreur « Cannot create a consistent method resolution order (MRO) for bases D, A ». En réalité, ce qu'il se passe, c'est que le MRO a détecté un problème d'héritage.

Si on essaie de reproduire ce que fait le MRO, cela donnerait :

(<class '__main__.F'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>)

Si on compare avec la classe E qui hérite en sens inverse :

(<class '__main__.E'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>)

Pour la classe E, on hérite deux fois de la classe A, donc la surcharge n'aura aucun effet. Le MRO l'a bien compris, et ne réalise finalement qu'un seul héritage.

Pour la classe F, on hérite aussi deux fois de la classe A. Mais entre ces deux héritages, la classe F hérite de diverses classes. Le MRO trouve cela bizarre et refuse donc la construction de la classe, et affiche un message d'erreur.

Considérons les faits suivants :

• en Python, les principaux types de variables sont int, float, str ;
• en Python, tout est objet.

À partir de cela, nous pouvons en déduire que lorsque nous créons des variables, il s'agit d'objets. Cela signifie donc que les types de ces variables (int, float et string) sont donc des classes. Ainsi quand nous écrivons

ma_string = 'Hello World!!!'

Python exécute implicitement

ma_string = str('Hello World!!!')

Je pense que vous connaissez bien la fameuse fonction « type », permettant de connaître le type d'une variable donnée. Eh bien au même titre qu'il existe une fonction pour connaître le type d'un objet, il existe une façon de connaître la classe à partir de laquelle un objet a été créé : __class__.

Voici quelques lignes saisies dans un terminal :

>>> ma_string = 'Hello World'
>>> mon_entier = 4
>>> mon_float = 5.3
>>> ma_string.__class__
<type 'str'>
>>> mon_entier.__class__
<type 'int'>
>>> mon_float.__class__
<type 'float'>
>>> str.__class__
<type 'type'>
>>> int.__class__
<type 'type'>
>>> float.__class__
<type 'type'>
>>> type.__class__
<type 'type'>

Vous ne remarquez rien ? Regardez bien. J'ai demandé les classes à partir desquelles les éléments str, int et float étaient créés. Surprise, ils héritent tous d'une classe nommée 'type'. Et si nous demandons la classe permettant la création de la classe type, Python nous renvoie… type.

Eh bien, c'est là que se trouve l'origine de notre langage adoré. 'type' est une métaclasse, LA métaclasse originelle en Python. C'est à partir d'elle que sont créées toutes les classes servant à créer des objets en Python.

Pour finir de vous convaincre, je vous invite à utiliser deux fonctions basiques de Python : 'isinstance' et 'issubclass'.

La première de ces fonctions prend deux paramètres : un objet/classe et une classe. Elle permet de vérifier si l'argument 1 est une instance de l'argument 2 (renvoie True) ou non (renvoie False).

La seconde fonction prend également deux paramètres, plus précisément deux noms de classes disponibles dans l'espace de noms. Elle permet de vérifier si l'argument 1 est une sous‑classe de l'argument 2.

Voici comment vous en servir à travers une utilisation adaptée à notre contexte :

>>> isinstance(mon_entier, int)
True
>>> issubclass(mon_entier, int)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: issubclass() arg 1 must be a class
>>> 
>>> 
>>> isinstance(int, type)
True
>>> issubclass(int,type)
False

Ce qui ressort ici, c'est que « mon_entier » est bien un objet créé à partir de la classe « int », mais n'est pas une classe.

En revanche, « int » est bien une classe (le « issubclass » ne tombe pas en erreur), mais également une instance de « type », c'est-à-dire que « int » a été créé à partir de « type ».

Cela confirme donc bien que « int » est une classe créée à partir de la métaclasse « type ». En effet, « type » est une classe qui sert à créer d'autres classes.

Nous venons donc de vérifier la définition d'une métaclasse.

Maintenant que nous avons clairement établi que la classe « type » était une métaclasse, nous allons voir comment elle fonctionne.

Cela est en effet indispensable pour bien appréhender les métaclasses.

« type » prend trois, voire quatre, arguments :

• « cls », dans certains cas, est aux classes ce que « self » est aux objets ;
• le nom de la classe à créer ;
• un tuple contenant les classes dont notre nouvelle classe va hériter ;
• un dictionnaire, lequel contiendra attributs et méthodes de notre classe.

Dans ce dernier, les clés seront les noms des méthodes ou des attributs (dont __init_₎ de la classe. Les valeurs du dictionnaire correspondront aux noms des méthodes ou attributs à utiliser.

Les conventions veulent qu'on nomme les paramètres « name », « bases » et « dct ».

type(name, bases, dct)

La théorie n'étant pas vraiment parlante, surtout dans notre cas, place à la pratique. Je vous propose de continuer avec le cas des voitures, ce type d'objet se prêtant bien aux classes.

# Dans toutes les fonctions, le premier parametre sera toujours
# le nom qui sera passe en premier argument a la classe "type"
def creation_classe_voiture(voiture, marque, modele, couleur):
    voiture.marque = marque
    voiture.modele = modele
    voiture.couleur = couleur
    voiture.phares = False
    voiture.moteur = False

def commutation_phares(voiture):
    voiture.phares = not voiture.phares
    return voiture.phares

def commutation_moteur(voiture):
    voiture.moteur = not voiture.moteur
    return voiture.moteur


if __name__ == "__main__":
    # Les classes dont on herite doivent etre placees dans un tuple.
    # Si on n'herite d'aucune classe, le tuple sera vide
    classes_dont_on_herite = ()

    # Le dictionnaire de methodes devra obligatoirement contenir
    # la methode "__init__" comme nom de constructeur.
    mes_methodes = { "__init__": creation_classe_voiture,
                     "changement_etat_phares": commutation_phares,
                     "commutation_moteur": commutation_moteur}

    # On commence par creer notre classe
    classe_voiture = type("voiture", classes_dont_on_herite, mes_methodes)

    # Puis on peut enfin s'en servir
    ma_voiture = classe_voiture("Peugeot", "504", "noir & chrome")
    print ma_voiture.commutation_moteur()
    print ma_voiture.commutation_moteur()
    print ma_voiture.changement_etat_phares()
    print ma_voiture.marque
    print ma_voiture.modele
    print ma_voiture.couleur

Comme le montre ce code, à partir de simples fonctions, et de la métaclasse « type », nous avons pu créer une classe « voiture ».

Mais il n'y a là rien de forcément compliqué maintenant désormais pour vous. Il est en revanche plus compliqué de créer sa propre métaclasse que d'en utiliser une.

L'exemple qui suit est inspiré de celui de Wikipédiahttps://fr.wikipedia.org/wiki/M%C3%A9taclasse#Autre_exemple, dans la mesure où cet exemple est proche de l'utilisation typique qui est faite, en général, des métaclasses : tracer les appels de méthodes.

Voici le code en Python 2.x :

from types import FunctionType


# Definition de notre metaclasse
class Tracer(type):
    def __new__(cls, name, bases, dct):
        print("name= %s" %(name))
        print("bases= %s" %(bases))
        print("methodes= %s" %(dct))

        def _wrapper(method):
            def _trace(self, *args, **kwargs):
                print("(call %s with *%s **%s)" % (method.__name__, str(args), kwargs))
                return method(self, *args, **kwargs)
            # On ne change ni le nom, ni la docstring de la classe
            _trace.__name__ = method.__name__
            _trace.__doc__  = method.__doc__
            _trace.__dict__.update(method.__dict__)
            # Notre methode de substitution est prete. On la retourne.
            return _trace

        newDct = {}
        for name, method in dct.items():
            # La ligne suivante permet de savoir si on a affaire a une methode
            # ou a un attribut
            if type(method) is FunctionType:
                print("nom de la methode= %s" % (name))
                newDct[name] = _wrapper(method)
            else:
                print("nom de l'attribut= %s" % (name))
                newDct[name] = method

        return type.__new__(cls, name, bases, newDct)




class ClasseDemo(object):
    """
        Ceci est ma classe de demo
    """
    # On definit une metaclasse qui va etre appelee a la creation de la classe ClasseDemo
    # Rien ne change dans le reste de notre classe
    __metaclass__ = Tracer

    def __init__(self, default_value):
        self.a = 1
        self._d = default_value
        self.__z = 6

    def get(self, b=0):
        return self.a * b




if __name__ == "__main__":
    # On cree une classe puis on appelle une methode et un attribut
    print("########################################################")
    print("##               Creation de la classe                ##")
    print("########################################################")
    objet = ClasseDemo(5)
    print("########################################################")
    print("##              Utilisation de la classe              ##")
    print("########################################################")
    print(objet.get(2))
    # L'appel d'un attribut ne declenche aucun tracage
    print(objet._d)

Et la même chose en Python 3.x :

from types import FunctionType


# Definition de notre metaclasse
class Tracer(type):
    def __new__(cls, name, bases, dct):
        print("name= %s" %(name))
        print("bases= %s" %(bases))
        print("methodes= %s" %(dct))

        def _wrapper(method):
            def _trace(self, *args, **kwargs):
                print("(call %s with *%s **%s)" % (method.__name__, str(args), kwargs))
                return method(self, *args, **kwargs)
            # On ne change ni le nom, ni la docstring de la classe
            _trace.__name__ = method.__name__
            _trace.__doc__  = method.__doc__
            _trace.__dict__.update(method.__dict__)
            # Notre methode de substitution est prete. On la retourne.
            return _trace

        newDct = {}
        for name, method in dct.items():
            # La ligne suivante permet de savoir si on a affaire a une methode
            # ou a un attribut
            if type(method) is FunctionType:
                print("nom de la methode= %s" % (name))
                newDct[name] = _wrapper(method)
            else:
                print("nom de l'attribut= %s" % (name))
                newDct[name] = method

        return type.__new__(cls, name, bases, newDct)




class ClasseDemo(object, metaclass = Tracer):
    """
        Ceci est ma classe de demo
    """
    # On definit une metaclasse qui va etre appelee a la creation de la classe ClasseDemo
    # Rien ne change dans le reste de notre classe

    def __init__(self, default_value):
        self.a = 1
        self._d = default_value
        self.__z = 6

    def get(self, b=0):
        return self.a * b




if __name__ == "__main__":
    # On cree une classe puis on appelle une methode et un attribut
    print("########################################################")
    print("##               Creation de la classe                ##")
    print("########################################################")
    objet = ClasseDemo(5)
    print("########################################################")
    print("##              Utilisation de la classe              ##")
    print("########################################################")
    print(objet.get(2))
    # L'appel d'un attribut ne declenche aucun tracage
    print(objet._d)

Quelques commentaires concernant ce code.

Ligne 38 ou 44, nous définissons la métaclasse que nous désirons utiliser : Tracer.

Notre classe Tracer, ligne 5, ne contient qu'une unique méthode : __new__. En métaclasse, c'est généralement la seule classe utilisée.

Dans __new__, le premier argument est cls (rappel : équivalent du self pour les classes), puis viennent le nom de la classe, dont elle hérite, et le dictionnaire des méthodes.

Ligne 11, nous définissons une méthode de substitution. Le but final est de ne pas modifier le fonctionnement initial, et d'ajouter un « print » en sus.

Ligne 12, nous retrouvons donc la création de la substitution. Nous interceptons l'ensemble des arguments (nommés ou non) passés en paramètres, puis nous les affichons, avant de retourner le résultat de l'appel de la méthode initiale, ligne 14.

Ligne 16 et 17, nous récupérons le nom et la docstring de la méthode d'origine, puis nous en copions le dictionnaire, ligne 18, afin d'obtenir une copie parfaite.

Ligne 20 enfin, lorsque notre méthode de substitution est prête, nous la renvoyons à l'appelant.

L'appelant dans notre cas, est constitué de la seconde partie du code de notre métaclasse, de la ligne 22 à 33.

En effet, lorsque nous pénétrons dans la méthode __new__ de notre métaclasse, c'est cette section de code qui est exécutée en premier.

Tout d'abord, nous analysons chaque élément du dictionnaire (ligne 23). Puis, lignes 26 et 29, nous déterminons le type d'élément : attribut ou méthode. S'il s'agit d'une méthode, alors, nous appelons notre wrapper, ligne 11. Nous substituons alors notre nouvelle méthode à celle d'origine. Sinon, nous nous contentons de copier l'attribut d'origine.

Afin d'effectuer l'ensemble de ces opérations, un dictionnaire tampon est utilisé.

Enfin, une fois cette analyse et les substitutions effectuées, nous appelons, ligne 33, la métaclasse « type », en lui communiquant non pas le dictionnaire d'origine, mais le dictionnaire tampon. La classe créée est alors retournée.