Assuming your script doesn't exit due to any kind of failure (exception, syntax error) and the script doesn't exit due to sys.exit() or os._exit(), how does Python figure out what exit code to exit with?
It seems to be 0, which makes sense since it indicates no-error on *nix systems. However, will that always be the case that it exits with 0 (except for the cases above)? Surprisingly after quite a bit of online searching, I couldn't find anything which explicitly said that it would exit with 0 unless otherwise specified.
Python has only two standard codes, i.e., a one and a zero. The exit code of 0 means that the process has been executed and exited successfully. This means no error was encountered. On the other hand, an error code of 1 indicates that the process exited with a failure.
255: Exit code out of range.
exit(0) means a clean exit without any errors / problems. exit(1) means there was some issue / error / problem and that is why the program is exiting. This is not Python specific and is pretty common. A non-zero exit code is treated as an abnormal exit, and at times, the error code indicates what the problem was.
The script was killed by the operating system.
sys.exit documents a default exit status of 0, and os._exit's docs specify a UNIX-like OS constant for "normal" exit status, os.EX_OK, but there is no documented guarantee I can find for the exit status in general.
Aside from that, the best I can give you is that in CPython, the python executable (including python.exe/pythonw.exe on Windows) is implemented in python.c by calling Py_Main and returning whatever it returns; per the documented guarantees on Py_Main, the exit status is:
0if the interpreter exits normally (i.e., without an exception),1if the interpreter exits due to an exception, or2if the parameter list does not represent a valid Python command line.Note that if an otherwise unhandled
SystemExitis raised, this function will not return1, but exit the process, as long asPy_InspectFlagis not set.
so this implies that simply running off the end of the __main__ module without an active exception should always return 0 for CPython, though alternate interpreters are not technically required to do the same.
This tracks with the implied exit status rules expected of most applications; while nothing explicitly says Python has to follow those rules, it would be extremely unusual for a tool that grew up in the command line UNIX-like world to violate those conventions.
If you look at the cpython source code:
main() in Programs/python.c returns the return value of Py_Main() Py_Main() in Modules/main.c returns the return value of run_file()
run_file(), also in Modules/main.c returns 0 unless PyRun_AnyFileExFlags() returns non-zeroPyRun_AnyFileExFlags() in Python/pythonrun.c will exit() in
the event of a SystemExit exception and so will not return if the
script sets an exit code. It will only return non-zero if there
is an internal error.So the return value of run_file() is what makes the default exit code of a script 0.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With