Skip to content

Оптимизация памяти с помощью __slots__ ​

По умолчанию Python устроен максимально гибко: вы можете создать объект класса и в любой момент динамически добавить ему новое свойство прямо на лету (например, box.emergency_status = "Срочно"). Такая магия работает потому, что внутри каждого экземпляра Python скрытно создает обычный словарь — дандер-атрибут __dict__.

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

На этом уроке мы научимся использовать инструмент жесткой оптимизации — атрибут __slots__, который отключает динамические словари, экономит до 40-50% памяти и ускоряет доступ к свойствам объекта.

1. Как работает __slots__ под капотом ​

Когда вы объявляете в теле класса специальный кортеж __slots__, вы жестко фиксируете список разрешенных атрибутов:

python
class ParcelBox:
    # Явно указываем Python, какие свойства могут быть у этого объекта
    __slots__ = ("tracking_number", "weight")

Что происходит внутри Python после этого:

  1. Python полностью уничтожает скрытый словарь __dict__ у каждого объекта этого класса.
  2. Вместо этого в памяти выделяется фиксированный массив строго под указанные свойства.
  3. Программа больше не тратит ресурсы на хэширование ключей словаря, за счет чего чтение и запись свойств ускоряются примерно на 20%.
  4. Обратная сторона: Попытка добавить объекту любое новое свойство, не указанное в __slots__, мгновенно вызовет ошибку AttributeError.

2. Сравнительный пример оптимизации ​

Давайте спроектируем две версии Почтовой Коробки — обычную и оптимизированную, и посмотрим на их поведение в Production.

python
class StandardBox:
    """Обычный класс. Тратит много памяти из-за скрытого словаря __dict__."""
    def __init__(self, tracking_number: str, weight: float) -> None:
        self.tracking_number: str = tracking_number
        self.weight: float = weight


class OptimizedBox:
    """Оптимизированный класс. Память выделена строго под массив из двух элементов."""
    __slots__ = ("tracking_number", "weight")

    def __init__(self, tracking_number: str, weight: float) -> None:
        self.tracking_number: str = tracking_number
        self.weight: float = weight


# === Проверка поведения в системе ===
if __name__ == "__main__":
    box_std = StandardBox("RU-111", 2.5)
    box_opt = OptimizedBox("RU-222", 1.8)

    # 1. Проверяем динамическое добавление свойств
    box_std.courier_notes = "Хрупкий груз"  # Успешно! Записалось в box_std.__dict__
    print(f"Словарь обычного объекта: {box_std.__dict__}")

    try:
        # У оптимизированного объекта словаря __dict__ больше не существует!
        box_opt.courier_notes = "Хрупкий груз"
    except AttributeError as e:
        print(f"\n[ЗАЩИТА] Не удалось добавить новое свойство объекту со slots: {e}")
        # Выведет: AttributeError: 'OptimizedBox' object has no attribute 'courier_notes'

    # 2. Проверка экономии памяти (системный замер)
    import sys
    # Обычный объект хранит сам себя + тяжелый скрытый словарь
    std_memory = sys.getsizeof(box_std) + sys.getsizeof(box_std.__dict__)
    # Оптимизированный объект хранит только компактный фиксированный массив
    opt_memory = sys.getsizeof(box_opt)
    
    print(f"\nПамять стандартного объекта: {std_memory} байт")
    print(f"Память оптимизированного объекта: {opt_memory} байт")

Подводный камень при наследовании

Если вы наследуете класс от другого класса, у которого нет __slots__, то у дочернего класса автоматически снова появится скрытый словарь __dict__, и вся оптимизация сойдет на нет. Чтобы оптимизация сохранялась по всей цепочке наследования, __slots__ должны быть объявлены у каждого родительского класса в иерархии. Если у дочернего класса нет новых свойств, ему пишут пустой кортеж: __slots__ = ().

Чек-лист готовности ​

