héritage multiple python à partir de chemins différents avec le même nom de méthode

Question

Avec l'exemple de code suivant, peut-on utiliser super ou C pour appeler A.foo et B.foo explicitement?

class A(object): 
    def foo(self): 
     print 'A.foo()' 

class B(object): 
    def foo(self): 
     print 'B.foo()' 

class C(A, B): 
    def foo(self): 
     print 'C.foo()' 
     A.foo(self) 
     B.foo(self) 

Answer 1

super() résoudra jamais qu'un seul type de classe pour une méthode donnée, donc si vous êtes héritant de plusieurs classes et que vous voulez appeler la méthode dans les deux, vous » ll faut le faire explicitement.

Answer 2

Si vous avez ajouté les éléments suivants:

class A(object): 
    def foo(self): 
     print 'A.foo()' 

class B(object): 
    def foo(self): 
     print 'B.foo()' 

class C(A, B): 
    def foo(self): 
     super(C, self).foo() 
     print 'C.foo()' 
     A.foo(self) 
     B.foo(self) 


c = C() 
c.foo() 

Ensuite super (C, auto) .foo() fait référence à A.foo

La sortie est

A.foo() 
C.foo() 
A.foo() 
B.foo() 

[Modifier: Inclure des informations et des liens supplémentaires]

• Understanding Python super() with __init__() methods
• http://www.artima.com/weblogs/viewpost.jsp?thread=237121

Answer 3

Super appellera la méthode foo sur la "première" super classe. Ceci est basé sur l'ordre de résolution de méthode (__mro__) pour la classe C.

>>> C.__mro__ 
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>) 
>>> 

Par conséquent, si vous appelez super(C, self).foo(), A.foo est appelé. Si vous modifiez l'ordre d'héritage à class C(B, A):, cela est inversé. Le __mro__ ressemble maintenant:

>>> C.__mro__ 
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>) 
>>> 

Si vous appelez super(C, self).foo() après avoir fait ce changement, B.foo() sera appelé.

Answer 4

super est en effet destiné à cette situation, mais cela ne fonctionne que si vous l'utilisez de manière cohérente. Si les classes de base n'utilisent pas toutes super cela ne fonctionnera pas, et à moins que la méthode soit dans object vous devez utiliser quelque chose comme une classe de base commune pour terminer la chaîne des appels super.

class FooBase(object): 
    def foo(self): pass 

class A(FooBase): 
    def foo(self): 
     super(A, self).foo() 
     print 'A.foo()' 

class B(FooBase): 
    def foo(self): 
     super(B, self).foo() 
     print 'B.foo()' 

class C(A, B): 
    def foo(self): 
     super(C, self).foo() 
     print 'C.foo()' 

@Marcin demande pourquoi il doit y avoir une base commune:

Sans FooBase qui implémente foo mais ne remet pas super() la dernière classe qui n'appelle super() obtiendra une erreur d'attribut car il n'y a méthode de base à appeler.

S'il y avait des classes de base séparées class A(AFooBase): et class B(BFooBase): l'appel super() en A appellerait la méthode AFooBase et la méthode B ne serait jamais appelé. Lorsque la base est commune à toutes les classes, elle va à la fin de l'ordre de résolution de la méthode et vous pouvez être certain que peu importe comment les classes sont définies, la méthode de la classe de base sera la dernière appelée.

Answer 5

Ceci est possible avec super

class A(object): 
    def foo(self): 
     print 'A.foo()' 

class B(object): 
    def foo(self): 
     print 'B.foo()' 

class C(A, B): 
    def foo(self): 
     print 'C.foo()' 
     super(C, self).foo() # calls A.foo() 
     super(A, self).foo() # calls B.foo() 

Answer 6

Comme Duncan dit ci-dessus, vous pouvez obtenir des résultats prévisibles, surtout si vous utilisez super() cohérente.

Les résultats de l'essai suivant ont été utiles pour moi:

class FooBase(object): 
    def foo(self): 
     print 'FooBase.foo()' 

class A(FooBase): 
    def foo(self): 
     print 'A.foo() before super()' 
     super(A, self).foo() 
     print 'A.foo() after super()' 

class B(FooBase): 
    def foo(self): 
     print 'B.foo() before super()' 
     super(B, self).foo() 
     print 'B.foo() after super()' 

class C(A, B): 
    def foo(self): 
     print 'C.foo() before super()' 
     super(C, self).foo() 
     print 'C.foo() after super()' 

Cette imprimera:

>>> c = C() 
>>> c.foo() 
C.foo() before super() 
A.foo() before super() 
B.foo() before super() 
FooBase.foo() 
B.foo() after super() 
A.foo() after super() 
C.foo() after super() 

Answer 7

Merci pour tous ceux qui ont contribué à ce fil. Pour résumer:

• The (currently) accepted answer est inexacte. La description correcte devrait être: super() n'est pas seulement bon pour la résolution de l'héritage unique, MAIS aussi l'héritage multiple. Et la raison est bien expliqué dans le commentaire de l » @blckknght:

  Tout en appelant explicitement les méthodes de la classe de base peut fonctionner pour des scénarios très simples comme l'exemple de l'interrogateur, elle se décomposera si les classes de base elles-mêmes héritent d'un commun base et vous ne voulez pas que la méthode de la classe de base ultime soit appelée deux fois. Ceci est connu comme "l'héritage du diamant" et c'est un gros problème pour de nombreux systèmes d'héritage multiple (comme en C++). L'héritage multiple collaboratif de Python (avec super()) vous permet de le résoudre facilement dans de nombreux cas (même si cela ne veut pas dire qu'une hiérarchie coopérative d'héritage multiple est facile à concevoir ou toujours une bonne idée).

• La bonne façon, comme @duncan pointed out, est d'utiliser super(), mais l'utiliser de manière cohérente.

  super est en effet destiné à cette situation, mais il ne fonctionne que si vous l'utilisez régulièrement. Si les classes de base n'utilisent pas toutes super cela ne fonctionnera pas, et à moins que la méthode soit dans object vous devez utiliser quelque chose comme une classe de base commune pour terminer la chaîne des appels super.

  class FooBase(object): 
      def foo(self): pass 
  
  class A(FooBase): 
      def foo(self): 
       super(A, self).foo() 
       print 'A.foo()' 
  
  class B(FooBase): 
      def foo(self): 
       super(B, self).foo() 
       print 'B.foo()' 
  
  class C(A, B): 
      def foo(self): 
       super(C, self).foo() 
       print 'C.foo()' 
  
  C().foo() # Run this 
  

  Mais il est également intéressant de souligner que, la méthode pour appeler peut ne pas sembler intuitive. Le résultat est:

  B.foo() 
  A.foo() 
  C.foo() 
  

  Et la raison de cet ordre apparemment étrange est basé sur MRO. As @Manoj-Govindan pointed out,

  super() appellera la méthode foo sur la "première" super classe. Ceci est basé sur l'ordre de résolution de méthode (__mro__) pour la classe C.

  >>> C.__mro__ 
  (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>) 
  >>> 
  

• En règle générale, si vous voulez voyager à toutes les méthodes de parents, mais ne se soucient pas vraiment l'ordre Invoke, utilisez super() consisently. Sinon, vous pouvez choisir d'appeler explicitement les méthodes parentes dans un ordre spécifique.Ne pas mélanger l'utilisation de super() et des appels explicites bien que. Sinon, vous finirez par duplication méchant comme mentionné dans this answer.

PS: J'ai augmenté la plupart des sources mentionnées ci-dessus.