一次打开多个（未指定数量）文件并确保它们正确关闭

Question

我知道我可以使用类似的方法打开多个文件，

with open('a', 'rb') as a, open('b', 'rb') as b:

但我有一种情况，我有一个要打开的文件列表，并且想知道当文件数量事先未知时执行相同操作的首选方法是什么。类似的东西

with [ open(f, 'rb') for f in files ] as fs:

（但是由于列表没有实现__exit__，所以失败并出现AttributeError）

我不介意使用类似的东西，

try:
    fs = [ open(f, 'rb') for f in files ]

    ....

finally:
    for f in fs:
        f.close()

但我不确定如果某些尝试打开文件时抛出文件。 fs 是否会在 finally 块中正确定义，并包含成功打开的文件？

Answer 1

不，除非所有 open() 调用成功完成，否则您的代码不会初始化 fs。但这应该可以工作：

fs = []
try:
    for f in files:
        fs.append(open(f, 'rb'))

    ....

finally:
    for f in fs:
        f.close()

另请注意， f.close() 可能会失败，因此您可能希望捕获并忽略（或以其他方式处理）那里的任何失败。

Answer 2

当然，为什么不呢，这是一个可以做到这一点的食谱。创建一个上下文管理器“池”，它可以输入任意数量的上下文（通过调用它的 enter() 方法），并且它们将在套件结束时被清理。

class ContextPool(object):
    def __init__(self):
        self._pool = []

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, exc_tb):
        for close in reversed(self._pool):
            close(exc_type, exc_value, exc_tb)

    def enter(self, context):
        close = context.__exit__
        result = context.__enter__()
        self._pool.append(close)
        return result

例如：

>>> class StubContextManager(object):
...     def __init__(self, name):
...         self.__name = name
...     def __repr__(self):
...         return "%s(%r)" % (type(self).__name__, self.__name)
... 
...     def __enter__(self):
...          print "called %r.__enter__()" % (self)
... 
...     def __exit__(self, *args):
...          print "called %r.__exit__%r" % (self, args)
... 
>>> with ContextPool() as pool:
...     pool.enter(StubContextManager("foo"))
...     pool.enter(StubContextManager("bar"))
...     1/0
... 
called StubContextManager('foo').__enter__()
called StubContextManager('bar').__enter__()
called StubContextManager('bar').__exit__(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or modulo by zero',), <traceback object at 0x02958648>)
called StubContextManager('foo').__exit__(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or modulo by zero',), <traceback object at 0x02958648>)

Traceback (most recent call last):
  File "<pyshell#67>", line 4, in <module>
    1/0
ZeroDivisionError: integer division or modulo by zero
>>> 

警告：上下文管理器不应在其 __exit__() 方法中引发异常，但如果引发异常，则此方案不会对所有上下文管理器进行清理。同样，即使每个上下文管理器都指示应忽略异常（通过从其退出方法返回 True），这仍然允许引发异常。

Answer 3

类 ExitStack 来自 < href="https://docs.python.org/3/library/contextlib.html#module-contextlib" rel="noreferrer">contextlib 模块提供您所需的功能寻找。
文档中提到的规范用例是管理动态数量的文件。

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

Answer 4

尝试打开文件、尝试读取文件以及（极少数情况下）尝试关闭文件时可能会发生错误。

因此，基本的错误处理结构可能如下所示：

try:
    stream = open(path)
    try:
        data = stream.read()
    finally:
        stream.close()
except EnvironmentError as exception:
    print 'ERROR:', str(exception)
else:
    print 'SUCCESS'
    # process data

这确保如果 stream 变量存在，则始终会调用 close。如果 stream 不存在，则 open 一定失败，因此没有要关闭的文件（在这种情况下， except 块将立即执行）。

您真的需要并行打开文件，还是可以顺序处理它们？如果是后者，则应将类似上述文件处理代码的内容放入一个函数中，然后为列表中的每个路径调用该函数。

Answer 5

感谢您的所有回答。受到大家的启发，我提出了以下建议。我认为（希望）它能按我的预期工作。我不确定是否将其作为问题的答案或补充发布，但认为答案更合适，因为如果它未能满足我的要求，可以对其进行适当的评论。

它可以像这样使用..

with contextlist( [open, f, 'rb'] for f in files ) as fs:
    ....

或像这样..

f_lock = threading.Lock()
with contextlist( f_lock, ([open, f, 'rb'] for f in files) ) as (lock, *fs):
    ....

在这里，

import inspect
import collections
import traceback

class contextlist:

    def __init__(self, *contexts):

        self._args = []

        for ctx in contexts:
            if inspect.isgenerator(ctx):
                self._args += ctx 
            else:
                self._args.append(ctx)


    def __enter__(self):

        if hasattr(self, '_ctx'):
            raise RuntimeError("cannot reenter contextlist")

        s_ctx = self._ctx = []

        try:
            for ctx in self._args:

                if isinstance(ctx, collections.Sequence):
                    ctx = ctx[0](*ctx[1:])

                s_ctx.append(ctx)

                try:
                    ctx.__enter__()
                except Exception:
                    s_ctx.pop()
                    raise

            return s_ctx

        except:
            self.__exit__()
            raise


    def __exit__(self, *exc_info):

        if not hasattr(self, '_ctx'):
            raise RuntimeError("cannot exit from unentered contextlist")

        e = []

        for ctx in reversed(self._ctx):
            try:
                ctx.__exit__()
            except Exception:
                e.append(traceback.format_exc())

        del self._ctx

        if not e == []: 
            raise Exception('\n>   '*2+(''.join(e)).replace('\n','\n>   '))