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:
0
if the interpreter exits normally (i.e., without an exception),1
if the interpreter exits due to an exception, or2
if the parameter list does not represent a valid Python command line.Note that if an otherwise unhandled
SystemExit
is raised, this function will not return1
, but exit the process, as long asPy_InspectFlag
is 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