Python: return a default value if function or expression fails

Question

Does Python has a feature that allows one to evaluate a function or expression and if the evaluation fails (an exception is raised) return a default value.

Pseudo-code: evaluator(function/expression, default_value)

The evaluator will try to execute the function or expression and return the result is the execution is successful, otherwise the default_value is returned.

I know I create a user defined function using try and except to achieve this but I want to know if the batteries are already included before going off and creating a custom solution.

Answer 1

In order to reuse code, you can create a decorating function (that accepts a default value) and decorate your functions with it:

def handle_exceptions(default):
    def wrap(f):
        def inner(*a):
            try:
                return f(*a)
            except Exception, e:
                return default
        return inner
    return wrap

Now let's see an example:

@handle_exceptions("Invalid Argument")
def test(num):
    return 15/num

@handle_exceptions("Input should be Strings only!")
def test2(s1, s2):
    return s2 in s1    

print test(0) # "Invalid Argument"
print test(15) # 1

print test2("abc", "b") # True
print test2("abc", 1) # Input should be Strings only!

Answer 2

No, the standard way to do this is with try... except.

There is no mechanism to hide or suppress any generic exception within a function. I suspect many Python users would consider indiscriminate use of such a function to be un-Pythonic for a couple reasons:

1. It hides information about what particular exception occurred. (You might not want to handle all exceptions, since some could come from other libraries and indicate conditions that your program can't recover from, like running out of disk space.)

2. It hides the fact that an exception occurred at all; the default value returned in case of an exception might coincide with a valid non-default value. (Sometimes reasonable, sometimes not really so.)

One of the principles of the Pythonic philosophy, I believe, is that "explicit is better than implicit," so Python generally avoids automatic type casting and error recovery, which are features of more "implicit- friendly"languages like Perl.

Although the try... except form can be a bit verbose, in my opinion it has a lot of advantages in terms of clearly showing where an exception may occur and what the control flow is around that exception.