Skip to content

Контекстные менеджеры (with, __enter__ и __exit__) ​

В реальной разработке программы постоянно работают с внешними ресурсами: открывают файлы на диске, подключаются к базам данных или устанавливают сетевые соединения. Главная опасность здесь — забыть вовремя закрыть ресурс. Если файл останется открытым, память «потечет», а другие программы не смогут получить к нему доступ.

Для решения этой проблемы в Python существует оператор with и протокол контекстного менеджера. Он гарантирует, что ресурс будет автоматически и гарантированно закрыт (или очищен), как только работа в блоке кода завершится — даже если внутри программы произошла критическая ошибка.

На этом уроке мы разберем магические методы __enter__ и __exit__ и применим их для управления жизненным циклом нашей Почтовой Коробки.

1. Как устроен оператор with под капотом ​

Когда вы пишете код с оператором with:

python
with open("parcel.txt", "w", encoding="utf-8") as file:
    file.write("Посылка отправлена")

Python скрытно выполняет следующий протокол:

  1. Вызывает метод __enter__ у объекта контекста. То, что этот метод возвращает, записывается в переменную после ключевого слова as (в данном случае — в file).
  2. Выполняет блок кода внутри with.
  3. При выходе из блока (неважно, успешном или из-за ошибки) всегда вызывает метод __exit__.

2. Реализация Контекстного Менеджера для Почтовой Коробки ​

Давайте применим эту концепцию к нашему сквозному проекту. Представьте бизнес-логику: когда почтовая коробка открывается для упаковки (with ParcelBox() as box), мы можем добавлять в неё вещи. Как только блок with заканчивается, коробка должна автоматически закрыться, опечататься скотчем и залогировать время сборки.

Если в процессе упаковки какая-то вещь разбилась (произошло исключение), коробка должна зафиксировать ошибку в логах и отменить отправку.

python
import sys

class ParcelBox:
    """Класс Почтовой Коробки, реализующий протокол контекстного менеджера."""

    def __init__(self, tracking_number: str) -> None:
        self.tracking_number: str = tracking_number
        self._items: list[str] = []
        self.is_sealed: bool = False  # Флаг: опечатана ли коробка скотчем

    def add_item(self, item: str) -> None:
        """Добавляет предмет в коробку, если она не опечатана."""
        if self.is_sealed:
            raise RuntimeError("Нельзя добавить вещь: коробка уже опечатана скотчем!")
        self._items.append(item)
        print(f"[УПАКОВКА] В коробку {self.tracking_number} положена вещь: {item}")

    def __enter__(self) -> "ParcelBox":
        """Начало контекста: открываем сессию упаковки коробки."""
        print(f"\n--- [СТАРТ СБОРКИ] Коробка {self.tracking_number} открыта для сборки ---")
        # Возвращаем self, чтобы объект записался в переменную после оператора `as`
        return self

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        """Конец контекста: автоматически опечатываем коробку.

        Args:
            exc_type: Тип возникшего исключения (если оно было).
            exc_val: Значение/сообщение исключения.
            exc_tb: Стек вызова (traceback) ошибки.
        """
        # Проверяем, произошла ли ошибка внутри блока `with`
        if exc_type is not None:
            print(f"[ВНИМАНИЕ] Сборка посылки {self.tracking_number} прервана из-за ошибки: {exc_val}")
            print(f"[СТАТУС] Коробка утилизирована. Отправка отменена.")
            # Возвращаем False, чтобы Python пробросил ошибку дальше (не подавляем её)
            return False

        # Если всё прошло успешно
        self.is_sealed = True
        print(f"[ФИНАЛ] Коробка {self.tracking_number} успешно опечатана скотчем.")
        print(f"--- [КОНЕЦ СБОРКИ] Посылка готова к передаче курьеру ---\n")
        return True


