Skip to content

Super - Функция super() ​

super() возвращает объект, с которого начинается поиск метода после текущего класса в MRO — то есть в «следующих» родителях. Зачем это нужно:

  1. вызвать метод родителя без его имени: super().__init__(...);
  2. сделать кооперативное множественное наследование: каждая инициализация продолжается в следующем по цепочке классе.

Простейший случай: вызов родителя ​

python
class Vehicle:
    def __init__(self, make, model):
        self.make, self.model = make, model

    def start(self):
        print(f'{self.make} {self.model}: engine ready')


class Car(Vehicle):
    def __init__(self, make, model, doors):
        super().__init__(make, model)   # вместо Vehicle.__init__(self, make, model)
        self.doors = doors

    def start(self):
        super().start()                  # базовый метод, потом свой код
        print(f'{self.doors} doors locked')


car = Car('Toyota', 'Corolla', 4)
car.start()

Почему не Vehicle.__init__(self, ...) напрямую? При простой иерархии — работает, но при множественном наследовании «именной» вызов может пропустить часть цепочки, а super() следует MRO точно.

Кооперативное наследование и mixin ​

Класс-mixin добавляет функциональность «в середину» иерархии. Чтобы он не рвал цепочку, обязан вызывать super().__init__():

python
class IM:                       # mixin: добавляет атрибут x
    def __init__(self):
        self.x = 'x'
        super().__init__()      # передать инициализацию дальше по MRO

    def add_mixin(self):
        print('mixin')


class A(IM):
    def __init__(self):
        self.a = 'a'
        super().__init__()


class B:
    def __init__(self):
        self.b = 'b'
        super().__init__()


class C(A, B):
    def __init__(self):
        super().__init__()      # старт цепи: A -> IM -> B -> object
        self.c = 'c'

MRO у C выглядит так: C → A → IM → B → object. Один вызов super().__init__() в C запускает инициализацию всех классов цепочки:

python
print(C().__dict__)   # {'a': 'a', 'x': 'x', 'b': 'b', 'c': 'c'}

Подвох: mixin без super() ​

Если в какой-то класс цепочки убрать super().__init__() (или вызвать родителя по имени с пропусками), инициализация «оборвётся» — часть атрибутов не создастся. Проверять поведение лучше сразу:

python
class BrokenA(IM):
    def __init__(self):
        self.a = 'a'
        # super().__init__()  # забыли!


class C2(BrokenA, B):
    def __init__(self):
        super().__init__()
        self.c = 'c'


print(C2().__dict__)   # {'a': 'a', 'c': 'c'} — x и b не инициализированы

Правила использования super() ​

  1. В __init__ наследника первым делом — super().__init__(...) с правильными аргументами.
  2. Каждый класс кооперативной цепочки, определяющий __init__, должен вызывать super().__init__().
  3. Не смешивайте стили: либо везде super(), либо везде имена классов.
  4. Для методов, которые расширяют поведение, вызов super().method() — до или после собственного кода — осознанный выбор.

Проверьте себя (автопроверка) ​

Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Классы Vehicle, Car, IM, A, B, C, BrokenA, C2 уже определены в предыдущих разделах урока.

Тест 1. MRO кооперативной цепочки:

python
print([c.__name__ for c in C.__mro__])   # ['C', 'A', 'IM', 'B', 'object']

Тест 2. Один вызов super().__init__() инициализирует всех:

python
print(C().__dict__)   # {'a': 'a', 'x': 'x', 'b': 'b', 'c': 'c'}

Тест 3. Оборванная цепочка:

python
print(C2().__dict__)   # {'a': 'a', 'c': 'c'} — x и b не созданы

Тест 4. Кто участвует в методе start:

python
def method_chain(cls, name):
    return [b.__name__ for b in cls.__mro__ if name in b.__dict__]


print(method_chain(Car, 'start'))   # ['Car', 'Vehicle']
Пояснения к ответам

Тест 1. Порядок: сам C, затем первый родитель A, затем роды A — IM, затем второй родитель C — B, и object. IM стоит между A и B, потому что он — родитель A.

Тест 2. C сам __init__ не определяет, поэтому первым запускается A.__init__ (первый по MRO): он ставит a и вызывает super().__init__(), который продолжает в IM (ставит x), затем в B (ставит b). После возврата C добавляет c. Один вход — полная инициализация.

Тест 3. BrokenA не вызывает super().__init__(), поэтому цепочка обрывается после a: IM и B никогда не запустятся. Внешне объект «работает», пока кто-нибудь не обращается к x или b — AttributeError.

Тест 4. start определён и в Car, и в Vehicle. При car.start() сработает Car.start, а внутри — super().start() найдёт Vehicle.start как следующий в MRO.

Проверьте себя ​

❓Что возвращает `super()`?
❓Почему писать `super().__init__(...)`, а не `Vehicle.__init__(self, ...)`?
❓Что такое миксин и что он обязан делать?
❓Что произойдёт, если забыть `super().__init__()` в одном из классов цепочки?
❓Какое правило использования `super()` верно?
❓Один вызов `super().__init__()` в `C(A, B)`, где `A(IM)` — что он запускает?

Практические упражнения ​

Выполните эти 6 упражнений, чтобы научиться строить кооперативные иерархии, подключать миксины и находить оборванные цепочки.

Упражнение 1: Иерархия животных (AnimalChain) ​

Задание: Создайте иерархию Animal → Dog → Puppy: Animal хранит name, Dog добавляет breed, Puppy добавляет trick. Каждый уровень — super().__init__(...) + свой атрибут.

python
# Ожидаемое поведение:
# p = Puppy('Reks', 'Corgi', 'spin')
# print(sorted(p.__dict__.keys()))   # ['breed', 'name', 'trick']

