Краткий ответ

Оператор with использует протокол контекстного менеджера: перед выполнением блока вызывает __enter__(), а при выходе — __exit__(). Метод __exit__() вызывается как при обычном завершении, так и при исключении внутри блока; если он возвращает истинное значение, исключение подавляется.

Исторический контекст

Конструкция with появилась как стандартизированный способ безопасно управлять ресурсами: файлами, блокировками, транзакциями и временными состояниями. Она решает типичную проблему ручного дублирования очистки в ветках успешного выполнения и обработки ошибок.

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

Постановка проблемы

Ресурс может потребовать освобождения после частично выполненной операции. Если исключение прерывает блок до явного вызова очистки, файл останется открытым, блокировка — удержанной, а транзакция — в неопределённом состоянии.

Ручной try...finally решает задачу, но при большом числе ресурсов усложняет вложенность и повышает риск ошибки. Важно также учитывать границы гарантии: если __enter__() завершился исключением, __exit__() для этого менеджера не вызывается.

Подробное решение

При выполнении with Python сначала вычисляет объект-менеджер и вызывает его __enter__(). Возвращаемое этим методом значение передаётся переменной после as, если такая переменная указана.

Затем выполняется тело блока. После него Python вызывает __exit__() с тремя аргументами: типом исключения, самим исключением и объектом трассировки. При нормальном завершении все три аргумента имеют значение None.

class Guard:
    def __enter__(self):
        print("вход")
        return self

    def __exit__(self, exc_type, exc, tb):
        print("выход")
        return False

with Guard():
    print("работа")
    raise ValueError("ошибка")

Здесь сначала печатаются вход, работа и выход, после чего ValueError продолжает распространяться: __exit__() вернул False. Если вернуть истинное значение, исключение будет считаться обработанным и наружу не выйдет.

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

Если используются несколько контекстных менеджеров, их вход выполняется слева направо, а выход — в обратном порядке. Это образует стек вложенных контекстов и позволяет корректно освобождать зависимости: последний захваченный ресурс освобождается первым.

Ситуация из практики

Сервис записывает данные в файл и обязан закрыть его даже при ошибке сериализации. Вариант с ручным вызовом close() прост, но не защищает от исключения между открытием файла и закрытием. Вариант с try...finally надёжен, однако при нескольких ресурсах быстро становится громоздким.

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

Что кандидаты часто упускают

1. Вызывается ли __exit__(), если __enter__() завершился исключением?

Нет. __exit__() вызывается только после успешного завершения __enter__(). Если ресурс создаётся внутри __enter__() и затем там возникает ошибка, сам __enter__() должен позаботиться об очистке уже созданной части ресурса.

2. Как контекстный менеджер может подавить исключение?

__exit__() возвращает истинное значение, например True. Тогда исключение, возникшее в теле with, считается обработанным. Это следует применять только когда менеджер действительно знает, что ошибка ожидаема и безопасна для подавления; безусловное подавление усложняет диагностику и может скрыть дефект.

3. Что произойдёт, если исключение возникнет внутри __exit__()?

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