Appearance
Composition - Составление объектов
Наследование отвечает на вопрос «является ли объект X» (Dog is Animal). Составление (composition) — «имеет объект X» (Car has Engine). Принцип «composition over inheritance»: сложное поведение собрать из небольших независимых частей, а не из глубокой иерархии классов.
Почему не всегда наследование
python
class Engine:
def __init__(self, volume, power):
self.volume, self.power = volume, power
def start(self):
print(f'Engine {self.volume} L ({self.power} hp) started')
def stop(self):
print('Engine stopped')
def __str__(self):
return f'Engine {self.volume} L ({self.power} hp)'Если сделать Car(Engine), машина «становится двигателем» — семантически неверно, и у машины может быть только один «родитель-двигатель». Правильно — хранить двигатель как атрибут:
python
class Car:
def __init__(self, make, model, engine):
self.make = make
self.model = model
self.engine = engine # car HAS an engine
def start(self):
print(f'{self.make} {self.model}: ignition on')
self.engine.start() # delegation
def stop(self):
self.engine.stop()
car = Car('Toyota', 'Camry', Engine(2.5, 200))
car.start()
car.stop()
print(type(car.engine).__name__) # Engine — двигатель хранится как частьДелегирование
Метод Car.start сам ничего не знает о двигателях — он делегирует работу составной части (self.engine.start()). Это и есть механизм composition: поведение объекта = поведение его частей.
python
class Car:
def __init__(self, make, model, engine):
self.make = make
self.model = model
self.engine = engine
def start(self):
print(f'{self.make} {self.model}: ignition on')
self.engine.start() # делегирование
def stop(self):
self.engine.stop()
def __str__(self):
return f'{self.make} {self.model} ({self.engine.volume} L)'
def info(self):
# делегирование: за Engine не храним данные дублирующе
return f'{self.make} {self.model}, engine: {self.engine}'
car = Car('Toyota', 'Camry', Engine(2.5, 200))
print(car)
print(car.info())Сравнение двух подходов
| Критерий | Наследование | Composition |
|---|---|---|
| семантика | «является» (is-a) | «имеет» (has-a) |
| замена поведения | только в пределах иерархии | часть меняется в любой момент |
| глубина иерархии | растёт | плоская |
| множественное поведение | множественное наследование (с MRO) | просто несколько атрибутов |
Пример замены «на лету»:
python
class SportsCar(Car):
def __init__(self, make, model, engine):
super().__init__(make, model, engine)
def swap_engine(self, new_engine):
self.engine = new_engine # унаследованного «меня двигателя» не было бы
car = SportsCar('Lexus', 'LC 500', Engine(3.5, 471))
car.start()
car.swap_engine(Engine(5.0, 471))
car.stop()Практическое правило
- класс «делает что-то само по себе» и поведение наследников — подмножество/расширение — можно наследовать;
- класс собирает независимые функции (двигатель, коробка, мультимедиа) — берите composition;
- наследование глубже 2–3 уровней или «мешок миксинов» — признак того, что нужен состав.
Проверьте себя (автопроверка)
Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Все классы (Engine, Car, SportsCar) уже определены в предыдущих разделах урока.
Тест 1. «является» vs «имеет»:
python
toyota = Car('Toyota', 'Camry', Engine(2.5, 200))
print(isinstance(toyota, Engine)) # False — машина не является двигателем
print(isinstance(toyota.engine, Engine)) # True — двигатель хранится как частьТест 2. Где реально хранятся данные:
python
print('engine' in vars(toyota)) # True — у машины есть атрибут-часть
print('volume' in vars(toyota)) # False — объём живёт внутри Engine, не дублируетсяТест 3. Замена части на лету:
python
lux = SportsCar('Lexus', 'LC 500', Engine(3.5, 471))
lux.swap_engine(Engine(4.0, 592))
print(lux) # Lexus LC 500 (4.0 L)Тест 4. Два разных метода stop:
python
print('stop' in vars(Car)) # True — у Car свой stop
print('stop' in vars(Engine)) # True — и у Engine свой stop
print(Car.stop is Engine.stop) # False — это два разных методаПояснения к ответам
Тест 1. isinstance(toyota, Engine) — False: Car наследуется от object, а не от Engine. Двигатель — атрибут, а не «родитель». Если бы написали class Car(Engine), этот тест показал бы True — семантически неверное утверждение «машина является двигателем».
Тест 2. Составление держит данные в одном месте: volume и power принадлежат объекту Engine и доступны как toyota.engine.volume. Car их не копирует — поэтому в vars(toyota) поля volume/power нет.
Тест 3. swap_engine заменяет целый объект-атрибут. __str__ у Car каждый раз читает self.engine.volume, поэтому новая мощность/объём видны сразу. В наследовании «родителя» после создания класса не поменяешь.
Тест 4. У Car и Engine есть свои методы stop, но toyota.stop() выполняет Car.stop, который внутри вызывает self.engine.stop() — метод Engine. Делегирование = «внешний метод пересылает работу внутрь части».
Проверьте себя
На какой вопрос отвечает наследование?
Почему запись `class Car(Engine)` — ошибка?
Что такое делегирование в примере урока?
Где хранятся данные `volume` и `power`?
Что демонстрирует метод `swap_engine(new_engine)`?
Когда брать composition по практическому правилу урока?
Практические упражнения
Выполните эти 6 упражнений, чтобы научиться собирать сложные объекты из небольших независимых частей, управлять этими частями «на лету» и объяснять, почему составление лучше наследования.
Упражнение 1: Дрон со сменной батареей (DroneBattery)
Задание: Создайте класс Battery (атрибут capacity, методы charge(n) — добавить заряд, не больше capacity, level() — вернуть текущий заряд; новая батарея заряжена полностью) и класс Drone (атрибут model, часть battery), где Drone.fly(minutes) тратит minutes единиц заряда, делегируя батарее, и при недостатке заряда бросает ValueError.
python
# Ожидаемое поведение:
# battery = Battery(100)
# drone = Drone('SkyHawk X1', battery)
# drone.fly(30)
# print(battery.level()) # 70
# drone.fly(80) # ValueError: не хватает зарядаУпражнение 2: Замена батареи на лету (DroneSwap)
Задание: Добавьте дрону из упражнения 1 метод swap_battery(new_battery) — замена батареи на лету, возвращающий старую батарею. Убедитесь, что старая батарея сохранила свой заряд, а новая заряжена полностью.
python
# Ожидаемое поведение:
# battery = Battery(100)
# drone = Drone('SkyHawk X1', battery)
# drone.fly(30)
# fresh = Battery(200)
# old = drone.swap_battery(fresh)
# print(old.level()) # 70 — старая не изменилась
# print(drone.battery.level()) # 200Упражнение 3: Дом с независимыми системами (SmartHouse)
Задание: Создайте класс House с частями door (класс Door: open(), close(), флаг is_open) и light (класс Light: turn_on(), turn_off(), флаг is_on). У House — методы-делегаты open_door(), close_door(), lights_on(), lights_off() и report(), собирающий строку состояния.
python
# Ожидаемое поведение:
# house = House()
# house.open_door()
# house.lights_on()
# print(house.report()) # Дверь: открыта, Свет: включен
# house.lights_off()
# print(house.report()) # Дверь: открыта, Свет: выключенУпражнение 4: Почему не наследование (DesignFlaw)
Задание: Объясните (2–4 предложения), почему class Drone(Battery) — ошибка проектирования. Назовите минимум три причины: семантика, количество частей, замена поведения. Код не нужен — ответ сверьте с эталоном в конце.
Упражнение 5: Принтер с двумя расходными частями (PrinterParts)
Задание: Создайте классы InkCartridge (атрибут ink, методы refill(n), empty()) и PaperTray (атрибут sheets, методы load(n), empty()) и класс Printer (атрибут name), у которого print_page() тратит 1 единицу чернил и 1 лист (при нехватке — RuntimeError с текстом ошибки), а refill_ink(n) и load_paper(n) делегируют частям.
python
# Ожидаемое поведение:
# printer = Printer('OfficeJet 3000')
# printer.load_paper(5)
# printer.refill_ink(2)
# printer.print_page()
# printer.print_page()
# printer.print_page() # RuntimeError: нет чернилУпражнение 6: Интроспекция состава (CompositionAudit)
Задание: Напишите функцию audit(obj), возвращающую список пар (имя_атрибута, имя_типа) для всех атрибутов obj, которые являются объектами-частями (не строки, числа и булевы). Используйте vars() и isinstance.
python
# Ожидаемое поведение:
# toyota = Car('Toyota', 'Camry', Engine(2.5, 200))
# print(audit(toyota)) # [('engine', 'Engine')]Решения для самопроверки
Посмотреть решение Упражнения 1 (DroneBattery)
python
class Battery:
def __init__(self, capacity):
self.capacity = capacity
self.reserved = capacity # новая батарея заряжена полностью
def charge(self, n):
# отрицательное n = расход заряда
self.reserved = min(self.capacity, self.reserved + n)
def level(self):
return self.reserved
class Drone:
def __init__(self, model, battery):
self.model = model
self.battery = battery # drone HAS a battery
def fly(self, minutes):
if self.battery.level() < minutes:
raise ValueError('не хватает заряда')
self.battery.charge(-minutes) # делегирование расхода
battery = Battery(100)
drone = Drone('SkyHawk X1', battery)
drone.fly(30)
print(battery.level()) # 70
try:
drone.fly(80)
except ValueError as err:
print(err) # не хватает зарядаПояснение: дрон ничего не знает о химии батареи — он только спрашивает level() и пересылает расход через charge(-minutes).
Посмотреть решение Упражнения 2 (DroneSwap)
python
class Battery:
def __init__(self, capacity):
self.capacity = capacity
self.reserved = capacity
def charge(self, n):
self.reserved = min(self.capacity, self.reserved + n)
def level(self):
return self.reserved
class Drone:
def __init__(self, model, battery):
self.model = model
self.battery = battery
def fly(self, minutes):
if self.battery.level() < minutes:
raise ValueError('не хватает заряда')
self.battery.charge(-minutes)
def swap_battery(self, new_battery):
old = self.battery
self.battery = new_battery
return old
battery = Battery(100)
drone = Drone('SkyHawk X1', battery)
drone.fly(30)
fresh = Battery(200)
old = drone.swap_battery(fresh)
print(old.level()) # 70 — старая не изменилась
print(drone.battery.level()) # 200Пояснение: замена «на лету» — просто присваивание нового объекта в атрибут. Старый объект продолжает жить со своим состоянием (его ещё можно зарядить и вернуть).
Посмотреть решение Упражнения 3 (SmartHouse)
python
class Door:
def __init__(self):
self.is_open = False
def open(self):
self.is_open = True
def close(self):
self.is_open = False
class Light:
def __init__(self):
self.is_on = False
def turn_on(self):
self.is_on = True
def turn_off(self):
self.is_on = False
class House:
def __init__(self):
self.door = Door()
self.light = Light()
def open_door(self):
self.door.open()
def close_door(self):
self.door.close()
def lights_on(self):
self.light.turn_on()
def lights_off(self):
self.light.turn_off()
def report(self):
door = 'открыта' if self.door.is_open else 'закрыта'
light = 'включен' if self.light.is_on else 'выключен'
return f'Дверь: {door}, Свет: {light}'
house = House()
house.open_door()
house.lights_on()
print(house.report()) # Дверь: открыта, Свет: включен
house.lights_off()
print(house.report()) # Дверь: открыта, Свет: выключенПояснение: House не хранит состояния дверей и света сам — он делегирует каждой части. Добавление третьей системы (например, thermostat) — это новый атрибут и пара делегатов, без переписывания House вглубь иерархии.
Посмотреть решение Упражнения 4 (DesignFlaw)
- Семантика: дрон не является батареей, поэтому
class Drone(Battery)ломает отношение is-a:isinstance(drone, Battery)было бы ложнымTrue. - Количество частей: дрон нужен с батареей, пропеллерами, автопилотом и камерой. Наследование даёт один «родитель-часть»; множественное наследование от частей уводит в MRO-конфликты.
- Замена поведения: с составлением батарею можно поменять на лету (
swap_battery), а «родитель» класса менять после его создания нельзя.
Краткая формула: если связь «имеет», а не «является» — берите составление.
Посмотреть решение Упражнения 5 (PrinterParts)
python
class InkCartridge:
def __init__(self):
self.ink = 0
def refill(self, n):
# отрицательное n = расход чернил
self.ink += n
def empty(self):
return self.ink <= 0
class PaperTray:
def __init__(self):
self.sheets = 0
def load(self, n):
self.sheets += n
def empty(self):
return self.sheets <= 0
class Printer:
def __init__(self, name):
self.name = name
self.ink_cartridge = InkCartridge()
self.paper_tray = PaperTray()
def print_page(self):
if self.ink_cartridge.empty():
raise RuntimeError('нет чернил')
if self.paper_tray.empty():
raise RuntimeError('нет бумаги')
self.ink_cartridge.refill(-1)
self.paper_tray.load(-1)
def refill_ink(self, n):
self.ink_cartridge.refill(n)
def load_paper(self, n):
self.paper_tray.load(n)
printer = Printer('OfficeJet 3000')
printer.load_paper(5)
printer.refill_ink(2)
printer.print_page()
printer.print_page()
try:
printer.print_page()
except RuntimeError as err:
print(err) # нет чернилПояснение: принтер не считает чернила и листы сам — обе проверки и оба расхода делегированы частям. Это композиция из двух независимых «расходников».
Посмотреть решение Упражнения 6 (CompositionAudit)
python
def audit(obj):
return [
(name, type(value).__name__)
for name, value in vars(obj).items()
if not isinstance(value, (str, int, float, bool))
]
toyota = Car('Toyota', 'Camry', Engine(2.5, 200))
print(audit(toyota)) # [('engine', 'Engine')]Пояснение: vars(obj) даёт атрибуты экземпляра; отфильтровав скаляры (str, int, float, bool), получаем именно «части» — объекты, из которых объект собран.