Упражнение 2: Миксин Timestamped (MixinJoin) ​

Задание: Создайте миксин Timestamped (атрибут created_at, кооперативный __init__) и подключите его ко второму родителю: SmartPuppy(Puppy, Timestamped). Убедитесь, что цепочка не рвётся и все атрибуты на месте.

python
# Ожидаемое поведение:
# sp = SmartPuppy('Reks', 'Corgi', 'spin')
# print(sorted(sp.__dict__.keys()))   # ['breed', 'created_at', 'name', 'trick']
# print(sp.created_at)                # now

Упражнение 3: Оборванный миксин (BrokenChain) ​

Задание: Создайте LateMixin (ставит late, без super().__init__() — намеренная ошибка) и EarlyMixin (ставит early, с super()). Соберите D(LateMixin, EarlyMixin) и покажите, что early не создаётся.

python
# Ожидаемое поведение:
# d = D()
# print(d.__dict__)   # {'late': 'late'} — early не создан
# print(hasattr(d, 'early'))   # False

Упражнение 4: Порядок инициализации (InitOrder) ​

Задание: Создайте классы LogA, LogB (каждый печатает свою букву и вызывает super().__init__()) и LogC(LogA, LogB), печатающий 'C'. Запустите LogC() и сверните порядок вывода с MRO.

python
# Ожидаемое поведение:
# LogC()
# # C
# # A
# # B

Упражнение 5: Три уровня с аргументами (ScooterChain) ​

Задание: Создайте Scooter(Vehicle) с атрибутом wheels (по умолчанию 2) и методом start(), который вызывает родительский start, а затем печатает число колёс. Затем SportScooter(Scooter), чей start() вызывает super().start() и печатает 'turbo mode'.

python
# Ожидаемое поведение:
# ss = SportScooter('Vespa', 'GTS')
# ss.start()
# # Vespa GTS: engine ready
# # 2 wheels ready
# # turbo mode

Упражнение 6: Куда смотрит super() (SuperTarget) ​

Задание: Создайте Base, Mid(Base), Top(Mid). У Top — метод target(), возвращающий имя класса, который видит super() внутри этого метода (super().__class__.__name__).

python
# Ожидаемое поведение:
# print(Top().target())   # Mid

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (AnimalChain)
python
class Animal:
    def __init__(self, name):
        super().__init__()
        self.name = name


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed


class Puppy(Dog):
    def __init__(self, name, breed, trick):
        super().__init__(name, breed)
        self.trick = trick


p = Puppy('Reks', 'Corgi', 'spin')
print(sorted(p.__dict__.keys()))   # ['breed', 'name', 'trick']

Пояснение: каждый уровень передаёт «общие» аргументы выше по цепочке и добавляет только своё. Animal зовёт super().__init__() — это object.__init__(), он не ждёт аргументов, всё в порядке.

Посмотреть решение Упражнения 2 (MixinJoin)
python
class Timestamped:
    def __init__(self):
        super().__init__()
        self.created_at = 'now'


class SmartPuppy(Puppy, Timestamped):
    pass


sp = SmartPuppy('Reks', 'Corgi', 'spin')
print(sorted(sp.__dict__.keys()))   # ['breed', 'created_at', 'name', 'trick']
print(sp.created_at)                # now

Пояснение: MRO SmartPuppy → Puppy → Dog → Animal → Timestamped → object. Puppy.__init__ зовётся первым (у SmartPuppy своего нет), цепочка super() доходит до Timestamped — и атрибут миксина создаётся.

Посмотреть решение Упражнения 3 (BrokenChain)
python
class LateMixin:
    def __init__(self):
        self.late = 'late'
        # super().__init__() — намеренно убрано


class EarlyMixin:
    def __init__(self):
        self.early = 'early'
        super().__init__()


class D(LateMixin, EarlyMixin):
    pass


d = D()
print(d.__dict__)          # {'late': 'late'} — early не создан
print(hasattr(d, 'early')) # False

Пояснение: MRO — D → LateMixin → EarlyMixin → object. Инициализация стартует в LateMixin (первый с __init__ по MRO), он не зовёт super(), и EarlyMixin пропускается. Так и ломаются цепочки — тихо, без ошибок.

Посмотреть решение Упражнения 4 (InitOrder)
python
class LogA:
    def __init__(self):
        print('A')
        super().__init__()


class LogB:
    def __init__(self):
        print('B')
        super().__init__()


class LogC(LogA, LogB):
    def __init__(self):
        print('C')
        super().__init__()


LogC()
# C
# A
# B

Пояснение: порядок вывода совпадает с MRO LogC → LogA → LogB → object — кооперативная инициализация идёт строго по цепочке.

Посмотреть решение Упражнения 5 (ScooterChain)
python
class Scooter(Vehicle):
    def __init__(self, make, model, wheels=2):
        super().__init__(make, model)
        self.wheels = wheels

    def start(self):
        super().start()
        print(f'{self.wheels} wheels ready')


class SportScooter(Scooter):
    def start(self):
        super().start()
        print('turbo mode')


ss = SportScooter('Vespa', 'GTS')
ss.start()
# Vespa GTS: engine ready
# 2 wheels ready
# turbo mode

Пояснение: SportScooter.start → Scooter.start → Vehicle.start — каждый уровень достраивает поведение. Аргументы передаются явными именами: super().__init__(make, model) — ровно то, что ожидает Vehicle.

Посмотреть решение Упражнения 6 (SuperTarget)
python
class Base:
    pass


class Mid(Base):
    pass


class Top(Mid):
    def target(self):
        return super().__class__.__name__


print(Top().target())   # Mid

Пояснение: внутри Top.target super() — это «следующий после Top в MRO» = Mid. super().__class__ показывает именно этот класс.