Appearance
Контекстные менеджеры (with, __enter__ и __exit__)
В реальной разработке программы постоянно работают с внешними ресурсами: открывают файлы на диске, подключаются к базам данных или устанавливают сетевые соединения. Главная опасность здесь — забыть вовремя закрыть ресурс. Если файл останется открытым, память «потечет», а другие программы не смогут получить к нему доступ.
Для решения этой проблемы в Python существует оператор with и протокол контекстного менеджера. Он гарантирует, что ресурс будет автоматически и гарантированно закрыт (или очищен), как только работа в блоке кода завершится — даже если внутри программы произошла критическая ошибка.
На этом уроке мы разберем магические методы __enter__ и __exit__ и применим их для управления жизненным циклом нашей Почтовой Коробки.
1. Как устроен оператор with под капотом
Когда вы пишете код с оператором with:
python
with open("parcel.txt", "w", encoding="utf-8") as file:
file.write("Посылка отправлена")Python скрытно выполняет следующий протокол:
- Вызывает метод
__enter__у объекта контекста. То, что этот метод возвращает, записывается в переменную после ключевого словаas(в данном случае — вfile). - Выполняет блок кода внутри
with. - При выходе из блока (неважно, успешном или из-за ошибки) всегда вызывает метод
__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:
- Конструктор принимает имя пользователя (
user). - Метод
__enter__печатает на экран:"Сессия калькулятора для пользователя {user} начата". - Метод
__exit__должен проверять наличие ошибок. Если сессия завершилась из-заValueError(типичная ошибка римской математики), метод должен напечатать:"Сессия аварийно закрыта. Ошибка вычислений залогирована". При этом метод должен вернутьTrue, чтобы подавить ошибку и позволить программе работать дальше. - Если ошибок не было, печатается:
"Сессия успешно завершена".
python
# Ожидаемое поведение:
# with RomanCalcSession("Алексей") as calc:
# print("[ВЫЧИСЛЕНИЕ] Роботы считают...")
# raise ValueError("В римской системе нет нуля!")
#
# print("Программа продолжает работать...") # Эта строка должна выполниться!Упражнение 2: Контекстный менеджер весового контроля курьера (CourierLoading)
При погрузке посылок в автомобиль курьера необходимо строго контролировать суммарный вес. Контекстный менеджер погрузки должен автоматически взвешивать машину на въезде и выезде со склада.
Задание: Создайте класс CourierLoading:
- Конструктор принимает текущий вес пустого автомобиля (
float). - Метод
__enter__фиксирует этот вес и возвращает специальный внутренний список_loaded_items, куда логист будет добавлять веса загружаемых посылок через.append(). - Метод
__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:
- Используйте встроенный модуль
import time. - В методе
__enter__зафиксируйте стартовое время сборки с помощьюtime.time(). - В методе
__exit__зафиксируйте конечное время, вычислите разницу и выведите её на экран в секундах с округлением до 2 знаков:"Время сборки заказа составило: {duration} сек.".
Упражнение 4: Транзакционный сейф почтовых отправлений (ParcelSafe)
Представьте цифровой сейф, где хранятся ценные трек-номера посылок. При открытии сейфа мы можем добавлять новые номера. Однако, если внутри блока with происходит любая непредвиденная системная ошибка, сейф должен выполнить откат (rollback) — стереть все изменения, внесенные за текущую сессию, чтобы защитить целостность данных.
Задание: Создайте класс ParcelSafe:
- Класс хранит основной список проверенных трек-номеров
_database. - В методе
__enter__создается временная копия базы данных:self._backup = self._database.copy(). Метод возвращаетself. - Метод
add_track(track_str)добавляет трек-номер в текущую базу_database. - В методе
__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 (строка):
- Метод
__enter__принудительно переводит посылку в статус"Досмотр в процессе". Метод возвращает сам объект посылки. - Внутри блока
withпользователь может изменить статус посылки на"Конфисковано"или"Одобрено". - Метод
__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 упал с критической ошибкой.