# === Демонстрация работы ===
if __name__ == "__main__":
    # 1. Успешный сценарий сборки посылки
    with ParcelBox("RU-777") as box:
        box.add_item("Ноутбук")
        box.add_item("Зарядное устройство")
    # Здесь метод __exit__ вызвался автоматически, коробка опечатана!

    # 2. Сценарий с возникновением ошибки внутри блока
    try:
        with ParcelBox("RU-999") as faulty_box:
            faulty_box.add_item("Фарфоровая ваза")
            # Сымитируем форс-мажор: ваза выскользнула и разбилась
            raise ValueError("Ваза разбилась при укладке!")
            faulty_box.add_item("Защитная пленка")  # Этот код не выполнится
    except ValueError:
        print("[СИСТЕМА] Исключение перехвачено внешним try-except блоком.")

Правила подавления ошибок в __exit__

Метод __exit__ должен возвращать логическое значение (bool):

  • Если метод возвращает True, Python считает, что вы полностью обработали («погасили») ошибку внутри контекста. Программа продолжит выполнение дальше, как будто аварии не было.
  • Если метод возвращает False (или ничего не возвращает, т.е. None), Python пробросит исключение вверх, и программа аварийно завершится, если её не перехватить внешним блоком try-except.

Проверьте себя (автопроверка) ​

Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Класс ParcelBox с протоколом контекстного менеджера уже определён в предыдущем разделе урока.

Тест 1. Успешная сборка — коробка опечатывается автоматически:

python
sealed_box = ParcelBox("RU-555")
with sealed_box as box:
    box.add_item("Чашка")
print(sealed_box.is_sealed)   # True

Тест 2. Ошибка внутри блока — коробка НЕ опечатывается:

python
try:
    with ParcelBox("RU-666") as faulty:
        faulty.add_item("Ваза")
        raise ValueError("Ваза разбилась!")
except ValueError:
    print("Ошибка проброшена в вызывающий код")
print(faulty.is_sealed)   # False — сбой отменил отправку

Тест 3. Добавление вещи в уже опечатанную коробку:

python
try:
    sealed_box.add_item("Шарф")
except RuntimeError as err:
    print(err)   # Нельзя добавить вещь: коробка уже опечатана скотчем!
Пояснения к ответам

Тест 1. __exit__ вызывается автоматически при выходе из блока with; в успешном сценарии он ставит флаг is_sealed = True и возвращает True.

Тест 2. В случае ошибки __exit__ получает непустой exc_type, логирует сбой и возвращает False — исключение пробрасывается выше, поэтому try-except в вызывающем коде его перехватывает.

Тест 3. Бизнес-правило add_item блокирует изменение содержимого уже запечатанной коробки с помощью явного исключения RuntimeError.

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

❓Что гарантирует оператор `with`?
❓Как устроен оператор `with` под капотом?
❓Что возвращает `__enter__`?
❓Какие аргументы принимает `__exit__`?
❓Что означает возвращение `True` из `__exit__`?
❓Что произойдёт, если `__exit__` вернёт `False` (или ничего) при ошибке в блоке?

Практические упражнения на контекстные менеджеры ​

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

Упражнение 1: Сессия безопасного калькулятора (RomanCalcSession) ​

При проведении цепочки сложных математических расчетов с римскими числами (RomanNumber) важно вести лог сессии. Если в процессе вычислений происходит ошибка (например, деление на ноль или получение отрицательного римского числа), контекстный менеджер должен зафиксировать сбой и корректно закрыть сессию.

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

  1. Конструктор принимает имя пользователя (user).
  2. Метод __enter__ печатает на экран: "Сессия калькулятора для пользователя {user} начата".
  3. Метод __exit__ должен проверять наличие ошибок. Если сессия завершилась из-за ValueError (типичная ошибка римской математики), метод должен напечатать: "Сессия аварийно закрыта. Ошибка вычислений залогирована". При этом метод должен вернуть True, чтобы подавить ошибку и позволить программе работать дальше.
  4. Если ошибок не было, печатается: "Сессия успешно завершена".
python
# Ожидаемое поведение:
# with RomanCalcSession("Алексей") as calc:
#     print("[ВЫЧИСЛЕНИЕ] Роботы считают...")
#     raise ValueError("В римской системе нет нуля!")
#
# print("Программа продолжает работать...")  # Эта строка должна выполниться!

Упражнение 2: Контекстный менеджер весового контроля курьера (CourierLoading) ​

