Eu estava brincando com a herança múltipla em python e venho uma cruz uma situação que não consigo entender como isso acontece.

Aqui está o layout da herança:

    A       F
  /   \     |
 B     C    |   
  \    |   /
    \  |  /   
       D

O diamante ABCD que todos conhecem. Além disso, uma classe extra "F" eu joguei por diversão.

Aqui está o código:

class A(object):
    def foo(self, call_from):
        print "foo from A, call from %s" % call_from
        super(A, self).foo("A")

class B(A):
    def foo(self, call_from):
        print "foo from B, call from %s" % call_from
        super(B, self).foo("B")

class C(A):
    def foo(self, call_from):
        print "foo from C, call from %s" % call_from
        super(C, self).foo("C")

class F(object):
    def foo(self, call_from):
        print "foo from F, call from %s" % call_from

class D(B, C, F):
    def foo(self):
        print "foo from D"
        super(D, self).foo("D")

saída:

>>> d = D()
>>> d.foo()
foo from D
foo from B, call from D
foo from C, call from B
foo from A, call from C
foo from F, call from A

A ordem de resolução do método:

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

foo from C, call from B ao invés defoo from C, call from Dfoo from F, call from A simplesmente me jogue fora

Parece que osuper() são encadeados de acordo com a ordem de resolução do método e ignoram o relacionamento entre as classes, mas não tenho certeza.

Alguém pode me indicar a direção certa para entender esse comportamento?

Por favor, tenha em mente que estou tentando entender a linguagem em si. Não tentando resolver um problema prático. Então eu não tenho um caso de uso para isso. Mas será bom se alguém puder apontar um caso de uso :)

ATUALIZAR:

Para resumir - super () simplesmente deixa você saber o que está ao lado da base de chamada no mro. Não é necessário o pai. Embora o mro tenha como base a hierarquia de herança, o próprio mro não é a hierarquia de herança.