How to return a value and raise an Exception

Question

I have two objectives with this try/except statement.

1. It needs to return a value of 1 if no problems occurred, or 0 if any problems occurred.
2. It needs to raise an exception and end the script.

I have the return value working. I also have the SystemExit() working. But together, they aren't working.

My Python Script (that's relevant):

except IOError:
    value_to_return = 0
    return value_to_return
    raise SystemExit("FOOBAR")

With this, it ignores the raise SystemExit("FOOBAR") line completely. How do I go about getting a returned value and still raise SystemExit("FOOBAR")? This may be elementary to some, but I'm actually having quite a bit of difficulty with it.

Answer 1

Returning and raising are mutually exclusive.

Raising SystemExit will end the script. A few cleanup routines get to run, and if the caller really, really wants to, they can catch the SystemExit and cancel it, but mostly, you can think of it as stopping execution right there. The caller will never get a chance to see a return value or do anything meaningful with it.

Returning means you want the script to continue. Continuing might mean having the caller raise SystemExit, or it might mean ignoring the error, or it might mean something else. Whatever it means is up to you, as you're the one writing the code.

Finally, are you sure you should be handling this error at all? Catching an exception only to turn it into a system shutdown may not be the most useful behavior. It's not a user-friendly way to deal with problems, and it hides all the useful debugging information you'd get from a stack trace.

Answer 2

You can raise an error with a 'returning_value' argument to be used after the calling.

Another pythonic answer to your problem could be to make use of the error arguments in the raise and then, in your call manage the error to get the value, convert it from string and get your 'return-ish'.

def your_f():
    try:
      some_io_thingy_ok()
      return 1
    except IOError:
        raise SystemExit("FOOBAR", 0)

try:
    my_returning_value = your_f()
except SystemExit as err:
    my_returning_value = err.args[1]


print(my_returning_value)

From Python 3 docs :

When an exception occurs, it may have an associated value, also known as the exception’s argument. The presence and type of the argument depend on the exception type.

The except clause may specify a variable after the exception name. The variable is bound to an exception instance with the arguments stored in instance.args. For convenience, the exception instance defines str() so the arguments can be printed directly without having to reference .args. One may also instantiate an exception first before raising it and add any attributes to it as desired.

Answer 3

To exit a script and return an exit status, use sys.exit():

import sys
sys.exit(value_to_return)

Answer 4

You can't "raise" and "return" in the same time, so you have to add a special variable to the return value (e.g: in tuple) in case of error.

E.g: I have a function (named "func") which counts something and I need the (partial) result even if an exception happened during the counting. In my example I will use KeyboardInterrupt exception (the user pressed CTRL-C).

Without exception handling in the function (it's wrong, in case of any exception the function doesn't give back anything):

def func():
    s=0
    for i in range(10):
        s=s+1
        time.sleep(0.1)
    return s


x=0
try:
    for i in range(10):
       s=func()
       x=x+s
except KeyboardInterrupt:
    print(x)
else:
    print(x)

And now I introduce a boolean return value (in a tuple, next to the original return value) to indicate if an exception happened. Because in the function I handle only the KeyboardInterrupt exception, I can be sure that's happened, so I can raise the same where I called the function:

def func():
    try:
        s=0
        for i in range(10):
            s=s+1
            time.sleep(0.1)
    except KeyboardInterrupt: # <- the trick is here
        return s, True        # <- the trick is here
    return s, False           # <- the trick is here


x=0
try:
    for i in range(10):
        s,e=func()
        x=x+s
        if e:                         # <- and here
            raise KeyboardInterrupt   # <- and here
except KeyboardInterrupt:
    print(x)
else:
    print(x)

Note: my example is python3. The time module is used (in both code above), but I haven't import it just to make it shorter. If you want to really try it, put at the beginning:

import time

Answer 5

i was looking for an answer without using try, use 'finally' keyword like this.. if any one knows fill me in here is an answer for your poblem

try:
    9/0#sample error "don't know how to make IOError"
except ZeroDivisionError:
    value_to_return = 0
    raise SystemExit("FOOBAR")
finally:return value_to_return

Answer 6

I think what you may be looking for is something more like this:

def some_function():
    # this function should probably do some stuff, then return 1 if
    # it was successful or 0 otherwise.
    pass

def calling_function():
    a = some_function()
    if a == 1:
        raise SystemExit('Get the heck outta here!')
    else:
        # Everything worked!
        pass