Как Python super делает правильные вещи?

Я предоставил несколько ссылок ниже, которые отвечают на ваш вопрос более подробно и точнее, чем я когда-либо мог надеяться. Однако я отвечу и на ваш вопрос своими словами, чтобы сэкономить вам время. Поставлю в баллах -

1. super — это встроенная функция, а не атрибут.
2. Каждый тип (класс) в Python имеет атрибут __mro__, который хранит порядок разрешения методов для этого конкретного экземпляра.
3. Каждый вызов super имеет вид super(type[, object-or-type]). Предположим, что второй атрибут является объектом на данный момент.
4. В начальной точке супервызовов объект имеет тип производного класса (скажем, DC).
5. super ищет методы, которые соответствуют (в вашем случае __init__) в классах в MRO, после класса, указанного в качестве первого аргумента (в данном случае классов после DC).
6. Когда соответствующий метод найден (скажем, в классе BC1), он вызывается.
   (Этот метод должен использовать super, поэтому я предполагаю, что это так. См. Python super отлично, но не может (ссылка ниже) Затем этот метод вызывает поиск следующего метода в MRO класса объекта справа от BC1.
7. Rinse Wash Repeat, пока не будут найдены и вызваны все методы.

Пояснение к вашему примеру

 MRO: D,B,C,A,object  

1. super(D, self).__init__() называется. isinstance(self, D) => True

2. Найдите следующий метод в MRO в классах справа от D.

   B.__init__ нашел и позвонил

3. B.__init__ звонит super(B, self).__init__().

   isinstance(self, B) => False
   isinstance(self, D) => True

4. Таким образом, MRO тот же, но поиск продолжается справа от B, т. е. объекты C, A и ищутся один за другим. Вызывается следующий найденный __init__.

5. И так далее.

Объяснение супер
http://www.python.org/download/releases/2.2.3/descrintro/#cooperation
На что следует обратить внимание при использовании super
http://fuhm.net/super-harmful/
Алгоритм MRO Python:
http://www.python.org/download/releases/2.3/mro/
документы super:
http://docs.python.org/library/functions.html
Внизу этой страницы есть хороший раздел о super:
http://docstore.mik.ua/orelly/other/python/0596001886_pythonian-chp-5-sect-2.html

Я надеюсь, что это поможет прояснить ситуацию.

Измените свой код на это, и я думаю, что это объяснит ситуацию (предположительно super смотрит, где, скажем, B находится в __mro__?):

class A(object):
    def __init__(self):
        print "A init"
        print self.__class__.__mro__

class B(A):
    def __init__(self):
        print "B init"
        print self.__class__.__mro__
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print "C init"
        print self.__class__.__mro__
        super(C, self).__init__()

class D(B, C):
    def __init__(self):
        print "D init"
        print self.__class__.__mro__
        super(D, self).__init__()

x = D()

Если вы запустите его, вы увидите:

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

Также стоит проверить Python's Super — отличный инструмент, но вы не можете его использовать.

просто предположил:

self во всех четырех методах относятся к одному и тому же объекту, то есть к классу D. поэтому в B.__init__() вызов super(B,self) знает всю алмазную родословную self и должен получить метод из «после» B. в данном случае это класс C.

super() знает полную иерархию классов. Вот что происходит внутри инициализации B:

>>> super(B, self)
<super: <class 'B'>, <D object>>

Это решает центральный вопрос,

как объект, возвращаемый super в определении инициализации D, сообщает о существовании C объекту, возвращаемому super в определении инициализации B?

А именно, в определении инициализации B self является экземпляром D и, таким образом, сообщает о существовании C. Например, C можно найти в type(self).__mro__.

Ответ Джейкоба показывает, как понять проблему, в то время как batbrat показывает детали, а hrr переходит прямо к делу.

Одна вещь, которую они не охватывают (по крайней мере, не явно) из вашего вопроса, это вот этот момент:

Однако, если вы закомментируете вызов super в функции инициализации B, ни функция инициализации A, ни C не будет вызвана.

Чтобы понять это, измените код Джейкоба на вывод стека при инициализации A, как показано ниже:

import traceback

class A(object):
    def __init__(self):
        print "A init"
        print self.__class__.__mro__
        traceback.print_stack()

class B(A):
    def __init__(self):
        print "B init"
        print self.__class__.__mro__
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print "C init"
        print self.__class__.__mro__
        super(C, self).__init__()

class D(B, C):
    def __init__(self):
        print "D init"
        print self.__class__.__mro__
        super(D, self).__init__()

x = D()

Немного удивительно видеть, что строка super(B, self).__init__() B на самом деле вызывает C.__init__(), поскольку C не является базовым классом B.

D init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
B init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
C init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
A init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
  File "/tmp/jacobs.py", line 31, in <module>
    x = D()
  File "/tmp/jacobs.py", line 29, in __init__
    super(D, self).__init__()
  File "/tmp/jacobs.py", line 17, in __init__
    super(B, self).__init__()
  File "/tmp/jacobs.py", line 23, in __init__
    super(C, self).__init__()
  File "/tmp/jacobs.py", line 11, in __init__
    traceback.print_stack()

Это происходит из-за того, что super (B, self) не 'вызывает версию базового класса B __init__'. Вместо этого это «вызов __init__ в первом классе справа от B, который присутствует в классе __mro__ self и имеет такой атрибут.

Таким образом, если вы закомментируете вызов super в функции инициализации B, стек методов остановится на B.__init__ и никогда не достигнет C или A.

Обобщить:

• Независимо от того, какой класс на него ссылается, self всегда является ссылкой на экземпляр, а его __mro__ и __class__ остаются постоянными.
• super() находит метод, ищущий классы, которые находятся справа от текущего на __mro__. Поскольку __mro__ остается постоянным, происходит то, что он ищется как список, а не как дерево или график.

Что касается последнего пункта, обратите внимание, что полное название алгоритма MRO — линеаризация суперкласса C3. То есть он сглаживает эту структуру в список. Когда происходят разные вызовы super(), они эффективно повторяют этот список.