Python Language
Plugin- och förlängningsklasser

Mixins

I Objektorienterat programmeringsspråk är en mixin en klass som innehåller metoder för användning av andra klasser utan att behöva vara moderklassen för de andra klasserna. Hur dessa andra klasser får tillgång till mixins metoder beror på språket.

Det tillhandahåller en mekanism för flera arv genom att låta flera klasser använda den gemensamma funktionaliteten, men utan den komplexa semantiken för flera arv. Mixins är användbara när en programmerare vill dela funktionalitet mellan olika klasser. Istället för att upprepa samma kod om och om igen, kan den vanliga funktionaliteten helt enkelt grupperas i ett mixin och sedan ärvas i varje klass som kräver det.

När vi använder mer än en mixins är Order of mixins viktigt. här är ett enkelt exempel:

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

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

class MyClass(Mixin1, Mixin2):
    pass

I det här exemplet kallar vi MyClass och test ,

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

Resultatet måste vara Mixin1 eftersom beställningen är från vänster till höger. Detta kan visa oväntade resultat när superklasser lägger till det. Så omvänd ordning är mer bra precis så här:

class MyClass(Mixin2, Mixin1):
    pass

Resultatet blir:

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

Mixins kan användas för att definiera anpassade plugins.

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 med anpassade klasser

I Python 3.6 har PEP 487 lagt till __init_subclass__ , som förenklar och utvidgar klassanpassningen utan att använda metacglas . Följaktligen möjliggör denna funktion att skapa enkla plugins . Här demonstrerar vi denna funktion genom att modifiera ett tidigare exempel :

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]