Appeler la classe des parents init avec l'héritage multiple, Quelle est la bonne façon?

la réponse à votre question dépend d'un aspect très important: vos classes de base sont-elles conçues pour l'héritage multiple?

il y a 3 scénarios différents:

1. les classes de base sont indépendantes et indépendantes.

   si vos classes de base sont des entités séparées qui sont capables de fonctionner indépendamment et ils ne se connaissent pas, ils sont Non conçu pour l'héritage multiple.

   Dans ce cas, vous devrez appeler chaque constructeur parent manuellement. C'est plus facile sans super .

   exemple:

   class Foo:
       def __init__(self):
           self.foo = 'foo'
   
   class Bar:
       def __init__(self, bar):
           self.bar = bar
   
   class FooBar(Foo, Bar):
       def __init__(self, bar='bar'):
           Foo.__init__(self)  # explicit calls without super
           Bar.__init__(self, bar)
   
           # To get the same results with `super`, you'd have to do this:
           #   super().__init__()
           #   super(Foo, self).__init__(bar)
           # Which is obviously much less intuitive.
   

   Important: notez que ni Foo ni Bar n'appelle super().__init__() ! C'est pourquoi votre code n'a pas fonctionné correctement. En raison de la façon dont l'héritage de diamant fonctionne en python:

   • les classes dont la classe de base est object ne doivent pas appeler super().__init__() . Comme vous l'avez remarqué, cela briserait l'héritage multiple parce que vous finissez par appeler une autre classe __init__ plutôt que object.__init__() .
   • cela signifie également que vous devez ne jamais écrire une classe qui hérite de object et n'a pas de __init__ méthode . Pas de la définition d'un La méthode __init__ a le même effet que l'appel super().__init__() . Si votre classe hérite directement de object , assurez-vous d'ajouter un constructeur vide comme ceci:

.

    class Base(object):
        def __init__(self):
            pass

2. l'une des classes est un mixin.

   Un mixin est une classe conçu pour être utilisé avec plusieurs héritage. Cela signifie que nous n'avons pas à appeler les deux constructeurs parents manuellement, parce que le mixin appellera automatiquement le 2e constructeur pour nous. Puisque nous n'avons qu'à appeler un constructeur unique cette fois, nous pouvons le faire avec super pour éviter d'avoir à coder le nom de la classe mère.

   exemple:

   class FooMixin:
       def __init__(self, *args, **kwargs):
           super().__init__(*args, **kwargs)
           self.foo = 'foo'
   
   class Bar:
       def __init__(self, bar):
           self.bar = bar
   
   class FooBar(FooMixin, Bar):
       def __init__(self, bar='bar'):
           super().__init__(bar)  # a single call is enough to invoke
                                  # all parent constructors
   
           # NOTE: `FooMixin.__init__(self, bar)` would also work, but isn't
           # recommended because we don't want to hard-code the parent class.
   

   les détails importants ici sont:

   • le mixin appelle super().__init__() et passe par le biais de tous les arguments qu'il reçoit.
   • la sous-classe hérite du mélange première : class FooBar(FooMixin, Bar) . Si l'ordre des classes de base est erroné, le constructeur du mixin ne sera jamais appelé.

3. toutes les classes de base sont conçues pour l'héritage coopératif.

   les Classes conçues pour l'héritage coopératif ressemblent beaucoup à des mixins: elles passent à travers toutes les arguments pour la prochaine classe. Comme avant, il suffit d'appeler super().__init__() et tous les constructeurs parents seront appelés en chaîne.

   exemple:

   class CoopFoo:
       def __init__(self, **kwargs):
           super().__init__(**kwargs)
           self.foo = 'foo'
   
   class CoopBar:
       def __init__(self, bar, **kwargs):
           super().__init__(**kwargs)
           self.bar = bar
   
   class CoopFooBar(CoopFoo, CoopBar):
       def __init__(self, bar='bar'):
           super().__init__(bar=bar)  # pass all arguments on as keyword
                                      # arguments to avoid problems with
                                      # positional arguments and the order
                                      # of the parent classes
   

   Dans ce cas, l'ordre des classes parent n'a pas d'importance. Nous pourrions ainsi hériter de CoopBar d'abord, et le code fonctionne encore le même. Mais c'est seulement vrai parce que tous les arguments sont passés comme des arguments de mots-clés. Utiliser des arguments de position rendrait facile d'obtenir le l'ordre des arguments est erroné, il est donc d'usage que les classes coopératives n'acceptent que les arguments par mots clés.

   il s'agit également d'une exception à la règle que j'ai mentionnée plus haut: les deux CoopFoo et CoopBar héritent de object , mais ils appellent encore super().__init__() . S'ils ne le faisaient pas, il n'y aurait pas d'héritage coopératif.