Перед тем как перейти к практике, убедитесь, что вы твердо усвоили:

  • [ ] Атрибут __slots__ принимает строго кортеж строк tuple, а не список list, так как сам кортеж является неизменяемым и защищает структуру памяти.
  • [ ] Использование __slots__ отключает дандер-атрибут __dict__, блокируя возможность динамического добавления случайных свойств объекту.
  • [ ] Оптимизация памяти работает на полную мощность только в том случае, если все родительские классы в цепочке наследования также используют механизм __slots__.

Проверьте себя ​

❓В чём цена гибкости по умолчанию (скрытый словарь `__dict__` у каждого объекта)?
❓Что происходит после объявления `__slots__ = («tracking_number», «weight»)`?
❓Какой тип принимает атрибут `__slots__`?
❓Дочерний класс унаследован от класса БЕЗ `__slots__` — что произойдёт?
❓Каков примерный эффект от `__slots__`?
❓Когда `__slots__` действительно важен?

Практические упражнения для Production-кода ​

Выполните эти 5 практических заданий, чтобы научиться профессионально применять оптимизацию памяти в высоконагруженных системах и контролировать структуру объектов.

Упражнение 1: Миллион Римских Чисел в памяти (RomanNumberSlots) ​

Представьте, что ваше математическое приложение выполняет масштабный статистический анализ и одновременно хранит в оперативной памяти массив из 1 000 000 объектов класса RomanNumber. Без оптимизации программа займет сотни мегабайт ОЗУ.

Задание:

  1. Создайте класс RomanNumberSlots.
  2. С помощью __slots__ зафиксируйте единственное разрешенное свойство объекта — value (строка с римским числом).
  3. Реализуйте методы __init__ и __repr__.
  4. Напишите проверочный код: попробуйте искусственно добавить объекту свойство _arabic_cache = 10. Убедитесь, что система выбрасывает ошибку AttributeError.

Упражнение 2: Оптимизация накладных курьерской службы (CourierTaskSlots) ​

Каждый день курьеры выполняют тысячи доставок. Класс CourierTask (Задача курьера) должен быть максимально легким, так как данные непрерывно синхронизируются через API мобильного приложения.

Задание: Создайте оптимизированный класс CourierTask:

  1. Объявите __slots__ для трех свойств: task_id (int), address (str) и weight (float).
  2. Напишите конструктор для инициализации этих полей.
  3. Проверьте через функцию hasattr(task, '__dict__'), действительно ли у созданного объекта отсутствует внутренний словарь динамических свойств (метод должен вернуть False).

Упражнение 3: Сохранение оптимизации при наследовании (InternationalParcelSlots) ​

Вам необходимо построить правильную иерархию классов для почтовых отправлений с сохранением оптимизации памяти.

Задание:

  1. Создайте базовый класс BaseParcel со свойствами в __slots__ = ("weight", "destination").
  2. Создайте дочерний класс InternationalParcel(BaseParcel), который расширяет базовый класс и добавляет собственное новое свойство — customs_duty (таможенная пошлина).
  3. Важное условие: Объявите __slots__ в дочернем классе так, чтобы в нем было указано только новое свойство, но при этом скрытый словарь __dict__ не создавался заново.
  4. Проверьте, что у объекта InternationalParcel доступны все 3 свойства, но динамически добавить четвертое свойство нельзя.
python
# Ожидаемое поведение:
# parcel = InternationalParcel(weight=5.4, destination="Минск", customs_duty=15.0)
# parcel.insurance = True  # Должно вызвать AttributeError!

Упражнение 4: Программное возвращение динамичности (FlexibleSlots) ​

Иногда на Production возникает компромиссная задача: нужно оптимизировать память для 95% основных свойств, но оставить лазейку для 5% непредвиденных динамических данных, которые могут прийти от внешних сервисов. Для этого в __slots__ можно намеренно вернуть строку '__dict__'.

Задание: Создайте класс FlexibleParcel:

  1. Объявите __slots__, в котором перечислите базовые свойства: tracking_number, sender, а последним элементом кортежа передайте строку '__dict__'.
  2. В конструкторе инициализируйте базовые свойства.
  3. Проверьте поведение: теперь объект будет экономить память на основных полях, но при этом вы сможете успешно добавить ему любое новое свойство на лету (ошибки AttributeError не возникнет).

