Skip to content

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)
  1. Семантика: дрон не является батареей, поэтому class Drone(Battery) ломает отношение is-a: isinstance(drone, Battery) было бы ложным True.
  2. Количество частей: дрон нужен с батареей, пропеллерами, автопилотом и камерой. Наследование даёт один «родитель-часть»; множественное наследование от частей уводит в MRO-конфликты.
  3. Замена поведения: с составлением батарею можно поменять на лету (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), получаем именно «части» — объекты, из которых объект собран.