Python | os.abort () method

abort | Python Methods and Functions

os.abort() in Python is used to generate a SIGABRT signal for the current process. On Unix, this method dumps the kernel, while on Windows, the process immediately returns an exit code 3.
This method does not call the Python signal handler registered for the SIGABRT signal with signal.signal ().

Syntax: os.abort ()

Parameter: No parameter is required.

Return type: This method does not return any value in the calling process.

Code # 1: Using the os.abort ()

# Python program to explain the os.abort () method

# import of the os module

import os



print ( "Hello! Geeks " )

# os.abort () method
# will generate & # 39; SIGABRT & # 39;
# signal for current process
# Unix core dump
# will be done
# On windows the process
# will exit with exit code 3
os.abort ()

# How the process was interrupted
# line after os.abort () statement
# will not be executed.

print ( "This will not be printed" )


 Hello! Geeks Aborted (core dumped) 

Code # 2: Using method os.abort()

# Python program to explain the os.abort () method

# import of the os module

import os, signal

# Create a child process
# using the os.fork () method

pid = os.fork ()


# pid greater than 0
# indicates the parent process

if pid & gt;  0 :

# Parent process

print ( "In Parent process" )


# Wait for completion

# child process and get

# its pid and exit status indication

# using the os.wait () method

info = os.wait ()


sig = os.WTERMSIG (info [ 1 ]) 

print ( " Child exited due to signal no: " , sig)

  print ( "Signal name:" , signal .Signals (sig) .name)


else :


  # child process

print ( "In child process" )

print ( "Process ID:" , os.getpid ())

print ( "Hello! Geeks " )


Terminate child process

# by generating a SIGABRT signal

  # using the os.abort () method

os.abort ()

Exit :

 In child process Process ID: 13914 Hello! Geeks In Parent process Child stopped due to signal no : 6 Signal name: SIGABRT 


Python | os.abort () method: StackOverflow Questions

DatabaseError: current transaction is aborted, commands ignored until end of transaction block?

I got a lot of errors with the message :

"DatabaseError: current transaction is aborted, commands ignored until end of transaction block"

after changed from python-psycopg to python-psycopg2 as Django project"s database engine.

The code remains the same, just don"t know where those errors are from.

How do I abort the execution of a Python script?

Question by Ray Vega

I have a simple Python script that I want to stop executing if a condition is met.

For example:

done = True
if done:
    # quit/stop/exit
    # do other stuff

Essentially, I am looking for something that behaves equivalently to the "return" keyword in the body of a function which allows the flow of the code to exit the function and not execute the remaining code.

Answer #1

To summarize and complement the existing answers:

  • python.exe is a console (terminal) application for launching CLI-type scripts (console applications).

    • Unless run from an existing console window, python.exe opens a new console window.

    • Standard streams sys.stdin, sys.stdout and sys.stderr are connected to the console window.

    • Execution is synchronous when launched from a cmd.exe or PowerShell console window: See eryksun"s 1st comment below.

      • If a new console window was created, it stays open until the script terminates.
      • When invoked from an existing console window, the prompt is blocked until the script terminates.
  • pythonw.exe is a GUI app for launching GUI/no-UI-at-all scripts.

    • NO console window is opened.
    • Execution is asynchronous:
      • When invoked from a console window, the script is merely launched and the prompt returns right away, whether the script is still running or not.
    • Standard streams sys.stdin, sys.stdout and sys.stderr are NOT available.
      • Caution: Unless you take extra steps, this has potentially unexpected side effects:
        • Unhandled exceptions cause the script to abort silently.
        • In Python 2.x, simply trying to use print() can cause that to happen (in 3.x, print() simply has no effect).
          • To prevent that from within your script, and to learn more, see this answer of mine.
          • Ad-hoc, you can use output redirection:Thanks, @handle.
            pythonw.exe yourScript.pyw 1>stdout.txt 2>stderr.txt
            (from PowerShell:
            cmd /c pythonw.exe yourScript.pyw 1>stdout.txt 2>stderr.txt) to capture stdout and stderr output in files.
            If you"re confident that use of print() is the only reason your script fails silently with pythonw.exe, and you"re not interested in stdout output, use @handle"s command from the comments:
            pythonw.exe yourScript.pyw 1>NUL 2>&1
            Caveat: This output redirection technique does not work when invoking *.pyw scripts directly (as opposed to by passing the script file path to pythonw.exe). See eryksun"s 2nd comment and its follow-ups below.

