Stop python from closing on error

Question

In python when running scripts is there a way to stop the console window from closing after spitting out the traceback?

Answer 1

Your question is not very clear, but I assume that the python interpreter exits (and therefore the calling console window closes) when an exception happens.

You need to modify your python application to catch the exception and print it without exiting the interpreter. One way to do that is to print "press ENTER to exit" and then read some input from the console window, effectively waiting for the user to press Enter.

Answer 2

try:
    #do some stuff
    1/0 #stuff that generated the exception
except Exception as ex:
    print ex
    raw_input()

Answer 3

You could have a second script, which imports/runs your main code. This script would catch all exceptions, and print a traceback (then wait for user input before ending)

Assuming your code is structured using the if __name__ == "__main__": main() idiom..

def myfunction():
    pass

class Myclass():
    pass

def main():
    c = Myclass()
    myfunction(c)

if __name__ == "__main__":
    main()

..and the file is named "myscriptname.py" (obviously that can be changed), the following will work

from myscriptname import main as myscript_main

try:
    myscript_main()
except Exception, errormsg:
    print "Script errored!"
    print "Error message: %s" % errormsg
    print "Traceback:"
    import traceback
    traceback.print_exc()
    print "Press return to exit.."
    raw_input()

If you don't have a main() function, you would use put the import statement in the try: block:

try:
    import myscriptname
except [...]

A better solution, one that requires no extra wrapper-scripts, is to run the script either from IDLE, or the command line..

On Windows, go to Start > Run, enter cmd and enter. Then enter something like..

cd "\Path\To Your\ Script\"
\Python\bin\python.exe myscriptname.py

(If you installed Python into C:\Python\)

On Linux/Mac OS X it's a bit easier, you just run cd /home/your/script/ then python myscriptname.py

The easiest way would be to use IDLE, launch IDLE, open the script and click the run button (F5 or Ctrl+F5 I think). When the script exits, the window will not close automatically, so you can see any errors

Also, as Chris Thornhill suggested, on Windows, you can create a shortcut to your script, and in it's Properties prefix the target with..

C:\WINDOWS\system32\cmd.exe /K [existing command]

From http://www.computerhope.com/cmd.htm:

/K command - Executes the specified command and continues running.

Answer 4

If you doing this on a Windows OS, you can prefix the target of your shortcut with:

C:\WINDOWS\system32\cmd.exe /K <command>

This will prevent the window from closing when the command exits.

Answer 5

On UNIX systems (Windows has already been covered above...) you can change the interpreter argument to include the -i flag:

#!/usr/bin/python -i

From the man page:

-i

When a script is passed as first argument or the -c option is used, enter interactive mode after executing the script or the command. It does not read the $PYTHONSTARTUP file. This can be useful to inspect global variables or a stack trace when a script raises an exception.

Answer 6

You can register a top-level exception handler that keeps the application alive when an unhandled exception occurs:

def show_exception_and_exit(exc_type, exc_value, tb):
    import traceback
    traceback.print_exception(exc_type, exc_value, tb)
    raw_input("Press key to exit.")
    sys.exit(-1)

 import sys
 sys.excepthook = show_exception_and_exit

This is especially useful if you have exceptions occuring inside event handlers that are called from C code, which often do not propagate the errors.