Python Language
Complementos y clases de extensión

Mixins

En el lenguaje de programación orientado a objetos, una mezcla es una clase que contiene métodos para el uso de otras clases sin tener que ser la clase principal de esas otras clases. Cómo esas otras clases obtienen acceso a los métodos de la mezcla depende del idioma.

Proporciona un mecanismo para la herencia múltiple al permitir que varias clases usen la funcionalidad común, pero sin la semántica compleja de la herencia múltiple. Los mixins son útiles cuando un programador quiere compartir funcionalidad entre diferentes clases. En lugar de repetir el mismo código una y otra vez, la funcionalidad común puede simplemente agruparse en una mezcla y luego heredarse en cada clase que lo requiera.

Cuando usamos más de un mixins, el orden de los mixins es importante. Aquí hay un ejemplo simple:

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

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

class MyClass(Mixin1, Mixin2):
    pass

En este ejemplo llamamos MyClass y método de test ,

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

El resultado debe ser Mixin1 porque el orden es de izquierda a derecha. Esto podría mostrar resultados inesperados cuando las súper clases lo agreguen. Así que el orden inverso es más bueno así:

class MyClass(Mixin2, Mixin1):
    pass

El resultado será:

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

Los mixins se pueden utilizar para definir complementos personalizados.

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 con clases personalizadas

En Python 3.6, PEP 487 agregó el método especial __init_subclass__ , que simplifica y amplía la personalización de la clase sin usar metaclases . En consecuencia, esta característica permite crear complementos simples . Aquí demostramos esta característica modificando un ejemplo anterior :

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]