class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return "Engine running"


class Car:
    def __init__(self, model):
        self.model = model
        self.engine = Engine(200)

    def drive(self):
        return self.engine.start()

• Car creates the Engine inside __init__
• Engine is not passed in — it's created internally
• If the Car object is deleted, the Engine goes with it
• No other object references this engine

# Usage
my_car = Car("Toyota")
print(my_car.drive())
# Engine running

class Book:
    def __init__(self, title):
        self.title = title


class Library:
    def __init__(self, name):
        self.name = name
        self.books = []

    def add_book(self, book):
        self.books.append(book)

• Books are created outside the Library
• They're passed in via add_book()
• Deleting the library doesn't destroy the books

# Usage
b1 = Book("Python 101")
b2 = Book("Clean Code")

lib = Library("City Library")
lib.add_book(b1)
lib.add_book(b2)

del lib
print(b1.title)  # Python 101 still exists!

Composition

class House:
    def __init__(self):
        # Created INSIDE
        self.rooms = [
            Room("kitchen"),
            Room("bedroom"),
            Room("bathroom"),
        ]

house = House()
del house
# rooms are gone too

Aggregation

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        # Passed in from OUTSIDE
        self.books.append(book)

book = Book("Python 101")
lib = Library()
lib.add_book(book)
del lib
print(book.title)  # still exists!

• Instead of inheriting properties from a parent class...
• ...a class should be composed of other classes that provide desired behavior
• More flexible — can change behavior at runtime
• Avoids fragile base class problem

class ManagerRole:
    def perform_duty(self):
        return "Manager report"

class TechnicianRole:
    def perform_duty(self):
        return "Equipment repaired"

class Employee:
    def __init__(self, name, role=None):
        self.name = name
        self.role = role

    def perform_duty(self):
        if self.role:
            return self.role.perform_duty()
        return "No specific duty"

# Create roles independently
mgr_role = ManagerRole()
tech_role = TechnicianRole()

# Assign to employees
alice = Employee("Alice", mgr_role)
bob = Employee("Bob", tech_role)

print(alice.perform_duty())
# Manager report

print(bob.perform_duty())
# Equipment repaired

# Change role at runtime!
alice.role = tech_role
print(alice.perform_duty())
# Equipment repaired

class Printer:
    def print_document(self, text):
        print(f"Printing: {text}")


class Report:
    def __init__(self, content):
        self.content = content

    def send_to_printer(self, printer):
        printer.print_document(self.content)

• Report doesn't own the Printer
• Printer is only used temporarily in the method call
• After the method returns, the relationship ends

# Usage
printer = Printer()
report = Report("Q1 Results")
report.send_to_printer(printer)
# Report has no reference to printer

class Omniva:
    def deliver(self, order):
        return f"Omniva ships {order}"

class LPExpress:
    def deliver(self, order):
        return f"LP Express ships {order}"

class OrderService:
    def __init__(self, shipper):
        self.shipper = shipper

    def ship_order(self, order):
        return self.shipper.deliver(order)

# Inject Omniva
svc = OrderService(Omniva())
print(svc.ship_order("Laptop"))
# Omniva ships Laptop

# Inject LP Express instead
svc = OrderService(LPExpress())
print(svc.ship_order("Laptop"))
# LP Express ships Laptop

# Inject a mock for testing
svc = OrderService(MockShipper())
print(svc.ship_order("Laptop"))
# MockShipper ships Laptop

from abc import ABC, abstractmethod

class Shipper(ABC):
    @abstractmethod
    def deliver(self, order):
        pass

class Omniva(Shipper):
    def deliver(self, order):
        return f"Omniva: {order}"

class DHL(Shipper):
    def deliver(self, order):
        return f"DHL: {order}"

class OrderService:
    def __init__(self, shipper: Shipper):
        self.shipper = shipper

    def ship(self, order):
        return self.shipper.deliver(order)

• Shipper ABC defines the contract
• Any class implementing deliver() can be injected
• Combines polymorphism + DI for maximum flexibility