résultat: l'implémentation correcte dépend des classes dont vous héritez.

le constructeur fait partie de l'interface publique d'une classe. Si la classe est conçue comme un mixin ou pour un héritage coopératif, cela doit être documenté. Si les docs ne mentionnent rien de tel, il est raisonnable de supposer que la classe n'est pas conçu pour l'héritage multiple et vous devez appeler explicitement le constructeur de chaque classe mère (sans super ).

cet article Aide à expliquer l'héritage multiple coopératif:

http://www.artima.com/weblogs/viewpost.jsp?thread=281127

il mentionne la méthode utile mro() qui vous montre l'ordre de résolution de la méthode. Dans votre deuxième exemple, où vous appelez super dans A , l'appel super se poursuit dans MRO. La classe suivante dans l'ordre est B , c'est pourquoi B init est appelé pour la première fois.

voici un article plus technique du site officiel de python:

http://www.python.org/download/releases/2.3/mro /

si vous multipliez les classes de sous-classe à partir de bibliothèques tierces, alors non, il n'y a pas d'approche aveugle pour appeler la classe de base __init__ méthodes (ou toute autre méthode) qui fonctionne réellement indépendamment de la façon dont les classes de base sont programmées.

super rend possible d'écrire des classes conçues pour mettre en œuvre de manière coopérative des méthodes dans le cadre d'arbres complexes à héritages multiples qu'il n'est pas nécessaire que l'auteur de la classe connaisse. Mais il n'y a aucun moyen de l'utiliser pour hériter correctement de classes arbitraires qui peuvent ou ne peuvent pas utiliser super .

essentiellement, si une classe est conçue pour être sous-classée en utilisant super ou avec des appels directs à la classe de base est une propriété qui fait partie de la classe" "interface publique", et elle doit être documentée en tant que telle. Si vous utilisez des bibliothèques tierces de la manière que l'auteur de la bibliothèque attendait et la bibliothèque a une documentation raisonnable, il serait normalement vous dire ce que vous devez faire à la sous-classe des choses particulières. Si ce n'est pas le cas, alors vous devrez regarder le code source pour les classes que vous sous-classez et voir ce qu'est leur convention d'invocation de classe de base. Si vous combinez plusieurs classes d'une ou plusieurs bibliothèques tierces d'une manière que les auteurs de la bibliothèque n'attendaient pas , alors il ne sera peut-être pas possible d'invoquer systématiquement les méthodes de super-classe du tout ; si la classe a fait partie de une hiérarchie utilisant super et la Classe B fait partie d'une hiérarchie qui n'utilise pas super, alors aucune des deux options n'est garantie de fonctionner. Tu devras trouver une stratégie qui fonctionne pour chaque cas particulier.

comme Raymond l'a dit dans sa réponse, un appel direct à A.__init__ et B.__init__ fonctionne bien, et votre code serait lisible.

Cependant, il n'utilise pas le lien d'héritage entre C et ces classes. L'exploitation de ce lien vous donne plus de cohérence et rend les retouches éventuelles plus faciles et moins sujettes aux erreurs. Un exemple de la façon de faire cela:

class C(A, B):
    def __init__(self):
        print("entering c")
        for base_class in C.__bases__:  # (A, B)
             base_class.__init__(self)
        print("leaving c")