herencia múltiple de python de diferentes rutas con el mismo nombre de método

Question

Con el siguiente ejemplo de código, ¿se puede usar super, o C tiene que llamar A.foo y B.foo explícitamente?

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() nunca dejará de resolver un solo tipo de clase de un método dado, así que si estás heredando de múltiples clases y quiere llamar al método de los dos, que' tendré que hacerlo explícitamente

Answer 2

Si añade lo siguiente:

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() 

Entonces super (C, la auto) .foo() se refiere a A.foo

La salida es

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

[Editar: Incluir información y enlaces adicionales]

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

Answer 3

Super llamará al método foo en la "primera" superclase. Esto se basa en la Orden de resolución de método (__mro__) para la clase C.

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

Por lo tanto si se llama a super(C, self).foo(), A.foo se llama. Si cambia la orden de herencia a class C(B, A):, se invierte. El __mro__ se ve ahora como:

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

Si llama super(C, self).foo() después de hacer este cambio, B.foo() será llamado.

Answer 4

super está diseñado para esta situación, pero solo funciona si lo usa de forma coherente. Si las clases base tampoco usan super, no funcionará, y a menos que el método esté en object, debe usar algo así como una clase base común para finalizar la cadena de llamadas 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 pregunta por qué tiene que haber una base común:

Sin FooBase que implementa foo pero no llama super() la última clase que llaman super() obtendrá un error atributo ya que no hay método base para llamar.

Si hubo clases base separadas class A(AFooBase): y class B(BFooBase): la llamada super() en A llamaría el método en el AFooBase y el método de B nunca ser llamado. Cuando la base es común a todas las clases, va al final del orden de resolución del método y puede estar seguro de que no importa cómo se definan las clases, el método de clase base será el último llamado.

Answer 5

Esto es posible con 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

Como dijo Duncan anteriormente, se pueden obtener resultados predecibles especialmente si se utiliza super() de forma coherente.

Los resultados de la prueba siguiente fueron útiles para mí:

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()' 

Esto imprimirá:

>>> 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

Gracias por todos aquellos contribuido a este hilo. Para resumir:

• The (currently) accepted answer es inexacta. La descripción correcta debería ser: super() NO SÓLO es bueno para resolver herencia individual, PERO TAMBIÉN herencias múltiples. Y la razón está bien explicado en el comentario @blckknght 's:

  Mientras una llamada explícita a los métodos de la clase base puede funcionar para escenarios muy simples como el ejemplo de la pregunta, se descompone si las clases de base en sí heredan de una común base y no quiere que el método de la última clase base sea llamado dos veces. Esto se conoce como "herencia de diamantes" y es un gran problema para muchos sistemas de herencia múltiple (como en C++). La herencia múltiple colaborativa de Python (con super()) le permite resolverla fácilmente en muchos casos (aunque eso no quiere decir que una jerarquía de herencia múltiple cooperativa sea fácil de diseñar o siempre una buena idea).

• La manera correcta, como @duncan pointed out, es usar super(), pero úselo consistentemente.

  super está diseñado para esta situación, pero solo funciona si lo usa de forma coherente. Si las clases base tampoco usan super, no funcionará, y a menos que el método esté en object, debe usar algo así como una clase base común para finalizar la cadena de llamadas 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 
  

  Pero es también vale la pena señalar que, el orden llamando al método puede no parecer intuitivo. El resultado es:

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

  Y el motivo de este orden aparentemente extraño se basa en MRO. As @Manoj-Govindan pointed out,

  super() llamará al método foo en la "primera" superclase. Esto se basa en la Orden de resolución de método (__mro__) para la clase C.

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

• Como regla general, si desea viajar de regreso a todos los métodos de los padres, pero no le importa realmente el orden de invocación, utiliza super() consisently. De lo contrario, puede optar por llamar explícitamente a los métodos principales en un orden específico.

• No mezcle el uso de super() y llamadas explícitas. De lo contrario, terminará duplicación desagradable como se menciona en this answer.

PD: He votado la mayoría de las fuentes mencionadas anteriormente.