Работа с вложенными объектами в Python: композиция и агрегация

Расширенные примеры вложенных объектов

Многоуровневая композиция

Объект может содержать несколько уровней вложенности, например, автомобиль содержит двигатель, а двигатель - поршни.

class Piston:
    def __init__(self, diameter):
        self.diameter = diameter

class Engine:
    def __init__(self, power):
        self.power = power
        self.pistons = [Piston(80), Piston(80), Piston(80), Piston(80)]

class Car:
    def __init__(self, brand, engine):
        self.brand = brand
        self.engine = engine

car = Car('Mercedes', Engine(300))
print(f'Количество поршней: {len(car.engine.pistons)}')

Количество поршней: 4

Композиция с коллекциями (список колес)

Внешний объект может хранить коллекцию вложенных объектов.

class Wheel:
    def __init__(self, size):
        self.size = size

class Car:
    def __init__(self, brand, wheels):
        self.brand = brand
        self.wheels = wheels  # список из Wheel

    def total_diameter(self):
        return sum(w.size for w in self.wheels)

wheels = [Wheel(17), Wheel(17), Wheel(17), Wheel(17)]
car = Car('BMW', wheels)
print(car.total_diameter())

68

Передача вложенного объекта в методы

Метод внешнего объекта может принимать вложенный объект как параметр.

class Mechanic:
    def repair(self, engine):
        print('Механик чинит двигатель мощностью', engine.power)

engine = Engine(200)
mechanic = Mechanic()
mechanic.repair(engine)

Механик чинит двигатель мощностью 200

Сравнение вложенных объектов

По умолчанию сравнение объектов выполняется по id. Чтобы сравнивать по содержимому, нужно переопределить __eq__ или использовать dataclasses с order=True.

@dataclass
class Engine:
    power: int

@dataclass
class Car:
    brand: str
    engine: Engine

car1 = Car('A', Engine(100))
car2 = Car('A', Engine(100))
print(car1 == car2)  # True, так как dataclass генерирует __eq__

True

Использование __slots__ для экономии памяти

Если много вложенных объектов, можно применить __slots__ для уменьшения потребления памяти.

class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Line:
    __slots__ = ('start', 'end')
    def __init__(self, start, end):
        self.start = start
        self.end = end

line = Line(Point(0,0), Point(1,1))
print(line.start.x)  # 0

Сериализация вложенных объектов

Для сохранения и загрузки вложенных структур удобно использовать json модуль с пользовательским кодировщиком или pickle.

import json

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

class Car:
    def __init__(self, brand, engine):
        self.brand = brand
        self.engine = engine

car = Car('Tesla', Engine(250))
# Сериализация через __dict__ не работает для вложенных объектов
# Решение: метод to_dict

def to_dict(obj):
    if hasattr(obj, '__dict__'):
        return {k: to_dict(v) for k, v in obj.__dict__.items()}
    else:
        return obj

print(json.dumps(to_dict(car), indent=2))

{
  "brand": "Tesla",
  "engine": {
    "power": 250
  }
}

Неизменяемые вложенные объекты (frozen dataclass)

Если требуется, чтобы вложенные объекты не изменялись после создания, используется frozen=True.

@dataclass(frozen=True)
class Engine:
    power: int

@dataclass(frozen=True)
class Car:
    brand: str
    engine: Engine

car = Car('Nissan', Engine(120))
# car.engine.power = 200  # вызовет ошибку

Проблемы с изменяемыми объектами по умолчанию

Одна из частых ошибок - использование изменяемого объекта как значения по умолчанию в аргументах конструктора.

class Car:
    def __init__(self, brand, engine=Engine(100)):  # неправильно: один объект для всех вызовов
        self.brand = brand
        self.engine = engine

car1 = Car('A')
car2 = Car('B')
car1.engine.power = 200
print(car2.engine.power)  # 200, так как все используют один и тот же engine