Является ли Python * с инструкцией *, точно эквивалентной блоку try - (except) - finally?

Я знаю, что это широко обсуждалось, но я до сих пор не могу найти ответ, чтобы подтвердить это: оператор with, идентичный тому, который вызывает тот же код в блоке try - (except) -finally, где все, что определено в __exit__ функция контекстного менеджера помещается в блок finally?

Например, эти два фрагмента кода делают одно и то же?

import sys
from contextlib import contextmanager

@contextmanager
def open_input(fpath):
    fd = open(fpath) if fpath else sys.stdin
    try:
        yield fd
    finally:
        fd.close()

with open_input("/path/to/file"):
    print "starting to read from file..."

то же самое, что:

def open_input(fpath):
    try:
        fd = open(fpath) if fpath else sys.stdin
        print "starting to read from file..."
    finally:
        fd.close()

open_input("/path/to/file")

Спасибо!

Ответы

Ответ 1

Я собираюсь отложить упоминания о сфере видимости, потому что это действительно не очень актуально.

Согласно PEP 343,

with EXPR as VAR:
    BLOCK

переводится на

mgr = (EXPR)
exit = type(mgr).__exit__  # Not calling it yet
value = type(mgr).__enter__(mgr)
exc = True
try:
    try:
        VAR = value  # Only if "as VAR" is present
        BLOCK
    except:
        # The exceptional case is handled here
        exc = False
        if not exit(mgr, *sys.exc_info()):
            raise
        # The exception is swallowed if exit() returns true
finally:
    # The normal and non-local-goto cases are handled here
    if exc:
        exit(mgr, None, None, None)

Как вы можете видеть, type(mgr).__enter__ вызывается, как вы ожидаете, но не внутри try.

type(mgr).__exit__ вызывается при выходе. Единственное отличие состоит в том, что , когда есть исключение, путь if not exit(mgr, *sys.exc_info()) берется. Это дает возможность with распознавать и изменять ошибки в отличие от того, что может сделать предложение finally.

contextmanager не усложняет это. Это просто:

def contextmanager(func):
    @wraps(func)
    def helper(*args, **kwds):
        return _GeneratorContextManager(func, *args, **kwds)
    return helper

Затем посмотрите на класс, о котором идет речь:

class _GeneratorContextManager(ContextDecorator):
    def __init__(self, func, *args, **kwds):
        self.gen = func(*args, **kwds)

    def __enter__(self):
        try:
            return next(self.gen)
        except StopIteration:
            raise RuntimeError("generator didn't yield") from None

    def __exit__(self, type, value, traceback):
        if type is None:
            try:
                next(self.gen)
            except StopIteration:
                return
            else:
                raise RuntimeError("generator didn't stop")
        else:
            if value is None:
                value = type()
            try:
                self.gen.throw(type, value, traceback)
                raise RuntimeError("generator didn't stop after throw()")
            except StopIteration as exc:
                return exc is not value
            except:
                if sys.exc_info()[1] is not value:
                    raise

Исключен несущественный код.

Прежде всего следует отметить, что если имеется несколько yield s, этот код будет ошибочным.

Это не влияет на поток управления заметно.

Рассмотрим __enter__.

try:
    return next(self.gen)
except StopIteration:
    raise RuntimeError("generator didn't yield") from None

Если менеджер контекста был хорошо написан, это никогда не сломается от ожидаемого.

Одно отличие состоит в том, что если генератор выбрасывает StopIteration, будет создана другая ошибка (RuntimeError). Это означает, что поведение не полностью совпадает с обычным with, если вы "выполняется полностью произвольный код.

Рассмотрим ошибку без ошибок __exit__:

if type is None:
    try:
        next(self.gen)
    except StopIteration:
        return
    else:
        raise RuntimeError("generator didn't stop")

Единственное отличие по-прежнему; если ваш код выбрасывает StopIteration, это повлияет на генератор, и, таким образом, декоратор contextmanager неправильно интерпретирует его.

Это означает, что:

from contextlib import contextmanager

@contextmanager
def with_cleanup(func):
    try:
        yield
    finally:
        func()

def good_cleanup():
    print("cleaning")

with with_cleanup(good_cleanup):
    print("doing")
    1/0
#>>> doing
#>>> cleaning
#>>> Traceback (most recent call last):
#>>>   File "", line 15, in <module>
#>>> ZeroDivisionError: division by zero

def bad_cleanup():
    print("cleaning")
    raise StopIteration

with with_cleanup(bad_cleanup):
    print("doing")
    1/0
#>>> doing
#>>> cleaning

Что вряд ли имеет значение, но это может быть.

Наконец:

else:
    if value is None:
        value = type()
    try:
        self.gen.throw(type, value, traceback)
        raise RuntimeError("generator didn't stop after throw()")
    except StopIteration as exc:
        return exc is not value
    except:
        if sys.exc_info()[1] is not value:
            raise

Возникает тот же вопрос о StopIteration, но интересно отметить, что последняя часть.

if sys.exc_info()[1] is not value:
    raise

Это означает, что если исключение необработанно, трассировка не изменится. Если он был обработан, но существует новая трассировка, это будет создано вместо этого.

Это идеально соответствует спецификации.

TL; DR

  • with на самом деле немного более мощный, чем try...finally, поскольку with может анализировать и прерывать ошибки.

  • Будьте осторожны с StopIteration, но в противном случае вы можете использовать @contextmanager для создания менеджеров контекста.