blocks|key|527460|text|不，除非所有open()调用都成功完成，否则您的代码不会初始化fs。不过，这应该是可行的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527461|fs+=+[]
try:
++++for+f+in+files:
++++++++fs.append(open(f,+'rb'))

++++....

finally:
++++for+f+in+fs:
++++++++f.close()|code-block|syntax|javascript|527462|还要注意，f.close()可能会失败，因此您可能希望捕获并忽略(或以其他方式处理)那里的任何失败。|527463|entityMap^0|6|6|V|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

No, your code wouldn't initialise <code>fs</code> unless all <code>open()</code> calls completed successfully. This should work though:

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

 ....

finally:
 for f in fs:
 f.close()
</code></pre>

Note also that f.close() could fail so you may want to catch and ignore (or otherwise handle) any failures there.

blocks|key|527539|text|尝试打开文件时、尝试读取文件时以及(极少数情况下)尝试关闭文件时可能会发生错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527540|因此，基本的错误处理结构可能如下所示：|527541|try:
++++stream+=+open(path)
++++try:
++++++++data+=+stream.read()
++++finally:
++++++++stream.close()
except+EnvironmentError+as+exception:
++++print+'ERROR:',+str(exception)
else:
++++print+'SUCCESS'
++++#+process+data|code-block|syntax|javascript|527542|这可以确保在stream变量存在的情况下始终调用close。如果stream不存在，那么open一定失败了，因此没有要关闭的文件(在这种情况下，except块将被立即执行)。|offset|length|style|CODE|527543|您是否真的需要并行打开这些文件，或者可以按顺序处理这些文件？如果是后者，则应该将类似上述文件处理代码的内容放入一个函数中，然后为列表中的每个路径调用该函数。|527544|entityMap^0|0|0|0|6|6|O|5|W|6|18|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]|$K|10|L|11|M|N]|$K|12|L|13|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

Errors can occur when attempting to open a file, when attempting to read from a file, and (very rarely) when attempting to close a file.

So a basic error handling structure might look like:

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

This ensures that <code>close</code> will always be called if the <code>stream</code> variable exists. If <code>stream</code> doesn't exist, then <code>open</code> must have failed, and so there is no file to close (in which case, the except block will be executed immediately).

Do you really need to have the files open in parallel, or can they be processed sequentially? If the latter, then something like the above file-processing code should be put in a function, which is then called for each path in the list.

blocks|key|744162|text|当然，为什么不呢，这里有一个食谱可以做到这一点。创建一个上下文管理器‘池’，它可以输入任意数量的上下文(通过调用它的enter()方法)，它们将在套件结束时被清除。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|744163|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|code-block|syntax|javascript|744164|例如：|744165|>>>+class+StubContextManager(object):
...+++++def+__init__(self,+name):
...+++++++++self.__name+=+name
...+++++def+__repr__(self):
...+++++++++return+"%25s(%25r)"+%25+(type(self).__name__,+self.__name)
...+
...+++++def+__enter__(self):
...++++++++++print+"called+%25r.__enter__()"+%25+(self)
...+
...+++++def+__exit__(self,+*args):
...++++++++++print+"called+%25r.__exit__%25r"+%25+(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
>>>+|744166|注意:上下文管理器不应该在他们的__exit__()方法中引发异常，但是如果他们这样做了，这个方法并不会对所有的上下文管理器进行清理。类似地，即使每个上下文管理器指示应忽略异常(通过从其exit方法返回True+)，这仍将允许引发异常。|744167|entityMap^0|1M|7|0|0|0|0|G|A|2T|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

Sure, why not, Here's a recipe that should do it. Create a context manager 'pool' that can enter an arbitrary number of contexts (by calling it's <code>enter()</code> method) and they will be cleaned up at the end of the end of the suite.

<pre><code>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
</code></pre>

For example:

<pre><code>&gt;&gt;&gt; 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)
... 
&gt;&gt;&gt; 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__(&lt;type 'exceptions.ZeroDivisionError'&gt;, ZeroDivisionError('integer division or modulo by zero',), &lt;traceback object at 0x02958648&gt;)
called StubContextManager('foo').__exit__(&lt;type 'exceptions.ZeroDivisionError'&gt;, ZeroDivisionError('integer division or modulo by zero',), &lt;traceback object at 0x02958648&gt;)

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

