CODEWITHSUNDEEP
pythonpep8try-except
mcy
mcy

Reputation: 200

Where to put exception handling in python

When using try/except blocks in Python, is there a recommendation to delegate it to any methods that might raise an exception, or to catch it in the parent function, or both?

For example, which of the following is preferred?

def my_function():
    s = something.that.might.go_wrong()
    return s

def main():
    try:
        s = my_function()
    except Exception:
        print "Error"

or

def my_function():
    try:
        s = something.that.might.go_wrong()
        return s
    except Exception:
        print "Error"

def main():
    s = my_function()

PEP 8 seems to be quiet on the matter, and I seem to find examples of both cases everywhere.

Upvotes: 9

Views: 2508

Answers (3)

AlokThakur
AlokThakur

Reputation: 3741

If you are following the rule of "one function should handle one task" then You shouldn't handle exception in that function, Let it fail loudly on unexpected input. Parent function which calling such function may handle to give better experience to user.

We can refer python builtin functions to get pythonic way

Upvotes: 3

SloppyJoe
SloppyJoe

Reputation: 403

I always use the second one. Logically to me it seems that the problems of a function should be dealt with in that function only. This would provide user a clean and a hassle free interface, so you could later put your code in a library.

There could be some cases where you would want to use exceptions outside the function. For example if you want to print a particular message when something goes wrong then you should use the exception out of the function.

However you could provide the exception statements as a argument to the function if you want to give user the ability to decide his own exception message. So i guess the Second example(exception inside the function) would be universal and thus should be preferred.

Upvotes: 1

Amber
Amber

Reputation: 526573

It really depends on the semantics of the functions in question. In general if you're writing a library, your library probably should handle exceptions that get raised inside the library (optionally re-raising them as new library-specific exceptions).

At the individual function level, though, the main thing you want to think about is what context/scope you desire to handle the exception in - if there is a reasonable different thing you could do in exceptional cases within the inner function, it might be useful to handle it within the inner function; otherwise, it might make more sense to handle it in the outer function.

For the specific case of writing output, it's often useful to only do that at the highest level, and inner functions only ever (a) return values or (b) raise exceptions. That makes the code easier to test because you don't have to worry about testing side effect output.

Upvotes: 7

Related Questions