При погрузке посылок в автомобиль курьера необходимо строго контролировать суммарный вес. Контекстный менеджер погрузки должен автоматически взвешивать машину на въезде и выезде со склада.

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

  1. Конструктор принимает текущий вес пустого автомобиля (float).
  2. Метод __enter__ фиксирует этот вес и возвращает специальный внутренний список _loaded_items, куда логист будет добавлять веса загружаемых посылок через .append().
  3. Метод __exit__ должен посчитать сумму всех весов в списке _loaded_items, прибавить её к стартовому весу машины и вывести на экран финальный вес: "Автомобиль загружен. Финальный вес: {total_weight} кг".
python
# Ожидаемое поведение:
# with CourierLoading(start_weight=1500.0) as car_trunk:
#     car_trunk.append(12.5)  # Посылка 1
#     car_trunk.append(45.0)  # Посылка 2
#
# # Вывод на выходе из блока: Автомобиль загружен. Финальный вес: 1557.5 кг

Упражнение 3: Временной трекер сборки заказов (DeliveryTimer) ​

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

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

  1. Используйте встроенный модуль import time.
  2. В методе __enter__ зафиксируйте стартовое время сборки с помощью time.time().
  3. В методе __exit__ зафиксируйте конечное время, вычислите разницу и выведите её на экран в секундах с округлением до 2 знаков: "Время сборки заказа составило: {duration} сек.".

Упражнение 4: Транзакционный сейф почтовых отправлений (ParcelSafe) ​

Представьте цифровой сейф, где хранятся ценные трек-номера посылок. При открытии сейфа мы можем добавлять новые номера. Однако, если внутри блока with происходит любая непредвиденная системная ошибка, сейф должен выполнить откат (rollback) — стереть все изменения, внесенные за текущую сессию, чтобы защитить целостность данных.

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

  1. Класс хранит основной список проверенных трек-номеров _database.
  2. В методе __enter__ создается временная копия базы данных: self._backup = self._database.copy(). Метод возвращает self.
  3. Метод add_track(track_str) добавляет трек-номер в текущую базу _database.
  4. В методе __exit__ проверьте наличие исключений. Если произошла ошибка, восстановите базу из резервной копии: self._database = self._storage_backup и напечатайте "Произошел сбой системы! Выполнен откат изменений.".
python
# Ожидаемое поведение:
# safe = ParcelSafe()
# safe._database = ["RU-111", "RU-222"]
#
# try:
#     with safe as s:
#         s.add_track("RU-333")
#         raise RuntimeError("Критический сбой диска!")
# except RuntimeError:
#     pass
#
# print(safe._database)  # Должно остаться строго: ['RU-111', 'RU-222'] (без RU-333!)

Упражнение 5: Менеджер авто-блокировки посылки на таможне (CustomsInspection) ​

Когда посылка проходит таможенный досмотр, ей временно присваивается статус "На проверке". Контекстный менеджер должен гарантировать, что в каком бы статусе посылка ни завершила досмотр (успех или конфискация из-за запрещенного содержимого), в финале её статус автоматически изменится на безопасный закрытый режим.

Задание: Создайте класс CustomsInspection, моделирующий посылку с атрибутами name и status (строка):

  1. Метод __enter__ принудительно переводит посылку в статус "Досмотр в процессе". Метод возвращает сам объект посылки.
  2. Внутри блока with пользователь может изменить статус посылки на "Конфисковано" или "Одобрено".
  3. Метод __exit__ проверяет: если статус остался "Досмотр в процессе" (пользователь забыл его поменять) или произошла ошибка, статус автоматически перезаписывается на "Заблокировано до выяснения". Если статус был успешно изменен на "Одобрено", метод оставляет его без изменений.

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

Посмотреть решение Упражнения 1 (RomanCalcSession)
python
class RomanCalcSession:
    def __init__(self, user: str) -> None:
        self.user: str = user

    def __enter__(self) -> "RomanCalcSession":
        print(f"Сессия калькулятора для пользователя {self.user} начата")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        if exc_type is ValueError:
            print(f"Сессия аварийно закрыта. Ошибка вычислений залогирована: {exc_val}")
            return True  # Подавляем ошибку ValueError
        
        print("Сессия успешно завершена")
        return False  # Пропускаем остальные типы ошибок, если они возникнут

