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

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.

Answer 2

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 3

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

Answer 4

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()

(Note that raw_input() has been replaced by input() in Python 3)

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 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

In windows instead of double clicking the py file you can drag it into an already open CMD window, and then hit enter. It stays open after an exception.

Dan

Answer 7

Take a look at answer of this question: How to find exit code or reason when atexit callback is called in Python?

You can just copy this ExitHooks class, then customize your own foo function then register it to atexit.

import atexit
import sys, os

class ExitHooks(object):
    def __init__(self):
        self.exit_code = None
        self.exception = None

    def hook(self):
        self._orig_exit = sys.exit
        sys.exit = self.exit
        sys.excepthook = self.exc_handler

    def exit(self, code=0):
        self.exit_code = code
        self._orig_exit(code)

    def exc_handler(self, exc_type, exc, *args):
        self.exception = exc

hooks = ExitHooks()
hooks.hook()

def goodbye():
    if not (hooks.exit_code is None and hooks.exception is None):
        os.system('pause')
#       input("\nPress Enter key to exit.")

atexit.register(goodbye)

Answer 8

if you are using windows you could do this

    import os

    #code here 

    os.system('pause')

Answer 9

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.