Comment fonctionne le super () de Python avec l'héritage multiple?

votre code, et les autres réponses, sont tout buggy. Il leur manque les appels super() dans les deux premières classes qui sont nécessaires pour que le sous-classement coopératif fonctionne.

Voici une version fixe du code:

class First(object):
    def __init__(self):
        super(First, self).__init__()
        print("first")

class Second(object):
    def __init__(self):
        super(Second, self).__init__()
        print("second")

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print("third")

l'appel super() trouve la méthode suivante dans le MRO à chaque étape, c'est pourquoi le premier et le Second doivent l'avoir aussi, sinon l'exécution s'arrête à la fin de Second.__init__() .

This c'est ce que j'obtiens:

>>> Third()
second
first
third

je voulais élaborer la réponse par lifeless un peu parce que quand j'ai commencé à lire sur la façon d'utiliser super() dans une hiérarchie d'héritage multiple en Python, je ne l'ai pas obtenu immédiatement.

ce que vous devez comprendre est que super(MyClass, self).__init__() fournit le suivant __init__ méthode selon la méthode utilisée ordonnant la méthode (MRO) algorithme dans le contexte de l'héritage complet hiérarchie .

cette dernière partie est cruciale à comprendre. Considérons l'exemple à nouveau:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

selon cet article sur L'ordre de résolution de méthode par Guido van Rossum, l'ordre de résolution __init__ est calculé (avant Python 2.3) en utilisant une "profondeur-première traversée de gauche à droite":

Third --> First --> object --> Second --> object

après suppression de tous les doublons, sauf le dernier, nous obtenez de l' :

Third --> First --> Second --> object

donc, suivons ce qui se passe quand nous instancions une instance de la classe Third , par exemple x = Third() .

1. selon MRO __init__ de troisième est appelé en premier.

2. ensuite, selon le MRO, à l'intérieur de la __init__ méthode super(Third, self).__init__() se résout à la __init__ méthode de premier, qui est appelée.

3. à l'Intérieur __init__ de Première super(First, self).__init__() appelle la __init__ de en Second lieu, parce que c'est ce que le MRO diktats!

4. à l'Intérieur __init__ de Deuxième super(Second, self).__init__() appels le __init__ de l'objet, qui ne représente rien. Après que "second" est imprimé .

5. après super(First, self).__init__() complété, "premier" est imprimé .

6. Après super(Third, self).__init__() terminé", 1519580920" "c'est elle" est imprimé .

Cela en détail pourquoi l'instanciation de Troisième() des résultats pour :

>>> x = Third()
second
first
that's it

