Appearance
Super - Функция super()
super() возвращает объект, с которого начинается поиск метода после текущего класса в MRO — то есть в «следующих» родителях. Зачем это нужно:
- вызвать метод родителя без его имени:
super().__init__(...); - сделать кооперативное множественное наследование: каждая инициализация продолжается в следующем по цепочке классе.
Простейший случай: вызов родителя
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()
- В
__init__наследника первым делом —super().__init__(...)с правильными аргументами. - Каждый класс кооперативной цепочки, определяющий
__init__, должен вызыватьsuper().__init__(). - Не смешивайте стили: либо везде
super(), либо везде имена классов. - Для методов, которые расширяют поведение, вызов
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__ показывает именно этот класс.