Stop python from closing on error

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.

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

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.

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. 

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

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) 

if you are using windows you could do this

 import os #code here os.system('pause') 

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.