CODEWITHSUNDEEP
python
q0987
q0987

Reputation: 35982

Handling Exceptions with else clause

The Python Tutorial states:

The try ... except statement has an optional else clause, which, when present, must follow all except clauses. It is useful for code that must be executed if the try clause does not raise an exception. For example:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print 'cannot open', arg
    else:
        print arg, 'has', len(f.readlines()), 'lines'
        f.close()

The use of the else clause is better than adding additional code to the try clause because it avoids accidentally catching an exception that wasn’t raised by the code being protected by the try ... except statement.

Question 1>　Ａｆｔｅｒ reading the above document, I still don't get the idea why we cannot simply move the code from else clause into try clause.

Question 2> How does try clause can accidentally catch an exception since all those catches are done in the except clause, right?

Upvotes: 1

Views: 294

Answers (4)

kindall
kindall

Reputation: 184200

You could put the else code in the try suite, but then you'd catch any exceptions that might be raised there. If you didn't intend that to happen, it would be "accidental," hence the wording of the document you linked to.

Best practice is to put as little code as possible in a try block, so that when an error occurs, you know what operation caused it and can handle it appropriately. If you have five lines of code in a try block and only expect one of them to ever raise an exception, your exception-handling code will be ill-prepared when an exception occurs in a line you didn't expect it to. Better in that case to let the exception be raised than handle it the wrong way.

Upvotes: 6

Alex Leach
Alex Leach

Reputation: 1201

1) Of course you could just move code from the else clause into the try clause. You could move it outside of the try block entirely, but this allows extra flexibility, and further modulation of the code. Also, perhaps specificity with the errors being caught. You could list a whole load of different exceptions that might be likely to happen, each with different statements. The stuff in the else clause would still only happen if no exception was raised, after the execution of the final line in the try block. e.g. printing a successful return message. Also, try clauses add some extra CPU overhead with regards to garbage collection management and error tracing, so anything outside of the try clause is not protected in the same manner and may run more efficiently.

2) Error catching is quite specific. e.g. The except clause in your above example will only be run if an IOError is raised when running the f = open(arg,'r') line. If you want to catch any form of exception, use except Exception:.

Upvotes: 1

Jim Dennis
Jim Dennis

Reputation: 17510

If you move the code from the else into the try then that becomes part of the "critical path" which can raise an exception. If f.readlines() raises some sort of exception (perhaps an I/O error while reading the file because of a bad sector on the disk) then that error will be conflated with the one error that you currently catch. (Technically the "cannot open" error message would be wrong at that point ... because opening a file can succeed when reading it later fails; in fact opening it must succeed before you can even get an I/O error while processing it).

Normally you'd use a pattern more like:

foo = None
try:
    # some code to access/load/initialize foo from an external source
except ...:
    # handle various types of file open/read, database access, etc errors
else:
    foo = something

... so that your subsequently run code and simply check if foo is None and use it or work around it's unavailability in whatever way you see fit.

Upvotes: 3

joaquin
joaquin

Reputation: 85603

Answer for both questions is similar,

If you move code to the try clause, then you can not be sure from where the exception is coming from. Thus if you have another line of code that produces an unexpected IOError you could end searching for a problem where there is not.

So to better disect your code you want to simplify as much as possible the lines in the try making the catch as especific as possible.

Upvotes: 2

Related Questions