herencia multiple python

Python multi-herencia,__init__

Question

En cuanto a la herencia de padres múltiples, cuando llamo al super . __init__ , ¿por qué no se llama a la función __init__ de __init__ ? Gracias.

class parent(object):
    var1=1
    var2=2
    def __init__(self,x=1,y=2):
        self.var1=x
        self.var2=y

class parent2(object):
    var4=11
    var5=12
    def __init__(self,x=3,y=4):
        self.var4=x
        self.var5=y

    def parprint(self):
        print self.var4
        print self.var5

class child(parent, parent2):
    var3=5
    def __init__(self,x,y):
        super(child, self).__init__(x,y)

childobject = child(9,10)
print childobject.var1
print childobject.var2
print childobject.var3
childobject.parprint()

La salida es

9
10
5
11
12

Answer 1

Mira este ejemplo:

class Base(object): 
    def __init__(self, c):
        print(''Base called by {0}''.format(c))
        super().__init__()

class ParentA(Base):
    def __init__(self, c):
        print(''ParentA called by {0}''.format(c))
        super().__init__(''ParentA'')

class ParentB(Base):
    def __init__(self, c):
        print(''ParentB called by {0}''.format(c))
        super().__init__(''ParentB'')

class Child(ParentA, ParentB):
    def __init__(self, c):
        print(''Child called by {0}''.format(c))
        super().__init__(''Child'')

Child(''Construct'')
print(Child.mro())

Esto dará como resultado:

Child called by Construct
ParentA called by Child
ParentB called by ParentA
Base called by ParentB
[<class ''__main__.Child''>, <class ''__main__.ParentA''>, <class ''__main__.ParentB''>, <class ''__main__.Base''>, <class ''object''>]

La herencia múltiple de Python es como una cadena, en Child clase Child mro , la ParentA de ParentA es ParentB , por lo que necesita llamar a super().__init__() en ParentA para ParentB .

Si cambia super().__init__(''ParentA'') a Base.__init__(self, ''ParentA'') , esto romperá la cadena de herencia, y generará:

Child called by Construct
ParentA called by Child
Base called by ParentA
[<class ''__main__.Child''>, <class ''__main__.ParentA''>, <class ''__main__.ParentB''>, <class ''__main__.Base''>, <class ''object''>]

Más información acerca de MRO

Answer 2

Porque el parent es el siguiente en la orden de resolución de métodos (MRO) , y nunca usa super() para llamar a parent2 .

Answer 3

Si desea utilizar super en child para llamar al parent.__init__ y parent2._init__ , ambos padres __init__ s también deben llamar a super :

class parent(Base):
    def __init__(self,x=1,y=2):
        super(parent,self).__init__(x,y)   

class parent2(Base):
    def __init__(self,x=3,y=4):
        super(parent2,self).__init__(x,y)

Consulte "Super método de Python y alternativas de llamada" para obtener más detalles sobre la secuencia de llamadas a __init__ causadas por el uso de super .

class Base(object): 
    def __init__(self,*args):
        pass

class parent(Base):
    var1=1
    var2=2
    def __init__(self,x=1,y=2):
        super(parent,self).__init__(x,y)        
        self.var1=x
        self.var2=y

class parent2(Base):
    var4=11
    var5=12
    def __init__(self,x=3,y=4):
        super(parent2,self).__init__(x,y)
        self.var4=x
        self.var5=y

    def parprint(self):
        print self.var4
        print self.var5

class child(parent, parent2):
    var3=5
    def __init__(self,x,y):
        super(child, self).__init__(x,y)


childobject = child(9,10)
print childobject.var1
print childobject.var2
print childobject.var3
childobject.parprint()

Es posible que se pregunte: "¿Por qué usar Base ?". Si parent y parent2 han heredado directamente del object , entonces super(parent2,self).__init__(x,y) llamaría al object.__init__(x,y) . Eso genera un TypeError ya que el object.__init__() no toma parámetros.

Para solucionar este problema, puede crear una Base clase que acepte argumentos para __init__ pero no los pase al object.__init__ . Con parent y parent2 heredando de Base , evita el TypeError .