method - python multiple inheritance

Python: hereda la superclase__init__

Question

Tengo una clase base con muchos argumentos __init__ :

def BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

Todas las clases __init__ deben ejecutar el método __init__ de la clase base.

Puedo escribir un __init__() en cada una de las clases __init__ que llamarían a la superclase __init__ , pero sería una duplicación de código grave:

def A(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

def B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

def C(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

...

¿Cuál es la forma más pitonica de llamar automáticamente a la superclase __init__ ?

Answer 1

A menos que esté haciendo algo útil en los __init__() la subclase __init__() , no tiene que anularlo.

def BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

def A(BaseClass):
    def some_other_method(self):
        pass

def B(BaseClass):
    pass

Answer 2

Agregar una implementación Pythonic. Suponiendo que desea que todos los atributos pasen, puede usar el siguiente código. (También puede mantener / eliminar claves kwargs específicas si quiere un subconjunto).

def A(BaseClass):
    def __init__(self, *args, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

base = BaseClass(...)
new = A( **base.__dict__ )

Answer 3

En las versiones 2.6 y inferior para heredar init de la clase base, no hay super función, puede heredar de la siguiente manera:

class NewClass():
     def __init__():
         BaseClass.__init__(self, *args)

Answer 4

Quizás una implementación más clara para su caso es usar ** kwargs combinado con nuevos argumentos agregados en su clase derivada como en:

class Parent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c


class Child(Parent):
    def __init__(self, d, **kwargs):
        super(Child, self).__init__(**kwargs)
        self.d = d

Con este método evita la duplicación de código pero conserva la adición implícita de argumentos en su clase derivada.

Answer 5

Si las clases derivadas no implementan nada más allá de lo que ya hace la clase base __init__() , simplemente omita las clases derivadas __init__() métodos - la clase base __init__() se llama automáticamente.

Si, OTOH, tus clases derivadas agregan algo de trabajo adicional en su __init__() , y no quieres que llamen explícitamente a su clase base __init__() , puedes hacer esto:

class BaseClass(object):
    def __new__(cls, a, b, c, d, e, f, ...):
        new = object.__new__(cls)
        new._a=a+b
        new._b=b if b else a
        ...
        return new

class A(BaseClass):
    '''''' no __init__() at all here ''''''

class B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        '''''' do stuff with init params specific to B objects ''''''

Como __new__() siempre se llama automáticamente, no se requiere más trabajo en las clases derivadas.

Answer 6

Tienes que escribirlo explícitamente, pero, por otro lado, si tienes muchos argumentos, probablemente deberías usar * args para posicionales args y ** kwargs para palabras clave args.

class SubClass(BaseClass):
    def __init__(self, *args, **kwargs):
        super(SubClass, self).__init__(*args, **kwargs)
        # SubClass initialization code

Otra técnica que puede usar es minimizar el código en init y luego, al final de la función init , llamar a otra función personalizada. Luego, en la subclase, solo tiene que anular la función personalizada

class BaseClass(object):
    def __init__(self, *args, **kwargs):
        # initialization code
        self._a = kwargs.get(''a'')
        ...
        # custom code for subclass to override
        self.load()

    def load():
        pass

class SubClass(BaseClass)
    def load():
        # SubClass initialization code
        ...

Answer 7

super(SubClass, self).__init__(...)

Considere usar * args y ** kw si ayuda a resolver su pesadilla variable.