Is this the right way to use the python "with" statement in combination with a try-except block?:
try: with open("file", "r") as f: line = f.readline() except IOError: <whatever>
If it is, then considering the old way of doing things:
try: f = open("file", "r") line = f.readline() except IOError: <whatever> finally: f.close()
Is the primary benefit of the "with" statement here that we can get rid of three lines of code? It doesn't seem that compelling to me for this use case (though I understand that the "with" statement has other uses).
EDIT: Is the functionality of the above two blocks of code identical?
EDIT2: The first few answers talk generally about the benefits of using "with", but those seem of marginal benefit here. We've all been (or should have been) explicitly calling f.close() for years. I suppose one benefit is that sloppy coders will benefit from using "with".
fis not bound.
The equivalent old style code would be:
try: f = open("file", "r") try: line = f.readline() finally: f.close() except IOError: <whatever>
As you can see, the
with statement can make things less error prone. In newer versions of Python (2.7, 3.1), you can also combine multiple expressions in one
with statement. For example:
with open("input", "r") as inp, open("output", "w") as out: out.write(inp.read())
Besides that, I personally regard it as bad habit to catch any exception as early as possible. This is not the purpose of exceptions. If the IO function that can fail is part of a more complicated operation, in most cases the IOError should abort the whole operation and so be handled at an outer level. Using
with statements, you can get rid of all these
try...finally statements at inner levels.
除此之外，我个人认为尽早捕捉任何例外都是不好的习惯。这不是例外的目的。如果可能失败的IO功能是更复杂操作的一部分，则在大多数情况下，IOError应该中止整个操作，因此应在外层处理。使用with语句，你可以在内层删除所有这些try ... finally语句。
If the contents of the
finally block are determined by the properties of the file object being opened, why shouldn't the implementer of the file object be the one to write the
finally block? That's the benefit of the
with statement, much more than saving you three lines of code in this particular instance.
And yes, the way you've combined
try-except is pretty much the only way to do it, as exceptional errors caused within the
open statement itself can't be caught within the
I think you got it wrong about "with" statement that it only reduces lines. It actually does initialization and handle teardown.
In your case "with" does
Here is link for understanding "with" statement : http://effbot.org/zone/python-with-statement.htm
Edit: Yes your usage of "with" is correct and functionality of both blocks of code is identical. Question about why to use "with" ? it's because of benefits you get with it. like you mentioned about accidentally missing f.close().
The more Pythonic way for the following codes is:
try: f = open("file", "r") try: line = f.readline() finally: f.close() except IOError: <whatever> try: f = open("file", "r") except IOError: <whatever> else: f.close()