改进“with”的直接替换Python 2.4 的声明

Question

您能否建议一种方法来编写可在 Python 2.4 中使用的“with”语句的直接替换代码？

这将是一个 hack，但它可以让我更好地将我的项目移植到 Python 2.4。

编辑： 删除了不相关的元类草图

Answer 1

只需使用 try-finally 即可。

确实，这作为一种心理练习可能很好，但如果你真的在你关心的代码中这样做，你最终会得到丑陋的、难以维护的代码。

Answer 2

我认为你可以（ab）使用装饰器来做到这一点。以下内容有效，例如：（

def execute_with_context_manager(man):
    def decorator(f):
        target = man.__enter__()
        exc = True
        try:
            try:
                f(target)
            except:
                exc = False
                if not man.__exit__(*sys.exc_info()):
                    raise
        finally:
            if exc:
                man.__exit__(None, None, None)
        return None
    return decorator

@execute_with_context_manager(open("/etc/motd"))
def inside(motd_file):
    for line in motd_file:
        print line,

嗯，在Python 2.4文件对象中没有 __enter__ 和 __exit__ 方法，但除此之外它可以工作）

这个想法是你将 with 行 in: 替换

with bar() as foo:
    do_something_with(foo)
    do_something_else_with(foo)
    # etc...

为装饰函数“声明” in:

@execute_with_context_manager( bar() )
def dummyname( foo ):
    do_something_with(foo)
    do_something_else_with(foo)
    # etc...

但是获得相同的行为（执行 do_something_... 代码）。请注意，装饰器将函数声明更改为立即调用，这有点邪恶。

Answer 3

由于您需要在错误期间和非错误期间退出上下文管理器，因此我认为不可能使用元类执行通用用例，或者实际上根本不可能。为此，您将需要 try/finally 块。

但也许根据你的情况可以做其他事情。这取决于您使用上下文管理器的用途。

使用 __del__ 在某些情况下会有所帮助，例如释放资源，但由于您无法确定它是否被调用，因此只能在您需要释放程序退出时释放的资源时使用它。如果您在 __exit__ 方法中处理异常，这也不起作用。

我想最干净的方法是将整个上下文管理包装在一种上下文管理调用中，并将代码块提取到一个方法中。像这样的东西（未经测试的代码，但大部分是从 PEP 343 窃取的）：

def call_as_context_manager(mgr, function):
    exit = mgr.__exit__
    value = mgr.__enter__()
    exc = True
    try:
        try:
            function(value)
        except:
            exc = False
            if not exit(*sys.exc_info()):
                raise
    finally:
        if exc:
            exit(None, None, None)

Answer 4

这个怎么样？

def improvize_context_manager(*args, **kwargs):

    assert (len(args) + len(kwargs)) == 1
    if args:
        context_manager = args[0]
        as_ = None
    else: # It's in kwargs
        (as_, context_manager) = kwargs.items()[0]

    def decorator(f):
        exit_ = context_manager.__exit__  # Not calling it yet
        enter_ = context_manager.__enter__()
        exc = True
        try:
            try:
                if as_:
                    f(*{as_: enter_})
                else:
                    f()
            except:
                exc = False
                if not exit_(*sys.exc_info()):
                    raise
        finally:
            if exc:
            exit_(None, None, None)
        return None
    return decorator

用法：

@improvize_context_manager(lock)
def null():
    do(stuff)

与不带 as 的 with 关键字并行。

或者：

@improvize_context_manager(my_lock=lock)
def null(my_lock):
    do(stuff_with, my_lock)

它与 with 关键字与 as 类似。

Answer 5

如果您同意使用 def 只是为了获取一个块和立即执行的装饰器，那么您可以使用函数签名来为指定的情况获得更自然的东西。

import sys
def with(func):
    def decorated(body = func):
        contexts = body.func_defaults
        try:
            exc = None, None, None
            try:
                for context in contexts:
                    context.__enter__()
                body()
            except:
                exc = sys.exc_info()
                raise
        finally:
            for context in reversed(contexts):
                context.__exit__(*exc)
    decorated()

class Context(object):
    def __enter__(self):
        print "Enter %s" % self
    def __exit__(self, *args):
        print "Exit %s(%s)" % (self, args)

x = Context()

@with
def _(it = x):
    print "Body %s" % it

@with
def _(it = x):
    print "Body before %s" % it
    raise "Nothing"
    print "Body after %s" % it