在 __enter__ 中输入上下文管理器答案

【问题标题】：entering context managers in __enter__在 __enter__ 中输入上下文管理器
【发布时间】：2018-05-22 04:20:30
【问题描述】：

将上下文管理器定义为函数，很容易以编程方式从一个内部输入一个单独的（或递归的）上下文管理器，如下所示：

@contextmanager
def enter(times):
    if times:
        with enter(times - 1) as tup:
            print 'entering {}'.format(times)
            yield tup + (times,)
            print 'exiting {}'.format(times)
    else:
        yield ()

运行这个：

In [11]: with enter(4) as x:
....:     print x
....:
entering 1
entering 2
entering 3
(1, 2, 3)
exiting 3
exiting 2
exiting 1

所有的出入境簿记都为您完成，真好！但是如果你有一个类而不是一个函数呢？

class Enter(object):
    def __init__(self, times):
        self.times = times

    def __enter__(self):
        print 'entering {}'.format(self.times)
        if self.times:
            with Enter(self.times - 1) as tup:  # WRONG
                return tup + (self.times,)
        return ()

    def __exit__(self, *_):
        print 'exiting {}'.format(self.times)

运行这个是错误的，因为你在运行 with-block 中的任何代码之前输入并退出嵌套调用：

In [12]: with Enter(3) as tup:
    print tup
....:
entering 3
entering 2
entering 1
entering 0
exiting 0
exiting 1
exiting 2
(1, 2, 3)
exiting 3

规定：不能强迫客户自己使用ExitStack；内部调用必须像在生成器中一样被封装。涉及Enter 维护自己的私有堆栈的解决方案也是次优的（在现实生活中，内部__exit__ 调用必须以线程安全的方式匹配到内部__enter__ 调用，但我会即使在这个简单的示例中，也希望尽可能避免这种手动记账。）

【问题讨论】：

你不能在你的__enter__()方法中使用with，因为它太多了。您需要：1) 创建另一个 Enter() 实例，2) 手动调用其 __enter__()，3) 将其 __exit__ 保存在实例变量中，以便您可以在 __exit__() 中调用它。跨度>

标签： python macros contextmanager

【解决方案1】：

在__enter__ 中使用嵌套的上下文管理器似乎很神奇。

看看这个：

class Enter(object):
    def __init__(self, times):
        self.times = times

    def __enter__(self):
        print('entering {}'.format(self.times))
        if self.times:
            with Enter(self.times - 1) as tup:  # WRONG
                print('returning {}'.format(tup))
                return tup + (self.times,)
        print('returning () from times={}'.format(self.times))
        return ()

    def __exit__(self, *_):
        print('exiting {}'.format(self.times))

with Enter(3) as tup:
    print(tup)

运行此打印

entering 3
entering 2
entering 1
entering 0
returning () from times=0
returning ()
exiting 0
returning (1,)
exiting 1
returning (1, 2)
exiting 2
(1, 2, 3)
exiting 3

我认为这在某种程度上是有道理的。当您调用 with Enter(3) ... 时，心智模型可能是必须“完成”__enter__ 方法，而“完成”意味着进入和退出所有上下文管理器。

def foo():
    with Enter(2) as tup:
        return tup
# we expect Enter to exit before we return, so why would it be different when
# we rename foo to __enter__?

让我们明确地这样做。

In [3]: %paste
class Enter(object):

    def __init__(self, times):
        self.times = times
        self._ctx = None

    def __enter__(self):
        print('entering {}'.format(self.times))
        if self.times:
            self._ctx = Enter(self.times - 1)
            tup = self._ctx.__enter__()
            return tup + (self.times,)
        else:
            return ()

    def __exit__(self, *_):
        if self._ctx is not None:
            self._ctx.__exit__()
        print('exiting {}'.format(self.times))

In [4]: with Enter(3) as tup:
   ...:     print(tup)
   ...:
entering 3
entering 2
entering 1
entering 0
(1, 2, 3)
exiting 0
exiting 1
exiting 2
exiting 3

（在@jasonharper 的指导下回答。）

【讨论】：

【解决方案2】：

我很惊讶它还没有添加到标准库中，但是当我需要一个类作为上下文管理器时，我正在使用以下工具：

class ContextManager(metaclass=abc.ABCMeta):
  """Class which can be used as `contextmanager`."""

  def __init__(self):
    self.__cm = None

  @abc.abstractmethod
  @contextlib.contextmanager
  def contextmanager(self):
    raise NotImplementedError('Abstract method')

  def __enter__(self):
    self.__cm = self.contextmanager()
    return self.__cm.__enter__()

  def __exit__(self, exc_type, exc_value, traceback):
    return self.__cm.__exit__(exc_type, exc_value, traceback)

用法：

class MyClass(ContextManager):

  @contextlib.contextmanager
  def contextmanager(self):
    try:
      print('Entering...')
      yield self
    finally:
      print('Exiting...')


with MyClass() as x:
  print(x)

【讨论】：