# Демонстрация:
with RomanCalcSession("Алексей") as calc:
    print("[ВЫЧИСЛЕНИЕ] Роботы считают...")
    raise ValueError("В римской системе нет нуля!")
print("Программа продолжает работать...")
Посмотреть решение Упражнения 2 (CourierLoading)
python
class CourierLoading:
    def __init__(self, start_weight: float) -> None:
        self.start_weight: float = start_weight
        self._loaded_items: list[float] = []

    def __enter__(self) -> list[float]:
        # Возвращаем именно список, чтобы пользователь работал с ним напрямую в as
        return self._loaded_items

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        if exc_type is None:
            total_cargo_weight = sum(self._loaded_items)
            final_weight = self.start_weight + total_cargo_weight
            print(f"Автомобиль загружен. Финальный вес: {final_weight} кг")
        return False

# Демонстрация:
with CourierLoading(start_weight=1500.0) as car_trunk:
    car_trunk.append(12.5)
    car_trunk.append(45.0)
# Вывод: Автомобиль загружен. Финальный вес: 1557.5 кг
Посмотреть решение Упражнения 3 (DeliveryTimer)
python
import time

class DeliveryTimer:
    def __enter__(self) -> "DeliveryTimer":
        self.start_time = time.time()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        end_time = time.time()
        duration = round(end_time - self.start_time, 2)
        print(f"Время сборки заказа составило: {duration} сек.")
        return False

# Демонстрация:
with DeliveryTimer() as timer:
    time.sleep(0.3)
# Вывод: Время сборки заказа составило: ≈0.3 сек.
Посмотреть решение Упражнения 4 (ParcelSafe с откатом)
python
class ParcelSafe:
    def __init__(self) -> None:
        self._database: list[str] = []

    def __enter__(self) -> "ParcelSafe":
        # Создаем копию на случай аварийного отката
        self._backup = self._database.copy()
        return self

    def add_track(self, track_str: str) -> None:
        self._database.append(track_str)

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        if exc_type is not None:
            # Если произошла ошибка, восстанавливаем исходное состояние базы
            self._database = self._backup
            print(f"[ОТКАТ] Произошел сбой системы! Изменения отменены.")
        else:
            print("[УСПЕХ] Все изменения транзакции успешно сохранены в базу данных.")
        return False  # Ошибку не гасим, передаем наверх

# Демонстрация:
safe = ParcelSafe()
safe._database = ["RU-111", "RU-222"]
try:
    with safe as s:
        s.add_track("RU-333")
        raise RuntimeError("Критический сбой диска!")
except RuntimeError:
    pass
print(safe._database)   # ['RU-111', 'RU-222'] — RU-333 откатится
Посмотреть решение Упражнения 5 (CustomsInspection)
python
class CustomsInspection:
    def __init__(self, name: str) -> None:
        self.name: str = name
        self.status: str = "Новая"

    def __enter__(self) -> "CustomsInspection":
        self.status = "Досмотр в процессе"
        return self

    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
        if exc_type is not None or self.status == "Досмотр в процессе":
            self.status = "Заблокировано до выяснения"
            print(f"[ТАМОЖНЯ] Посылка {self.name} автоматически ЗАБЛОКИРОВАНА.")
        else:
            print(f"[ТАМОЖНЯ] Проверка завершена. Текущий статус: {self.status}")
        return False

# Демонстрация:
parcel = CustomsInspection("Посылка_RU-101")
with parcel as p:
    p.status = "Одобрено"
print(parcel.status)   # Одобрено — статус сохранен

forgotten = CustomsInspection("Посылка_RU-102")
with forgotten as f:
    pass   # Статус не изменен пользователем
print(forgotten.status)   # Заблокировано до выяснения

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

Перед тем как завершить урок, убедитесь, что вы: • Четко понимаете, в каких сценариях метод exit должен возвращать True, а в каких — False. • Помните, что если в enter не написать return self, то переменная после ключевого слова as получит значение None. • Знаете, что метод exit выполнится в любом случае, даже если код внутри блока with упал с критической ошибкой.