Python Language
Classes d'extension et d'extension

Mixins

Dans un langage de programmation orienté objet, un mixin est une classe qui contient des méthodes à utiliser par d'autres classes sans devoir être la classe parente de ces autres classes. La façon dont ces autres classes accèdent aux méthodes de mixin dépend de la langue.

Il fournit un mécanisme pour l'héritage multiple en permettant à plusieurs classes d'utiliser les fonctionnalités communes, mais sans la sémantique complexe de l'héritage multiple. Les mixins sont utiles lorsqu'un programmeur souhaite partager des fonctionnalités entre différentes classes. Au lieu de répéter le même code encore et encore, les fonctionnalités communes peuvent simplement être regroupées dans un mixin, puis héritées dans chaque classe qui le requiert.

Lorsque l'on utilise plus d'un mixin, l'ordre des mixins est important. Voici un exemple simple:

class Mixin1(object):
    def test(self):
        print "Mixin1"

class Mixin2(object):
    def test(self):
        print "Mixin2"

class MyClass(Mixin1, Mixin2):
    pass

Dans cet exemple, nous appelons MyClass et la méthode de test ,

>>> obj = MyClass()
>>> obj.test()
Mixin1

Le résultat doit être Mixin1 car Order est de gauche à droite. Cela pourrait donner des résultats inattendus lorsque les super-classes y sont associées. Donc, l'ordre inverse est plus juste comme ceci:

class MyClass(Mixin2, Mixin1):
    pass

Le résultat sera:

>>> obj = MyClass()
>>> obj.test()
Mixin2

Les mixins peuvent être utilisés pour définir des plug-ins personnalisés.

class Base(object):
    def test(self):
        print("Base.")

class PluginA(object):
    def test(self):
        super().test()
        print("Plugin A.")

class PluginB(object):
    def test(self):
        super().test()
        print("Plugin B.")

plugins = PluginA, PluginB

class PluginSystemA(PluginA, Base):
    pass

class PluginSystemB(PluginB, Base):
    pass

PluginSystemA().test()
# Base.
# Plugin A.

 PluginSystemB().test()
# Base.
# Plugin B.

Plugins avec des classes personnalisées

Dans Python 3.6, PEP 487 a ajouté la méthode spéciale __init_subclass__ , qui simplifie et étend la personnalisation de classe sans utiliser de métaclasses . Par conséquent, cette fonctionnalité permet de créer des plugins simples . Ici, nous démontrons cette fonctionnalité en modifiant un exemple précédent :

class Base:
    plugins = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.plugins.append(cls)
    
    def test(self):
        print("Base.")

class PluginA(Base):
    def test(self):
        super().test()
        print("Plugin A.")
    

class PluginB(Base):
    def test(self):
        super().test()
        print("Plugin B.")

PluginA().test()
# Base.
# Plugin A.

PluginB().test()
# Base.
# Plugin B.

Base.plugins
# [__main__.PluginA, __main__.PluginB]