Как реализовать композицию в ООП?

Давай разберём этот ваш композиционный принцип, а то я вижу, у некоторых глаза уже стекленеют, как у пойманной Муму перед утоплением.

Вот смотри, есть у тебя объект. И этот объект, такой здоровый Герасим, блядь, немой, но сильный. И ему надо что-то делать. А он нихуя не умеет сам, блядь. Ну не может он, сука, завестись, как двигатель, или лампочку вкрутить. Что делать? А он берёт и имеет другого чувака внутри себя! Не "является" им, а именно имеет. Вот в чём, блядь, весь цимес!

Наследование — это когда ты кричишь: "Я — двигатель! Я — лампочка!". А композиция — это когда ты спокойно так говоришь: "У меня в кармане есть двигатель и лампочка, я щас ими воспользуюсь". Почувствуй разницу, ёпта! Первое — это пиздецкая претензия, а второе — просто здоровый пофигизм и прагматизм.

Зачем это, блядь, надо? А затем, сука, чтобы не было этой ебаной иерархии, где все друг от друга наследуются, как уроды в плохом анекдоте. Поменял что-то в дедушке-классе — и поехала вся родня, пиздец! А с композицией — заменил один движок на другой, и похуй. Главное, чтобы кнопки start() и stop() были на тех же местах. Гибкость — овердохуища!

Смотри, как это выглядит в коде, на примере тачки и движка. Блоки кода не трогаю, они святы, как ядра чистый изумруд.

class Engine:
    def __init__(self, horsepower: int):
        self.horsepower = horsepower
        print(f"Двигатель мощностью {self.horsepower} л.с. создан.")

    def start(self) -> str:
        return "Двигатель запущен."

    def stop(self) -> str:
        return "Двигатель остановлен."

class Car:
    def __init__(self, make: str, model: str, engine_hp: int):
        self.make = make
        self.model = model
        self.engine = Engine(engine_hp)  # Вот она, мать её, композиция! Car В СЕБЕ ИМЕЕТ Engine.

    def start_car(self) -> str:
        return f"{self.make} {self.model}: {self.engine.start()}"  # Делегируем, блядь, работу движку!

    def stop_car(self) -> str:
        return f"{self.make} {self.model}: {self.engine.stop()}"

    def get_info(self) -> str:
        return f"Автомобиль: {self.make} {self.model}, Мощность двигателя: {self.engine.horsepower} л.с."

# Использование композиции
my_car = Car("Toyota", "Camry", 180)
print(my_car.get_info())
print(my_car.start_car())
print(my_car.stop_car())

Видишь? Машина не кричит "Я двигатель!". Она говорит: "У меня есть движок, он всё сделает". И если завтра мы захотим электрокар — просто суём внутрь объект ElectricEngine с такими же методами start() и stop(). И всё! Машине похуй, она как делегировала, так и делегирует. Красота, в рот меня чих-пых!

Плюсы, блядь, очевидны:

• Не связаны по рукам и ногам. Меняй части как хочешь.
• Тестировать легко. Двигатель можно тестить отдельно, потом всунуть его в машину и опять тестить.
• Повторное использование. Этот же движок можно, блядь, в лодку запихнуть или в генератор. Наследованием тут и не пахнет.
• Нет проблем с алмазным наследованием. Этой хуйни с композицией просто не существует, потому что нет этих ёбаных ромбов в иерархии.

Вот и весь сказ. Композиция — это когда ты не пытаешься быть всем, а просто грамотно используешь то, что у тебя есть. Здоровый, блядь, подход к жизни и к коду.