You can control which of the executables runs your script by default - such as when opened from Explorer - by choosing the right filename extension:

  • *.py files are by default associated (invoked) with python.exe
  • *.pyw files are by default associated (invoked) with pythonw.exe

Answer #2

What is the reason for the try-except-else to exist?

A try block allows you to handle an expected error. The except block should only catch exceptions you are prepared to handle. If you handle an unexpected error, your code may do the wrong thing and hide bugs.

An else clause will execute if there were no errors, and by not executing that code in the try block, you avoid catching an unexpected error. Again, catching an unexpected error can hide bugs.


For example:

except SomeException as the_exception:
    return something

The "try, except" suite has two optional clauses, else and finally. So it"s actually try-except-else-finally.

else will evaluate only if there is no exception from the try block. It allows us to simplify the more complicated code below:

no_error = None
    no_error = True
except SomeException as the_exception:
if no_error:
    return something

so if we compare an else to the alternative (which might create bugs) we see that it reduces the lines of code and we can have a more readable, maintainable, and less buggy code-base.


finally will execute no matter what, even if another line is being evaluated with a return statement.

Broken down with pseudo-code

It might help to break this down, in the smallest possible form that demonstrates all features, with comments. Assume this syntactically correct (but not runnable unless the names are defined) pseudo-code is in a function.

For example:

except SomeException as the_exception:
    # Handle a instance of SomeException or a subclass of it.
except Exception as the_exception:
    # Handle any other exception that inherits from Exception
    # - doesn"t include GeneratorExit, KeyboardInterrupt, SystemExit
    # Avoid bare `except:`
else: # there was no exception whatsoever
    return something()
    # if no exception, the "something()" gets evaluated,
    # but the return will not be executed due to the return in the
    # finally block below.
    # this block will execute no matter what, even if no exception,
    # after "something" is eval"d but before that value is returned
    # but even if there is an exception.
    # a return here will hijack the return functionality. e.g.:
    return True # hijacks the return in the else clause above

It is true that we could include the code in the else block in the try block instead, where it would run if there were no exceptions, but what if that code itself raises an exception of the kind we"re catching? Leaving it in the try block would hide that bug.

We want to minimize lines of code in the try block to avoid catching exceptions we did not expect, under the principle that if our code fails, we want it to fail loudly. This is a best practice.

It is my understanding that exceptions are not errors

In Python, most exceptions are errors.

We can view the exception hierarchy by using pydoc. For example, in Python 2:

$ python -m pydoc exceptions

or Python 3:

$ python -m pydoc builtins

Will give us the hierarchy. We can see that most kinds of Exception are errors, although Python uses some of them for things like ending for loops (StopIteration). This is Python 3"s hierarchy:


A commenter asked:

Say you have a method which pings an external API and you want to handle the exception at a class outside the API wrapper, do you simply return e from the method under the except clause where e is the exception object?

No, you don"t return the exception, just reraise it with a bare raise to preserve the stacktrace.

except SomeException as the_exception:

Or, in Python 3, you can raise a new exception and preserve the backtrace with exception chaining:

except SomeException as the_exception:
    raise DifferentException from the_exception

I elaborate in my answer here.

Answer #3

You can update your python version to 3.8 in conda using the command

conda install -c anaconda python=3.8

as per Though not all packages support 3.8 yet, running

conda update --all

may resolve some dependency failures. You can also create a new environment called py38 using this command

conda create -n py38 python=3.8

