How to exit from Python without traceback?

Perhaps you're trying to catch all exceptions and this is catching the SystemExit exception raised by sys.exit()?

import sys

try:
    sys.exit(1) # Or something that calls sys.exit()
except SystemExit as e:
    sys.exit(e)
except:
    # Cleanup and reraise. This will print a backtrace.
    # (Insert your cleanup code here.)
    raise

In general, using except: without naming an exception is a bad idea. You'll catch all kinds of stuff you don't want to catch -- like SystemExit -- and it can also mask your own programming errors. My example above is silly, unless you're doing something in terms of cleanup. You could replace it with:

import sys
sys.exit(1) # Or something that calls sys.exit().

If you need to exit without raising SystemExit:

import os
os._exit(1)

I do this, in code that runs under unittest and calls fork(). Unittest gets when the forked process raises SystemExit. This is definitely a corner case!

import sys
sys.exit(1)

The following code will not raise an exception and will exit without a traceback:

import os
os._exit(1)

See this question and related answers for more details. Surprised why all other answers are so overcomplicated.

This also will not do proper cleanup, like calling cleanup handlers, flushing stdio buffers, etc. (thanks to pabouk for pointing this out)

something like import sys; sys.exit(0) ?

It's much better practise to avoid using sys.exit() and instead raise/handle exceptions to allow the program to finish cleanly. If you want to turn off traceback, simply use:

sys.tracebacklimit = 0

You can set this at the top of your script to squash all traceback output, but I prefer to use it more sparingly, for example "known errors" where I want the output to be clean, e.g. in the file foo.py:

import sys
from subprocess import *

try:
    check_call([ 'uptime', '--help' ])
except CalledProcessError:
    sys.tracebacklimit = 0
    print "Process failed"
    raise

print "This message should never follow an error."

If CalledProcessError is caught, the output will look like this:

[me@test01 dev]$ ./foo.py
usage: uptime [-V]
    -V    display version
Process failed
subprocess.CalledProcessError: Command '['uptime', '--help']' returned non-zero exit status 1

If any other error occurs, we still get the full traceback output.

Use the built-in python function quit() and that's it. No need to import any library. I'm using python 3.4

I would do it this way:

import sys

def do_my_stuff():
    pass

if __name__ == "__main__":
    try:
        do_my_stuff()
    except SystemExit, e:
        print(e)

import atexit
import inspect
import os
import signal
import sys


def sigint_handler(signal, frame):
    sys.stderr.write('\nInterrupted')
    cleanup(0)


def _cleanup(attr, method, args):
    code = 0
    if hasattr(attr, method):
        try:
            getattr(attr, method)(*args)
        except Exception as exc:
            sys.stderr.write(f"Error cleaning up attribute {repr(attr)}: {exc}")
            code = 1
    return code


def cleanup(code=0):
    for attr in globals().values():
        if not(inspect.isclass(attr) or inspect.isfunction(attr)):
            if not code:
                code |= _cleanup(attr, "__del__", ())
                code |= _cleanup(attr, "__exit__", (None, None, None))
    
    try:
        atexit._run_exitfuncs()
    except Exception as exc:
        sys.stderr.write(f"Error running exit event handlers: {exc}")
        code |= 1
    
    os._exit(code)


signal.signal(signal.SIGINT, sigint_handler)


# -- Maincode down here --

def main():
    pass

# -- Maincode Ends


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        sys.stderr.write('\nInterrupted')
        cleanup(0)

P.S.: The output msgs from the standerd error stream ISN'T A TRACEBACK, but it can be friendly to users

What about

import sys
....
....
....
sys.exit("I am getting the heck out of here!")

No traceback and somehow more explicit.