The best answers to the question “What is the use of "assert" in Python?” in the category Dev.
I have been reading some source code and in several places I have seen the usage of
What does it mean exactly? What is its usage?
Watch out for the parentheses. As has been pointed out in other answers, in Python 3,
assert is still a statement, so by analogy with
print(..), one may extrapolate the same to
raise(..) but you shouldn’t.
This is wrong:
assert(2 + 2 == 5, "Houston we've got a problem")
This is correct:
assert 2 + 2 == 5, "Houston we've got a problem"
The reason the first one will not work is that
bool( (False, "Houston we've got a problem") ) evaluates to
In the statement
assert(False), these are just redundant parentheses around
False, which evaluate to their contents. But with
assert(False,) the parentheses are now a tuple, and a non-empty tuple evaluates to
True in a boolean context.
assert statement exists in almost every programming language. It helps detect problems early in your program, where the cause is clear, rather than later when some other operation fails.
When you do…
… you’re telling the program to test that condition, and immediately trigger an error if the condition is false.
In Python, it’s roughly equivalent to this:
if not condition: raise AssertionError()
Try it in the Python shell:
>>> assert True # nothing happens >>> assert False Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError
Assertions can include an optional message, and you can disable them when running the interpreter.
To print a message if the assertion fails:
assert False, "Oh no! This assertion failed!"
Do not use parenthesis to call
assert like a function. It is a statement. If you do
assert(condition, message) you’ll be running the
assert with a
(condition, message) tuple as first parameter.
As for disabling them, when running
python in optimized mode, where
False, assert statements will be ignored. Just pass the
python -O script.py
See here for the relevant documentation.
The goal of an assertion in Python is to inform developers about unrecoverable errors in a program.
Assertions are not intended to signal expected error conditions, like “file not found”, where a user can take corrective action (or just try again).
Another way to look at it is to say that assertions are internal self-checks in your code. They work by declaring some conditions as impossible in your code. If these conditions don’t hold that means there’s a bug in the program.
If your program is bug-free, these conditions will never occur. But if one of them does occur the program will crash with an assertion error telling you exactly which “impossible” condition was triggered. This makes it much easier to track down and fix bugs in your programs.
Here’s a summary from a tutorial on Python’s assertions I wrote:
Python’s assert statement is a debugging aid, not a mechanism for handling run-time errors. The goal of using assertions is to let developers find the likely root cause of a bug more quickly. An assertion error should never be raised unless there’s a bug in your program.
As other answers have noted,
assert is similar to throwing an exception if a given condition isn’t true. An important difference is that assert statements get ignored if you compile your code with the optimization option
-O. The documentation says that
assert expression can better be described as being equivalent to
if __debug__: if not expression: raise AssertionError
This can be useful if you want to thoroughly test your code, then release an optimized version when you’re happy that none of your assertion cases fail – when optimization is on, the
__debug__ variable becomes False and the conditions will stop getting evaluated. This feature can also catch you out if you’re relying on the asserts and don’t realize they’ve disappeared.