Edit - note that the conda install option will potentially take a while to solve the environment, and if you try to abort this midway through you will lose your Python installation (usually this means it will resort to non-conda pre-installed system Python installation).

Answer #4

You can use simple trick which is import flask app variable from main inside another file, like:

from __main__ import app

@app.route("/test", methods=["GET"])
def test():
    return "it works!"

and in your main files, where you declared flask app, import test-routes, like:

from flask import Flask, request, abort

app = Flask(__name__)

# import declared routes
import test_routes

It works from my side.

Answer #5

Have a look at the Requests exception docs. In short:

In the event of a network problem (e.g. DNS failure, refused connection, etc), Requests will raise a ConnectionError exception.

In the event of the rare invalid HTTP response, Requests will raise an HTTPError exception.

If a request times out, a Timeout exception is raised.

If a request exceeds the configured number of maximum redirections, a TooManyRedirects exception is raised.

All exceptions that Requests explicitly raises inherit from requests.exceptions.RequestException.

To answer your question, what you show will not cover all of your bases. You"ll only catch connection-related errors, not ones that time out.

What to do when you catch the exception is really up to the design of your script/program. Is it acceptable to exit? Can you go on and try again? If the error is catastrophic and you can"t go on, then yes, you may abort your program by raising SystemExit (a nice way to both print an error and call sys.exit).

You can either catch the base-class exception, which will handle all cases:

    r = requests.get(url, params={"s": thing})
except requests.exceptions.RequestException as e:  # This is the correct syntax
    raise SystemExit(e)

Or you can catch them separately and do different things.

    r = requests.get(url, params={"s": thing})
except requests.exceptions.Timeout:
    # Maybe set up for a retry, or continue in a retry loop
except requests.exceptions.TooManyRedirects:
    # Tell the user their URL was bad and try a different one
except requests.exceptions.RequestException as e:
    # catastrophic error. bail.
    raise SystemExit(e)

As Christian pointed out:

If you want http errors (e.g. 401 Unauthorized) to raise exceptions, you can call Response.raise_for_status. That will raise an HTTPError, if the response was an http error.

An example:

    r = requests.get("")
except requests.exceptions.HTTPError as err:
    raise SystemExit(err)

Will print:

404 Client Error: Not Found for url:

Answer #6

A Session object is basically an ongoing transaction of changes to a database (update, insert, delete). These operations aren"t persisted to the database until they are committed (if your program aborts for some reason in mid-session transaction, any uncommitted changes within are lost).

The session object registers transaction operations with session.add(), but doesn"t yet communicate them to the database until session.flush() is called.

session.flush() communicates a series of operations to the database (insert, update, delete). The database maintains them as pending operations in a transaction. The changes aren"t persisted permanently to disk, or visible to other transactions until the database receives a COMMIT for the current transaction (which is what session.commit() does).

session.commit() commits (persists) those changes to the database.

flush() is always called as part of a call to commit() (1).

When you use a Session object to query the database, the query will return results both from the database and from the flushed parts of the uncommitted transaction it holds. By default, Session objects autoflush their operations, but this can be disabled.

Hopefully this example will make this clearer:

s = Session()

s.add(Foo("A")) # The Foo("A") object has been added to the session.
                # It has not been committed to the database yet,
                #   but is returned as part of a query.
print 1, s.query(Foo).all()

s2 = Session()
s2.autoflush = False

print 2, s2.query(Foo).all() # The Foo("B") object is *not* returned
                             #   as part of this query because it hasn"t
                             #   been flushed yet.
s2.flush()                   # Now, Foo("B") is in the same state as
                             #   Foo("A") was above.
print 3, s2.query(Foo).all() 
s2.rollback()                # Foo("B") has not been committed, and rolling
                             #   back the session"s transaction removes it
                             #   from the session.
print 4, s2.query(Foo).all()

1 [<Foo("A")>]
2 [<Foo("A")>]
3 [<Foo("A")>, <Foo("B")>]
4 [<Foo("A")>]

