获取嵌套函数的退出状态？

Question

I have a function called within a different function. In the nested function, various errors (eg improper arguments, missing parameters, etc.) should result in exit status 1. Something like:

if not os.path.isdir(filepath):
    print('Error: could not find source directory...')
    sys.exit(1)

Is this the correct way to use exit statuses within python? Should I have, instead,

return sys.exit(1)

??? Importantly, how would I reference the exit status of this nested function in the other function once the nested function had finished?

Answer 1

sys.exit() raises a SystemExit exception . Normally, you should not use it unless you really mean to exit your program.

You could catch this exception:

try:
    function_that_uses_sys.exit()
except SystemExit as exc:
    print exc.code

The .code attribute of the SystemExit exception is set to the proposed exit code.

However, you should really use a more specific exception, or create a custom exception for the job. A ValueError might be appropriate here, for example:

if not os.path.isdir(filepath):
    raise ValueError('Error: could not find source directory {!r}'.format(filepath))

then catch that exception:

try:
    function_that_may_raise_valueerror()
except ValueError as exc:
    print "Oops, something went wrong: {}".format(exc.message)

Answer 2

By using sys.exit , you typically signal that you want the entire program to end. If you want to handle the error in a calling function, you should probably have the inner function raise a more specific exception instead. (You could catch the exception raised by SystemExit, but it would be a rather awkward way to pass error information out.)

Answer 3

I guess that the right thing to do is this:

if not os.path.isdir(filepath):
    raise ValueError('the given filepath is not a directory')

However, the code as it stands still could be improved. One point is that a path to a file should never be a directory, so that is not an exceptional state. Maybe what you want is to just name it path without adding an unintended connotations.

Further, and that has actual functional implications, you are still not guaranteed to be able to access a directory there even if isdir() returns true! The reason is that something could have switched the thing under your feet, typically a malicious attacker, or, more simple, you could simply not have the rights to access it. If you care, you should rather just open the directory and handle the according errors instead of trying in advance to determine if something in the future will fail. This is in general a better approach, as the "normal" code doesn't get cluttered by such checks and you also don't pay any albeit small performance penalty except when an error occurs.