Инстанцирование суперкласса Python 3 через конструктор по умолчанию производного класса

В этом коде:

class A():
  def __init__(self, x):
    self.x = x

  def __str__(self):
    return self.x

class B(A):
  def __str__(self):
    return super().__str__()

b = B("Привет")
print(b)

Вывод: Привет.

Что происходит “под капотом”? Как конструктор по умолчанию в производном классе вызывает конструктор суперкласса? Как параметры, передаваемые объекту производного класса, сопоставляются с параметрами суперкласса?

Как конструктор по умолчанию в производном классе вызывает конструктор суперкласса?

Вы не переопределили его в B, поэтому вы унаследовали его от A. Для этого и нужно наследование.

>>> B.__init__ is A.__init__
True

В том же духе вы могли бы вообще не определять B.__str__, поскольку он ничего не делает (кроме добавления бесполезного дополнительного фрейма в стек вызовов).

Как параметры, передаваемые объекту производного класса, сопоставляются с параметрами суперкласса?

Вы, возможно, слишком много об этом думаете. Как показано выше, B.__init__ и A.__init__ идентичны. B.__init__ определяется в пространстве имен A, так как он отсутствует в пространстве имен B.

>>> B.__mro__
(__main__.B, __main__.A, object)
>>> A.__dict__["__init__"]
<function __main__.A.__init__(self, x)>
>>> B.__dict__["__init__"]
...
# KeyError: '__init__'

Что происходит “под капотом”?

Обратите внимание, что методы __init__ не являются конструкторами. Если вы ищете аналог конструкторов в других языках программирования, метод __new__ может быть более подходящим, чем __init__. Сначала будет создан экземпляр B (с помощью __new__), а затем этот экземпляр будет передан в качестве первого позиционного аргумента self в A.__init__, вместе со строковым значением “Привет” для второго позиционного аргумента x.

Первое, что значит вызвать B в первую очередь? B является экземпляром type, и экземпляры можно вызывать, когда их классы определяют __call__. type.__call__ можно рассматривать как определяемый следующим образом:

def __call__(self, *args, **kwargs):
    obj = self.__new__(self, *args, **kwargs)
    if isinstance(obj, self):
        obj.__init__(*args, **kwargs)
    return obj

Таким образом, B("привет") начинается как вызов type.__call__(B, "привет").

Внутри __call__ мы сначала пытаемся вызвать B.__new__(B, "привет"). Поскольку B.__new__ не определен, нам нужно посмотреть на порядок разрешения методов B, чтобы найти класс, который определяет __new__.

>>> B.__mro___
(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

A не определяет его, но object определяет, поэтому мы заканчиваем с

obj = object.__new__(B, "привет")

что фактически игнорирует "привет" и возвращает “обнаженный” экземпляр B (первый аргумент). *

Поскольку obj действительно является экземпляром B, isinstance возвращает True, и мы вызываем метод __init__. Снова, у obj нет атрибута __init__, поэтому мы обращаемся к порядку разрешения методов type(obj), чтобы найти его, и мы находим A.__init__. Таким образом, мы выполняем A.__init__(obj, "привет") перед тем, как наконец вернуть obj.

* Есть небольшое количество “магии”, о которой я не знаю. object.__new__ может вызвать TypeError, если он получает аргументы, которые не ожидает:

>>> object.__new__(object, "привет")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object() takes no arguments

поэтому я не уверен, как именно object.__new__(B, "привет") работает. Насколько я понимаю, наличие метода __init__ для первого аргумента достаточно для того, чтобы object.__new__ принял и проигнорировал произвольные аргументы.