Answer #7

As you correctly guessed, there are two sides to it: Catching any error by specifying no exception type after except, and simply passing it without taking any action.

My explanation is “a bit” longer—so tl;dr it breaks down to this:

  1. Don’t catch any error. Always specify which exceptions you are prepared to recover from and only catch those.
  2. Try to avoid passing in except blocks. Unless explicitly desired, this is usually not a good sign.

But let’s go into detail:

Don’t catch any error

When using a try block, you usually do this because you know that there is a chance of an exception being thrown. As such, you also already have an approximate idea of what can break and what exception can be thrown. In such cases, you catch an exception because you can positively recover from it. That means that you are prepared for the exception and have some alternative plan which you will follow in case of that exception.

For example, when you ask for the user to input a number, you can convert the input using int() which might raise a ValueError. You can easily recover that by simply asking the user to try it again, so catching the ValueError and prompting the user again would be an appropriate plan. A different example would be if you want to read some configuration from a file, and that file happens to not exist. Because it is a configuration file, you might have some default configuration as a fallback, so the file is not exactly necessary. So catching a FileNotFoundError and simply applying the default configuration would be a good plan here. Now in both these cases, we have a very specific exception we expect and have an equally specific plan to recover from it. As such, in each case, we explicitly only except that certain exception.

However, if we were to catch everything, then—in addition to those exceptions we are prepared to recover from—there is also a chance that we get exceptions that we didn’t expect, and which we indeed cannot recover from; or shouldn’t recover from.

Let’s take the configuration file example from above. In case of a missing file, we just applied our default configuration, and might decided at a later point to automatically save the configuration (so next time, the file exists). Now imagine we get a IsADirectoryError, or a PermissionError instead. In such cases, we probably do not want to continue; we could still apply our default configuration, but we later won’t be able to save the file. And it’s likely that the user meant to have a custom configuration too, so using the default values is likely not desired. So we would want to tell the user about it immediately, and probably abort the program execution too. But that’s not something we want to do somewhere deep within some small code part; this is something of application-level importance, so it should be handled at the top—so let the exception bubble up.

Another simple example is also mentioned in the Python 2 idioms document. Here, a simple typo exists in the code which causes it to break. Because we are catching every exception, we also catch NameErrors and SyntaxErrors. Both are mistakes that happen to us all while programming; and both are mistakes we absolutely don’t want to include when shipping the code. But because we also caught those, we won’t even know that they occurred there and lose any help to debug it correctly.

But there are also more dangerous exceptions which we are unlikely prepared for. For example SystemError is usually something that happens rarely and which we cannot really plan for; it means there is something more complicated going on, something that likely prevents us from continuing the current task.

In any case, it’s very unlikely that you are prepared for everything in a small scale part of the code, so that’s really where you should only catch those exceptions you are prepared for. Some people suggest to at least catch Exception as it won’t include things like SystemExit and KeyboardInterrupt which by design are to terminate your application, but I would argue that this is still far too unspecific. There is only one place where I personally accept catching Exception or just any exception, and that is in a single global application-level exception handler which has the single purpose to log any exception we were not prepared for. That way, we can still retain as much information about unexpected exceptions, which we then can use to extend our code to handle those explicitly (if we can recover from them) or—in case of a bug—to create test cases to make sure it won’t happen again. But of course, that only works if we only ever caught those exceptions we were already expecting, so the ones we didn’t expect will naturally bubble up.

Try to avoid passing in except blocks

When explicitly catching a small selection of specific exceptions, there are many situations in which we will be fine by simply doing nothing. In such cases, just having except SomeSpecificException: pass is just fine. Most of the time though, this is not the case as we likely need some code related to the recovery process (as mentioned above). This can be for example something that retries the action again, or to set up a default value instead.

If that’s not the case though, for example because our code is already structured to repeat until it succeeds, then just passing is good enough. Taking our example from above, we might want to ask the user to enter a number. Because we know that users like to not do what we ask them for, we might just put it into a loop in the first place, so it could look like this:

def askForNumber ():
    while True:
            return int(input("Please enter a number: "))
        except ValueError:

Because we keep trying until no exception is thrown, we don’t need to do anything special in the except block, so this is fine. But of course, one might argue that we at least want to show the user some error message to tell him why he has to repeat the input.

In many other cases though, just passing in an except is a sign that we weren’t really prepared for the exception we are catching. Unless those exceptions are simple (like ValueError or TypeError), and the reason why we can pass is obvious, try to avoid just passing. If there’s really nothing to do (and you are absolutely sure about it), then consider adding a comment why that’s the case; otherwise, expand the except block to actually include some recovery code.

except: pass

The worst offender though is the combination of both. This means that we are willingly catching any error although we are absolutely not prepared for it and we also don’t do anything about it. You at least want to log the error and also likely reraise it to still terminate the application (it’s unlikely you can continue like normal after a MemoryError). Just passing though will not only keep the application somewhat alive (depending where you catch of course), but also throw away all the information, making it impossible to discover the error—which is especially true if you are not the one discovering it.

So the bottom line is: Catch only exceptions you really expect and are prepared to recover from; all others are likely either mistakes you should fix, or something you are not prepared for anyway. Passing specific exceptions is fine if you really don’t need to do something about them. In all other cases, it’s just a sign of presumption and being lazy. And you definitely want to fix that.

Answer #8

You could use an import and single line code like this:

import ctypes  # An included library with Python install.   
ctypes.windll.user32.MessageBoxW(0, "Your text", "Your title", 1)

Or define a function (Mbox) like so:

import ctypes  # An included library with Python install.
def Mbox(title, text, style):
    return ctypes.windll.user32.MessageBoxW(0, text, title, style)
Mbox("Your title", "Your text", 1)

Note the styles are as follows:

##  Styles:
##  0 : OK
##  1 : OK | Cancel
##  2 : Abort | Retry | Ignore
##  3 : Yes | No | Cancel
##  4 : Yes | No
##  5 : Retry | Cancel 
##  6 : Cancel | Try Again | Continue

Have fun!

Note: edited to use MessageBoxW instead of MessageBoxA

Answer #9

To verify that a string is a keyword you can use keyword.iskeyword; to get the list of reserved keywords you can use keyword.kwlist:

>>> import keyword
>>> keyword.iskeyword("break")
>>> keyword.kwlist
["False", "None", "True", "and", "as", "assert", "break", "class", "continue", "def", 
 "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", 
 "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", 
 "while", "with", "yield"]

If you want to include built-in names as well (Python 3), then check the builtins module:

>>> import builtins
>>> dir(builtins)
["ArithmeticError", "AssertionError", "AttributeError",
 "BaseException", "BlockingIOError", "BrokenPipeError", "BufferError", "BytesWarning",
 "ChildProcessError", "ConnectionAbortedError", "ConnectionError",
 "ConnectionRefusedError", "ConnectionResetError", "DeprecationWarning", "EOFError",
 "Ellipsis", "EnvironmentError", "Exception", "False", "FileExistsError",
 "FileNotFoundError", "FloatingPointError", "FutureWarning", "GeneratorExit", "IOError",
 "ImportError", "ImportWarning", "IndentationError", "IndexError",
 "InterruptedError", "IsADirectoryError", "KeyError", "KeyboardInterrupt", "LookupError",
 "MemoryError", "NameError", "None", "NotADirectoryError", "NotImplemented",
 "NotImplementedError", "OSError", "OverflowError", "PendingDeprecationWarning",
 "PermissionError", "ProcessLookupError", "RecursionError", "ReferenceError",
 "ResourceWarning", "RuntimeError", "RuntimeWarning", "StopAsyncIteration",
 "StopIteration", "SyntaxError", "SyntaxWarning", "SystemError", "SystemExit",
 "TabError", "TimeoutError", "True", "TypeError", "UnboundLocalError",
 "UnicodeDecodeError", "UnicodeEncodeError", "UnicodeError", "UnicodeTranslateError",
 "UnicodeWarning", "UserWarning", "ValueError", "Warning", "ZeroDivisionError", "_",
 "__build_class__", "__debug__", "__doc__", "__import__", "__loader__", "__name__",
 "__package__", "__spec__", "abs", "all", "any", "ascii", "bin", "bool",
 "bytearray", "bytes", "callable", "chr", "classmethod", "compile", "complex",
 "copyright", "credits", "delattr", "dict", "dir", "divmod", "enumerate", "eval",
 "exec", "exit", "filter", "float", "format", "frozenset", "getattr",
 "globals", "hasattr", "hash", "help", "hex", "id", "input", "int",
 "isinstance", "issubclass", "iter", "len", "license", "list", "locals", "map",
 "max", "memoryview", "min", "next", "object", "oct", "open", "ord", "pow",
 "print", "property", "quit", "range", "repr", "reversed", "round", "set",
 "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super", "tuple",
 "type", "vars", "zip"]

