Python Language
Plug-ins en uitbreidingsklassen

mixins

In Object-georiënteerde programmeertaal is een mixin een klasse die methoden bevat voor gebruik door andere klassen zonder de bovenliggende klasse van die andere klassen te hoeven zijn. Hoe die andere klassen toegang krijgen tot de methoden van de mixin hangt af van de taal.

Het biedt een mechanisme voor meervoudige overerving door meerdere klassen de algemene functionaliteit te laten gebruiken, maar zonder de complexe semantiek van meervoudige overerving. Mixins zijn handig wanneer een programmeur functionaliteit wil delen tussen verschillende klassen. In plaats van dezelfde code steeds opnieuw te herhalen, kan de algemene functionaliteit eenvoudig worden gegroepeerd in een mixin en vervolgens worden overgenomen in elke klasse die deze vereist.

Wanneer we meerdere mixins gebruiken, zijn de volgorde van mixins belangrijk. hier is een eenvoudig voorbeeld:

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

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

class MyClass(Mixin1, Mixin2):
    pass

In dit voorbeeld noemen we MyClass en test ,

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

Resultaat moet Mixin1 zijn omdat Order van links naar rechts is. Dit kan onverwachte resultaten opleveren als er superklassen aan worden toegevoegd. Dus omgekeerde volgorde is net zo goed:

class MyClass(Mixin2, Mixin1):
    pass

Resultaat zal zijn:

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

Mixins kunnen worden gebruikt om aangepaste plug-ins te definiëren.

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.

Plug-ins met aangepaste klassen

In Python 3.6 heeft PEP 487 de speciale methode __init_subclass__ toegevoegd, die het aanpassen van klassen vereenvoudigt en uitbreidt zonder metaclasses . Bijgevolg maakt deze functie het mogelijk om eenvoudige plug-ins te maken . Hier demonstreren we deze functie door een eerder voorbeeld te wijzigen :

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]