Caveats: context managers aren't supposed to raise exceptions in their <code>__exit__()</code> methods, but if they do, this recipe doesn't do the cleanup for all the context managers. Similarly, even if every context manager indicates that an exception should be ignored (by returning <code>True</code> from their exit methods), this will still allow the exception to be raised.

blocks|key|527688|text|谢谢你的回答。从你们所有人那里得到灵感，我想出了以下几点。我认为(希望)它能像我预期的那样工作。我不确定是将它作为答案还是添加到问题中，但我认为答案更合适，因为如果它没有完成我要求的事情，可以适当地进行评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527689|例如，它可以像这样使用。|527690|with+contextlist(+[open,+f,+'rb']+for+f+in+files+)+as+fs:
++++....|code-block|syntax|javascript|527691|或者像这样..。|527692|f_lock+=+threading.Lock()
with+contextlist(+f_lock,+([open,+f,+'rb']+for+f+in+files)+)+as+(lock,+*fs):
++++....|527693|这就是，|527694|import+inspect
import+collections
import+traceback

class+contextlist:

++++def+__init__(self,+*contexts):

++++++++self._args+=+[]

++++++++for+ctx+in+contexts:
++++++++++++if+inspect.isgenerator(ctx):
++++++++++++++++self._args+%2B=+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%2B(''.join(e)).replace('\n','\n>+++'))|527695|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Thanks for all your answers. Taking inspiration from all of you, I have come up with the following. I think (hope) it works as I intended. I wasn't sure whether to post it as an answer or an addition to the question, but thought an answer was more appropriate as then if it fails to do what I'd asked it can be commented on appropriately.

It can be used for example like this ..

<pre><code>with contextlist( [open, f, 'rb'] for f in files ) as fs:
 ....
</code></pre>

or like this ..

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

And here it is,

<pre><code>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&gt; '*2+(''.join(e)).replace('\n','\n&gt; '))
</code></pre>

blocks|key|527755|text|contextlib模块中的类ExitStack提供了您想要的功能。文档中提到的规范用例是管理动态数量的文件。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527756|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|code-block|syntax|javascript|527757|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/contextlib.html#module-contextlib|1|https://docs.python.org/3/library/contextlib.html#contextlib.ExitStack^0|0|A|F|9|0|A|0|F|9|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

The class <a href="https://docs.python.org/3/library/contextlib.html#contextlib.ExitStack" rel="nofollow noreferrer"><code>ExitStack</code></a> from the <a href="https://docs.python.org/3/library/contextlib.html#module-contextlib" rel="nofollow noreferrer"><code>contextlib</code></a> module provides the functionality you are looking for.
The canonical use-case that is mentioned in the documentation is managing a dynamic number of files.

<pre><code>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
</code></pre>

I am aware that I can open multiple files with something like,

<pre><code>with open('a', 'rb') as a, open('b', 'rb') as b:
</code></pre>

But I have a situation where I have a list of files to open and am wondering what the preferred method is of doing the same when the number of files is unknown in advance. Something like,

<pre><code>with [ open(f, 'rb') for f in files ] as fs:
</code></pre>

(but this fails with an <code>AttributeError</code> since list doesn't implement <code>__exit__</code>)

I don't mind using something like,

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

 ....

finally:
 for f in fs:
 f.close()
</code></pre>

But am not sure what will happen if some files throw when trying to open them. Will <code>fs</code> be properly defined, with the files that did manage to open, in the <code>finally</code> block?

Opening multiple (an unspecified number) of files at once and ensuring they are correctly closed

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我知道我可以打开多个文件，比如，with open('a', 'rb') as a, open('b', 'rb') as b:但是我有一种情况，我有一个要打开的文件列表，并且想知道在预先不知道文件数量的情况下执行相同操作的首选方法是什么。像这样，with [ open(f, 'rb') for f in files ...

问一次打开多个(数量不详)文件，并确保正确关闭
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一次打开多个(数量不详)文件，并确保正确关闭EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一次打开多个(数量不详)文件，并确保正确关闭
EN