For Python 2 you"ll need to use the __builtin__ module

>>> import __builtin__
>>> dir(__builtin__)
["ArithmeticError", "AssertionError", "AttributeError", "BaseException", "BufferError", "BytesWarning", "DeprecationWarning", "EOFError", "Ellipsis", "EnvironmentError", "Exception", "False", "FloatingPointError", "FutureWarning", "GeneratorExit", "IOError", "ImportError", "ImportWarning", "IndentationError", "IndexError", "KeyError", "KeyboardInterrupt", "LookupError", "MemoryError", "NameError", "None", "NotImplemented", "NotImplementedError", "OSError", "OverflowError", "PendingDeprecationWarning", "ReferenceError", "RuntimeError", "RuntimeWarning", "StandardError", "StopIteration", "SyntaxError", "SyntaxWarning", "SystemError", "SystemExit", "TabError", "True", "TypeError", "UnboundLocalError", "UnicodeDecodeError", "UnicodeEncodeError", "UnicodeError", "UnicodeTranslateError", "UnicodeWarning", "UserWarning", "ValueError", "Warning", "WindowsError", "ZeroDivisionError", "_", "__debug__", "__doc__", "__import__", "__name__", "__package__", "abs", "all", "any", "apply", "basestring", "bin", "bool", "buffer", "bytearray", "bytes", "callable", "chr", "classmethod", "cmp", "coerce", "compile", "complex", "copyright", "credits", "delattr", "dict", "dir", "divmod", "enumerate", "eval", "execfile", "exit", "file", "filter", "float", "format", "frozenset", "getattr", "globals", "hasattr", "hash", "help", "hex", "id", "input", "int", "intern", "isinstance", "issubclass", "iter", "len", "license", "list", "locals", "long", "map", "max", "memoryview", "min", "next", "object", "oct", "open", "ord", "pow", "print", "property", "quit", "range", "raw_input", "reduce", "reload", "repr", "reversed", "round", "set", "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super", "tuple", "type", "unichr", "unicode", "vars", "xrange", "zip"]

Answer #10

  1. The two code blocks you gave are not equivalent
  2. The code you described as old way of doing things has a serious bug: in case opening the file fails you will get a second exception in the finally clause because f is not bound.

The equivalent old style code would be:

    f = open("file", "r")
        line = f.readline()
except IOError:

As you can see, the with statement can make things less error prone. In newer versions of Python (2.7, 3.1), you can also combine multiple expressions in one with statement. For example:

with open("input", "r") as inp, open("output", "w") as out:

Besides that, I personally regard it as bad habit to catch any exception as early as possible. This is not the purpose of exceptions. If the IO function that can fail is part of a more complicated operation, in most cases the IOError should abort the whole operation and so be handled at an outer level. Using with statements, you can get rid of all these try...finally statements at inner levels.