Упражнение 5: Оптимизированная карточка адреса (AddressSlots) ​

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

Задание: Создайте класс AddressCard:

  1. В __slots__ пропишите строгий список полей: country, city, street.
  2. Реализуйте метод __init__, принимающий эти три параметра.
  3. Напишите тест: попытайтесь сымитировать ошибку пользователя, который опечатался в названии свойства при заполнении: card.statregion = "Центральный". Покажите в консоли, как __slots__ предотвращает подобные баги на этапе выполнения.

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (RomanNumberSlots)
python
class RomanNumberSlots:
    __slots__ = ("value",)  # Запятая обязательна, чтобы это был кортеж, а не строка в скобках

    def __init__(self, value: str) -> None:
        self.value: str = value

    def __repr__(self) -> str:
        return f"RomanNumberSlots('{self.value}')"

# Проверка: динамическое свойство запрещено
r = RomanNumberSlots("XIV")
print(repr(r))   # RomanNumberSlots('XIV')
try:
    r._arabic_cache = 10
except AttributeError as err:
    print(f"AttributeError: {err}")   # AttributeError: 'RomanNumberSlots' object has no attribute '_arabic_cache'
Посмотреть решение Упражнения 2 (CourierTaskSlots)
python
class CourierTaskSlots:
    __slots__ = ("task_id", "address", "weight")

    def __init__(self, task_id: int, address: str, weight: float) -> None:
        self.task_id: int = task_id
        self.address: str = address
        self.weight: float = weight

# Проверка в коде:
task = CourierTaskSlots(1, "ул. Ленина, 10", 4.5)
print(hasattr(task, '__dict__'))   # False
Посмотреть решение Упражнения 3 (Наследование со slots)
python
class BaseParcel:
    __slots__ = ("weight", "destination")
    
    def __init__(self, weight: float, destination: str) -> None:
        self.weight: float = weight
        self.destination: str = destination


class InternationalParcel(BaseParcel):
    # Дочерний класс указывает ТОЛЬКО свои новые свойства
    __slots__ = ("customs_duty",)

    def __init__(self, weight: float, destination: str, customs_duty: float) -> None:
        # Обязательно вызываем конструктор родителя
        super().__init__(weight, destination)
        self.customs_duty: float = customs_duty

# Проверка: все три свойства доступны, словарь не создаётся
parcel = InternationalParcel(weight=5.4, destination="Минск", customs_duty=15.0)
print(parcel.weight, parcel.destination, parcel.customs_duty)   # 5.4 Минск 15.0
print(hasattr(parcel, '__dict__'))   # False
try:
    parcel.insurance = True
except AttributeError as err:
    print(f"AttributeError: {err}")
Посмотреть решение Упражнения 4 (FlexibleSlots с сохранением __dict__)
python
class FlexibleParcel:
    # Компромиссный вариант: фиксируем поля + разрешаем динамику
    __slots__ = ("tracking_number", "sender", "__dict__")

    def __init__(self, tracking_number: str, sender: str) -> None:
        self.tracking_number: str = tracking_number
        self.sender: str = sender

# Проверка: динамическое свойство теперь добавляется успешно
flex = FlexibleParcel("RU-777", "Иван")
flex.external_flag = "OK"
print(flex.external_flag)   # OK
Посмотреть решение Упражнения 5 (AddressSlots как контракт)
python
class AddressCard:
    __slots__ = ("country", "city", "street")

    def __init__(self, country: str, city: str, street: str) -> None:
        self.country: str = country
        self.city: str = city
        self.street: str = street

# Проверка: опечатка в имени поля ловится сразу
card = AddressCard("Беларусь", "Минск", "ул. Немига, 1")
try:
    card.statregion = "Центральный"
except AttributeError as err:
    print(f"AttributeError: {err}")