l'algorithme MRO a été amélioré à partir de Python 2.3 Pour bien fonctionner dans les cas complexes, mais je suppose que l'utilisation de la " profondeur-d'abord de gauche à droite traversal " + "supprimer les doublons expect for the last" fonctionne toujours dans la plupart des cas (veuillez commenter si ce n'est pas le cas). N'oubliez pas de lire le billet du blog de Guido!

ceci est connu comme le Diamond Problem , la page a une entrée sur Python, mais en bref, Python appellera les méthodes de la superclasse de gauche à droite.

C'est à la façon dont j'ai résolu à la question d'avoir l'héritage multiple avec des variables différentes pour l'initialisation et d'avoir des MixIns multiples avec le même appel de fonction. J'ai dû ajouter explicitement des variables à passed * * kwargs et ajouter une interface MixIn pour être un endpoint pour les super appels.

ici A est une classe de base extensible et B et C sont des classes de MixIn tous les deux qui fournissent la fonction f . A et B les deux attendent le paramètre v dans leur __init__ et C attend w . La fonction f prend un paramètre y . Q hérite des trois classes. MixInF est l'interface de mixin pour B et C .

• Carnet IPython De Ce Code
• Github Repo avec Exemple de code

class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

je comprends que cela ne répond pas directement à la question super() , mais je pense que c'est assez pertinent pour le partager.

il y a aussi une façon d'appeler directement chaque classe héritée:

class First(object):
    def __init__(self):
        print '1'

class Second(object):
    def __init__(self):
        print '2'

class Third(First, Second):
    def __init__(self):
        Second.__init__(self)

il suffit de noter que si vous le faites de cette façon, vous devrez appeler chacun manuellement car je suis assez sûr que First 's __init__() ne sera pas appelé.

à propos de le commentaire de @calfzhou , vous pouvez utiliser, comme d'habitude, **kwargs :

exemple de fonctionnement en ligne

class A(object):
  def __init__(self, a, *args, **kwargs):
    print("A", a)

class B(A):
  def __init__(self, b, *args, **kwargs):
    super(B, self).__init__(*args, **kwargs)
    print("B", b)

class A1(A):
  def __init__(self, a1, *args, **kwargs):
    super(A1, self).__init__(*args, **kwargs)
    print("A1", a1)

class B1(A1, B):
  def __init__(self, b1, *args, **kwargs):
    super(B1, self).__init__(*args, **kwargs)
    print("B1", b1)


B1(a1=6, b1=5, b="hello", a=None)

résultat:

A None
B hello
A1 6
B1 5

vous pouvez également les utiliser positionnellement:

B1(5, 6, b="hello", a=None)

mais vous devez vous rappeler le MRO, c'est vraiment déroutant.

je peux être un peu agaçant, mais j'ai remarqué que les gens ont oublié chaque fois pour utiliser *args et **kwargs quand ils outrepassent une méthode, alors que c'est l'un des rares vraiment utile et saine utilisation de ces 'variables magiques'.

un autre point non encore couvert est les paramètres d'initialisation des classes. Depuis la destination de super dépend de la sous-classe la seule bonne façon de passer les paramètres d'emballage tous ensemble. Alors attention à ne pas avoir le même nom de paramètre avec des significations différentes.

exemple:

class A(object):
    def __init__(self, **kwargs):
        print('A.__init__')
        super().__init__()

class B(A):
    def __init__(self, **kwargs):
        print('B.__init__ {}'.format(kwargs['x']))
        super().__init__(**kwargs)


class C(A):
    def __init__(self, **kwargs):
        print('C.__init__ with {}, {}'.format(kwargs['a'], kwargs['b']))
        super().__init__(**kwargs)


class D(B, C): # MRO=D, B, C, A
    def __init__(self):
        print('D.__init__')
        super().__init__(a=1, b=2, x=3)

print(D.mro())
D()

donne:

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D.__init__
B.__init__ 3
C.__init__ with 1, 2
A.__init__

appelant la classe super __init__ directement à plus directe l'assignation des paramètres est tentante mais échoue s'il y a un appel super dans une super classe et/ou le MRO est modifié et la classe a peut être appelée plusieurs fois, selon l'implémentation.

pour conclure: l'héritage coopératif et les paramètres super et spécifiques pour l'initialisation ne fonctionnent pas très bien ensemble.

Global

en supposant que tout descend de object (vous êtes seul si ce n'est pas le cas), Python calcule un ordre de résolution de méthode (MRO) basé sur votre arbre d'héritage de classe. Le MRO satisfait 3 propriétés:

• les Enfants d'une classe de venir avant que leurs parents
• les parents de gauche viennent avant les parents de droite
• d'Une classe n'apparaît qu'une fois dans le MRO

si un tel ordre n'existe pas, des erreurs Python. Le fonctionnement interne de ceci est une linéarisation C3 de l'ascendance des classes. Tout savoir ici: https://www.python.org/download/releases/2.3/mro /

Ainsi, dans les deux exemples ci-dessous, c'est:

1. enfant
2. à gauche
3. Droit
4. Parent

Lorsqu'une méthode est appelée, la première occurrence de cette méthode dans le MRO est celui qui est appelé. Toute classe qui implémente cette méthode est ignorée. Tout appel à super dans le cadre de cette méthode appellera la prochaine occurrence de cette méthode dans le BM. Par conséquent, il importe à la fois quel ordre vous placez les classes dans l'héritage, et où vous mettez les appels à super dans les méthodes.

avec super premier dans chaque méthode

class Parent(object):
    def __init__(self):
        super(Parent, self).__init__()
        print "parent"

class Left(Parent):
    def __init__(self):
        super(Left, self).__init__()
        print "left"

class Right(Parent):
    def __init__(self):
        super(Right, self).__init__()
        print "right"

class Child(Left, Right):
    def __init__(self):
        super(Child, self).__init__()
        print "child"

Child() sorties:

parent
right
left
child

avec super dernier dans chaque méthode

class Parent(object):
    def __init__(self):
        print "parent"
        super(Parent, self).__init__()

class Left(Parent):
    def __init__(self):
        print "left"
        super(Left, self).__init__()

class Right(Parent):
    def __init__(self):
        print "right"
        super(Right, self).__init__()

class Child(Left, Right):
    def __init__(self):
        print "child"
        super(Child, self).__init__()

Child() sorties:

child
left
right
parent

class First(object):
  def __init__(self, a):
    print "first", a
    super(First, self).__init__(20)

class Second(object):
  def __init__(self, a):
    print "second", a
    super(Second, self).__init__()

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__(10)
    print "that's it"

t = Third()

sortie est

first 10
second 20
that's it

Call to Third () localise le init défini dans Third. Et appel à super dans cette routine invoque init défini en premier. MRO=[First, Second]. Maintenant appel à super dans init défini dans la première va continuer la recherche MRO et trouver init défini dans la seconde, et tout appel à super va frapper l'objet par défaut init . J'espère que cet exemple clarifie le concept.

si vous n'appelez pas super en premier. La chaîne s'arrête et vous obtiendrez le résultat suivant.

first 10
that's it

je voudrais ajouter à ce que @Visionscaper dit en haut:

Third --> First --> object --> Second --> object

dans ce cas, l'interpréteur ne filtre pas la classe de l'objet parce que celle-ci est dupliquée, mais plutôt parce que la seconde apparaît en position de tête et n'apparaît pas en position de queue dans un sous-ensemble de la hiérarchie. Alors que l'objet apparaît seulement dans les positions de queue et n'est pas considéré comme une position forte dans L'algorithme C3 pour déterminer la priorité.

le la linéarisation(mro) d'une Classe C, L (C), est le

• la Classe C
• plus la fusion de
  • linéarisation de ses parents P1, P2, .. = L (P1, P2,...) et
  • la liste de ses parents P1, P2, ..

la fusion linéarisée se fait en sélectionnant les classes communes qui apparaissent en tête de liste et non en queue depuis l'ordre les questions(deviendra clair ci-dessous)

la linéarisation du tiers peut être calculée comme suit:

    L(O)  := [O]  // the linearization(mro) of O(object), because O has no parents

    L(First)  :=  [First] + merge(L(O), [O])
               =  [First] + merge([O], [O])
               =  [First, O]

    // Similarly, 
    L(Second)  := [Second, O]

    L(Third)   := [Third] + merge(L(First), L(Second), [First, Second])
                = [Third] + merge([First, O], [Second, O], [First, Second])
// class First is a good candidate for the first merge step, because it only appears as the head of the first and last lists
// class O is not a good candidate for the next merge step, because it also appears in the tails of list 1 and 2, 
                = [Third, First] + merge([O], [Second, O], [Second])
// class Second is a good candidate for the second merge step, because it appears as the head of the list 2 and 3
                = [Third, First, Second] + merge([O], [O])            
                = [Third, First, Second, O]

donc pour une super() implémentation dans le code suivant:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

, il devient évident de savoir comment cette méthode sera résolu

Third.__init__() ---> First.__init__() ---> Second.__init__() ---> 
Object.__init__() ---> returns ---> Second.__init__() -
prints "second" - returns ---> First.__init__() -
prints "first" - returns ---> Third.__init__() - prints "that's it"