gpt4 book ai didi

python - 使用可变数量的上下文管理器替代 contextlib.nested

转载 作者:IT老高 更新时间:2023-10-28 22:22:39 27 4
gpt4 key购买 nike

我们的代码根据运行时参数调用可变数量的上下文管理器:

from contextlib import nested, contextmanager

@contextmanager
def my_context(arg):
print("entering", arg)
try:
yield arg
finally:
print("exiting", arg)

def my_fn(items):
with nested(*(my_context(arg) for arg in items)) as managers:
print("processing under", managers)

my_fn(range(3))

但是,contextlib.nested is deprecated since Python 2.7 :

DeprecationWarning: With-statements now directly support multiple context managers

Multiple variables in Python 'with' statement 的答案表明 contextlib.nested 有一些“令人困惑的容易出错的怪癖”,但使用多管理器 with 语句的建议替代方法不适用于可变数量的上下文管理器(并且还破坏了向后兼容性)。

contextlib.nested 是否有任何替代品未被弃用并且(最好)没有相同的错误?

或者我应该继续使用 contextlib.nested 并忽略警告?如果是这样,我是否应该计划在将来的某个时间删除 contextlib.nested

最佳答案

新的Python 3 contextlib.ExitStack class被添加为 contextlib.nested() 的替代品(参见 issue 13585 )。

它的编码方式可以让你直接在 Python 2 中使用它:

import sys
from collections import deque


class ExitStack(object):
"""Context manager for dynamic management of a stack of exit callbacks

For example:

with ExitStack() as stack:
files = [stack.enter_context(open(fname)) for fname in filenames]
# All opened files will automatically be closed at the end of
# the with statement, even if attempts to open files later
# in the list raise an exception

"""
def __init__(self):
self._exit_callbacks = deque()

def pop_all(self):
"""Preserve the context stack by transferring it to a new instance"""
new_stack = type(self)()
new_stack._exit_callbacks = self._exit_callbacks
self._exit_callbacks = deque()
return new_stack

def _push_cm_exit(self, cm, cm_exit):
"""Helper to correctly register callbacks to __exit__ methods"""
def _exit_wrapper(*exc_details):
return cm_exit(cm, *exc_details)
_exit_wrapper.__self__ = cm
self.push(_exit_wrapper)

def push(self, exit):
"""Registers a callback with the standard __exit__ method signature

Can suppress exceptions the same way __exit__ methods can.

Also accepts any object with an __exit__ method (registering a call
to the method instead of the object itself)
"""
# We use an unbound method rather than a bound method to follow
# the standard lookup behaviour for special methods
_cb_type = type(exit)
try:
exit_method = _cb_type.__exit__
except AttributeError:
# Not a context manager, so assume its a callable
self._exit_callbacks.append(exit)
else:
self._push_cm_exit(exit, exit_method)
return exit # Allow use as a decorator

def callback(self, callback, *args, **kwds):
"""Registers an arbitrary callback and arguments.

Cannot suppress exceptions.
"""
def _exit_wrapper(exc_type, exc, tb):
callback(*args, **kwds)
# We changed the signature, so using @wraps is not appropriate, but
# setting __wrapped__ may still help with introspection
_exit_wrapper.__wrapped__ = callback
self.push(_exit_wrapper)
return callback # Allow use as a decorator

def enter_context(self, cm):
"""Enters the supplied context manager

If successful, also pushes its __exit__ method as a callback and
returns the result of the __enter__ method.
"""
# We look up the special methods on the type to match the with statement
_cm_type = type(cm)
_exit = _cm_type.__exit__
result = _cm_type.__enter__(cm)
self._push_cm_exit(cm, _exit)
return result

def close(self):
"""Immediately unwind the context stack"""
self.__exit__(None, None, None)

def __enter__(self):
return self

def __exit__(self, *exc_details):
# We manipulate the exception state so it behaves as though
# we were actually nesting multiple with statements
frame_exc = sys.exc_info()[1]
def _fix_exception_context(new_exc, old_exc):
while 1:
exc_context = new_exc.__context__
if exc_context in (None, frame_exc):
break
new_exc = exc_context
new_exc.__context__ = old_exc

# Callbacks are invoked in LIFO order to match the behaviour of
# nested context managers
suppressed_exc = False
while self._exit_callbacks:
cb = self._exit_callbacks.pop()
try:
if cb(*exc_details):
suppressed_exc = True
exc_details = (None, None, None)
except:
new_exc_details = sys.exc_info()
# simulate the stack of exceptions by setting the context
_fix_exception_context(new_exc_details[1], exc_details[1])
if not self._exit_callbacks:
raise
exc_details = new_exc_details
return suppressed_exc

使用它作为你的上下文管理器,然后随意添加嵌套上下文管理器:

with ExitStack() as stack:
managers = [stack.enter_context(my_context(arg)) for arg in items]
print("processing under", managers)

对于您的示例上下文管理器,这将打印:

>>> my_fn(range(3))
('entering', 0)
('entering', 1)
('entering', 2)
('processing under', [0, 1, 2])
('exiting', 2)
('exiting', 1)
('exiting', 0)

您也可以安装 contextlib2 module ;它包含 ExitStack 作为后向端口。

关于python - 使用可变数量的上下文管理器替代 contextlib.nested,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/16083791/

27 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com