Python Language
Plugin- und Erweiterungsklassen

Mixins

In der objektorientierten Programmiersprache ist ein Mixin eine Klasse, die Methoden enthält, die von anderen Klassen verwendet werden können, ohne die Elternklasse dieser anderen Klassen zu sein. Wie diese anderen Klassen Zugang zu den Methoden des Mixins erhalten, hängt von der Sprache ab.

Es bietet einen Mechanismus für die Mehrfachvererbung, indem mehrere Klassen die gemeinsame Funktionalität verwenden können, jedoch ohne die komplexe Semantik der Mehrfachvererbung. Mixins sind nützlich, wenn ein Programmierer Funktionalität zwischen verschiedenen Klassen teilen möchte. Anstatt den gleichen Code immer und immer wieder zu wiederholen, kann die allgemeine Funktionalität einfach in einem Mixin zusammengefasst und dann in jede Klasse vererbt werden, die dies erfordert.

Wenn wir mehr als ein Mixin verwenden, ist die Reihenfolge der Mixins wichtig. Hier ist ein einfaches Beispiel:

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

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

class MyClass(Mixin1, Mixin2):
    pass

In diesem Beispiel rufen wir MyClass und test .

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

Ergebnis muss Mixin1 sein, da Order von links nach rechts ist. Dies kann zu unerwarteten Ergebnissen führen, wenn Superklassen hinzugefügt werden. Die umgekehrte Reihenfolge ist also besser so:

class MyClass(Mixin2, Mixin1):
    pass

Ergebnis wird sein:

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

Mixins können verwendet werden, um benutzerdefinierte Plugins zu definieren.

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 mit benutzerdefinierten Klassen

In Python 3.6 fügte PEP 487 die spezielle Methode __init_subclass__ hinzu, mit der die Klassenanpassung ohne Verwendung von Metaklassen vereinfacht und erweitert werden kann. Daher können mit dieser Funktion einfache Plugins erstellt werden . Hier demonstrieren wir diese Funktion durch Modifizieren eines früheren Beispiels :

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]