Bawiłem się z dziedziczeniem wielokrotnym w Pythonie i przechodziłem przez sytuację, w której nie mogę zrozumieć, jak to się stało.

Oto układ dziedziczenia:

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

Diament ABCD, który wszyscy znają. Plus dodatkowa klasa „F” Wrzucam to dla zabawy.

Oto kod:

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

wydajność:

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

Kolejność rozwiązywania metody:

>>> 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 zamiastfoo from C, call from Dfoo from F, call from A po prostu mnie wyrzuć ...

Wygląda na tosuper() są powiązane łańcuchowo zgodnie z kolejnością rozwiązywania metod i ignorują relacje między klasami, ale nie jestem pewien.

Czy ktoś może wskazać mi właściwy kierunek, aby zrozumieć to zachowanie?

Pamiętaj, że staram się zrozumieć sam język. Nie próbuję rozwiązać praktycznego problemu. Więc nie mam na to przypadku. Ale będzie miło, jeśli ktoś wskaże przypadek użycia :)

AKTUALIZACJA:

Podsumowując - super () po prostu daje ci znać, co jest obok bazy wywoławczej na mro. Nie jest to konieczne dla rodzica. Podczas gdy mro zbudowana baza na hierarchii dziedziczenia, sama mro nie jest hierarchią dziedziczenia.