ChatGPT解决这个技术问题 Extra ChatGPT

What is the use of "assert" in Python?

What does assert mean? How is it used?


s
slezica

The assert statement exists in almost every programming language. It has two main uses:

It helps detect problems early in your program, where the cause is clear, rather than later when some other operation fails. A type error in Python, for example, can go through several layers of code before actually raising an Exception if not caught early on. It works as documentation for other developers reading the code, who see the assert and can confidently say that its condition holds from now on.

When you do...

assert condition

... 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 __debug__ is False, assert statements will be ignored. Just pass the -O flag:

python -O script.py

See here for the relevant documentation.


Nit: assert is a statement and not a function. And unlike print, in Python 3 it's still a statement.
@Chaine assert means "make sure that *something" is True". So assert a == 3 will make sure that a is equal to 3; if a is not equal to 3 (i.e. a==3 is False) then it will raise an error
If I can just use the if not condition: raise AssertError(), why should I use assert? Are there any conditions under which assert is better other than just being a shorter form of if not condition statement?
totally cannot get how does this answer get so many up votes, actually others answers also. the question is "What is the use of “assert” in Python? ", so it is asking: when to use, or more exactly: what is the usage scenario of assert, but after reading all answers, i totally got nothing i want!
The purpose of assertions are frequently misunderstood. They are not for early test conditions as has been suggested, and they are not syntactic sugar for test expressions. Their purpose is to "assert" that certain conditions are true at certain points in the program, with the intent of helping programmers understand the state of the system at those points. For example, if at the top of a function I see an "assert arg" statement, then I will know without a doubt that (arg is None) is an invalid state for any subsequent statements in that function, reducing the state set I have to consider.
N
Neuron

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 assert(..) or 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 True.

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.


I came here looking for this exact info about parens and the follow message. Thanks.
But assert (2 + 2 = 5), "Houston we've got a problem" should be ok, yes?
Don't forget that people often use parentheses for PEP 8-compliant implicit line continuation Also Also don't forget that tuples are not defined by parentheses but by the existence of the comma (tuples have nothing to do with parens except for the purposes of operator precedence).
assert (2 + 2 = 5), "Houston we've got a problem" won't work... but it has nothing to do with the assert statement, which is fine. Your condition won't work because it isn't a condition. Missing a second =.
@SherylHohman, assert (2+2==5), “Houston we’ve got a problem will evaluate to assert False, “Houston we’ve got a problem, and will thus raise the assertion error. This is regardless of whether you have a space between assert and (2+2==5). What the other commenters are talking about is when you pass (2+2==5, “Houston we’ve got a problem”) as a input the assert function. So the input is really a tuple consisting of 2 terms 2+2==5 and “Houston we’ve got a problem`.
R
Ricardo Stuven

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.


Does this mean, that if a certain variable or correct input (according to the contract by which the program is written) could lead to crashing the program, when its run by the user (assuming that -O flag is used when the user runs the program), you should instead use the if Not Error: raise Exception(“ this is a error”)? That way, the program will still show the source of the error, when the user runs it..
On the other hand, if you expect that the program could error out because of incorrect logic/implementation of the code (but not due to an input which is according to the contract to the user of the program), you should use the assert statement? The assumption here is that when the program is released to the end user, you are using the -O flag, thus assuming that all the bugs have been removed. Hence, any error or program crash is due to input to the program which is valid as per the contract, but cant be handled by the program. So it should alert the user as such.
@alpha_989 that's exactly right. I like to think of assertions as sanity checks that are only to help you as a developer to make sure that what you think is true is actually true while you develop.
d
dbader

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.


Thanks for the article. Very helpful to understand assert statement and when to use this. I am trying to understand a number of terms that you introduced in the article.
I thought I would post the comments here so a lot more people might be benefited from the clarifications. Sorry if the questions are too naive.
If you consider that ‘user.is_admin()` is a user input and hence shouldn’t be used in an assert statement, cant price also be considered a user input? Why do you consider assert user.is_admin() as data validation but not assert price?
@LaryxDecidua Nope, you can just read it on my website, the tutorial is publicly available. Just hit escape or click the little "x" symbol if you're not interested in the newsletter. Hope this helps :-)
+1 for explaining when to use assertions. I had it explained once to me that if a caller can trigger an assertion via the use of public API, then that is always a bug that should be fixed. Either the assertion did its job and found a genuine bug or it is an improper assertion doing public contract enforcement and should be replaced with a proper caller facing error. Assertions are for validating the internal private logic of your implementations not for public API contract enforcement against a caller.
p
pyrrhic

Others have already given you links to documentation.

You can try the following in a interactive shell:

>>> assert 5 > 2
>>> assert 2 > 5
Traceback (most recent call last):
  File "<string>", line 1, in <fragment>
builtins.AssertionError:

The first statement does nothing, while the second raises an exception. This is the first hint: asserts are useful to check conditions that should be true in a given position of your code (usually, the beginning (preconditions) and the end of a function (postconditions)).

Asserts are actually highly tied to programming by contract, which is a very useful engineering practice:

http://en.wikipedia.org/wiki/Design_by_contract.


Lose the parens, assert is not a function.
Losing the parens is more important than it seems. See below.
Assert actually dates back (long before "contracts") to Turing, when he wrote one of the earliest papers on how programmers might tackle the rather daunting task of creating correct programs. Finding that paper is left as an exercise for the reader, since all programmers can benefit from becoming familiar with his work. :-) turingarchive.org
b
binaryfunt

From docs:

Assert statements are a convenient way to insert debugging assertions into a program

You can read more here: http://docs.python.org/release/2.5.2/ref/assert.html


i like this comment since it just explains what it is very plainly. my question is "if i've written a proper unit test, why would i need an assertion"? that stuff doesn't run in production anyways.
If you want to write a unit test for each and every possible corner case then you don't need to assert. But assertions can be quicker to write and more concise. They also aid readability of the code because they assert that something is true at the point in the code where it is supposed to be true, whereas unit tests are often not even in the same file.
I
Ian Goldby

The assert statement has two forms.

The simple form, assert <expression>, is equivalent to

if __​debug__:
    if not <expression>: raise AssertionError

The extended form, assert <expression1>, <expression2>, is equivalent to

if __​debug__:
    if not <expression1>: raise AssertionError(<expression2>)

J
Jacob Abraham

Assertions are a systematic way to check that the internal state of a program is as the programmer expected, with the goal of catching bugs. See the example below.

>>> number = input('Enter a positive number:')
Enter a positive number:-1
>>> assert (number > 0), 'Only positive numbers are allowed!'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: Only positive numbers are allowed!
>>> 

Also, assertions can often be used in unit testing programs. stackoverflow.com/questions/1383/what-is-unit-testing
Your answer is correct but the example is a very bad one. Assert should NOT be used to verify user input, because depending on compile flags, asserts can be disabled. A better example would be to call a function defined for positive numbers but pass a negative.
No! In your example, it's not a bug in the code if someone enters a negative number, so an assertion is completely inappropriate. A better (but still rather trivial) example would be assert math.pow(number, 2) >= 0 because you can guarantee that for any number this is true unless there is an error in the math.pow() code.
G
Gaurav Agarwal

Here is a simple example, save this in file (let's say b.py)

def chkassert(num):
    assert type(num) == int


chkassert('a')

and the result when $python b.py

Traceback (most recent call last):
  File "b.py", line 5, in <module>
    chkassert('a')
  File "b.py", line 2, in chkassert
    assert type(num) == int
AssertionError

a
avandeursen

As summarized concisely on the C2 Wiki:

An assertion is a boolean expression at a specific point in a program which will be true unless there is a bug in the program.

You can use an assert statement to document your understanding of the code at a particular program point. For example, you can document assumptions or guarantees about inputs (preconditions), program state (invariants), or outputs (postconditions).

Should your assertion ever fail, this is an alert for you (or your successor) that your understanding of the program was wrong when you wrote it, and that it likely contains a bug.

For more information, John Regehr has a wonderful blog post on the Use of Assertions, which applies to the Python assert statement as well.


+1 for pointing out that the use of the assert statement is useful for documenting the programmer‘s understanding of the code.
s
slayer

The assert statement exists in almost every programming language. It helps detect problems early in your program, where the cause is clear, rather than later as a side-effect of some other operation. They always expect a True condition.

When you do something like:

assert condition

You're telling the program to test that condition and immediately trigger an error if it is false.

In Python, assert expression, is equivalent to:

if __debug__:
    if not <expression>: raise AssertionError

You can use the extended expression to pass an optional message:

if __debug__:
    if not (expression_1): raise AssertionError(expression_2)

Try it in the Python interpreter:

>>> assert True # Nothing happens because the condition returns a True value.
>>> assert False # A traceback is triggered because this evaluation did not yield an expected value.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

There are some caveats to seen before using them mainly for those who deem to toggles between the assert and if statements. The aim to use assert is on occasions when the program verifies a condition and return a value that should stop the program immediately instead of taking some alternative way to bypass the error:

1. Parentheses

As you may have noticed, the assert statement uses two conditions. Hence, do not use parentheses to englobe them as one for obvious advice. If you do such as:

assert (condition, message)

Example:

>>> assert (1==2, 1==1)
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

You will be running the assert with a (condition, message) which represents a tuple as the first parameter, and this happens cause non-empty tuple in Python is always True. However, you can do separately without problem:

assert (condition), "message"

Example:

>>> assert (1==2), ("This condition returns a %s value.") % "False"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: This condition returns a False value.

2. Debug purpose

If you are wondering regarding when use assert statement. Take an example used in real life:

* When your program tends to control each parameter entered by the user or whatever else:

def loremipsum(**kwargs):
    kwargs.pop('bar') # return 0 if "bar" isn't in parameter
    kwargs.setdefault('foo', type(self)) # returns `type(self)` value by default
    assert (len(kwargs) == 0), "unrecognized parameter passed in %s" % ', '.join(kwargs.keys())

* Another case is on math when 0 or non-positive as a coefficient or constant on a certain equation:

def discount(item, percent):
    price = int(item['price'] * (1.0 - percent))
    print(price)
    assert (0 <= price <= item['price']),\
            "Discounted prices cannot be lower than 0 "\
            "and they cannot be higher than the original price."

    return price

* or even a simple example of a boolean implementation:

def true(a, b):
    assert (a == b), "False"
    return 1

def false(a, b):
    assert (a != b), "True"
    return 0

3. Data processing or data validation

The utmost importance is to not rely on the assert statement to execute data processing or data validation because this statement can be turned off on the Python initialization with -O or -OO flag – meaning value 1, 2, and 0 (as default), respectively – or PYTHONOPTIMIZE environment variable.

Value 1:

* asserts are disabled;

* bytecode files are generated using .pyo extension instead of .pyc;

* sys.flags.optimize is set to 1 (True);

* and, __debug__ is set to False;

Value 2: disables one more stuff

* docstrings are disabled;

Therefore, using the assert statement to validate a sort of expected data is extremely dangerous, implying even to some security issues. Then, if you need to validate some permission I recommend you raise AuthError instead. As a preconditional effective, an assert is commonly used by programmers on libraries or modules that do not have a user interact directly.


S
Shawn Mehan

if the statement after assert is true then the program continues , but if the statement after assert is false then the program gives an error. Simple as that.

e.g.:

assert 1>0   #normal execution
assert 0>1   #Traceback (most recent call last):
             #File "<pyshell#11>", line 1, in <module>
             #assert 0>1
             #AssertionError

a
alwbtc

In Pycharm, if you use assert along with isinstance to declare an object's type, it will let you access the methods and attributes of the parent object while you are coding, it will auto-complete automatically.

For example, let's say self.object1.object2 is a MyClass object.

import MyClasss

def code_it(self):
    testObject = self.object1.object2 # at this point, program doesn't know that testObject  is a MyClass object yet
    assert isinstance(testObject , MyClasss) # now the program knows testObject is a MyClass object
    testObject.do_it() # from this point on, PyCharm will be able to auto-complete when you are working on testObject

r
rassa45

If you ever want to know exactly what a reserved function does in python, type in help(enter_keyword)

Make sure if you are entering a reserved keyword that you enter it as a string.


N
Nitish Chauhan

Python assert is basically a debugging aid which test condition for internal self-check of your code. Assert makes debugging really easy when your code gets into impossible edge cases. Assert check those impossible cases.

Let's say there is a function to calculate price of item after discount :

def calculate_discount(price, discount):
    discounted_price = price - [discount*price]
    assert 0 <= discounted_price <= price
    return discounted_price

here, discounted_price can never be less than 0 and greater than actual price. So, in case the above condition is violated assert raises an Assertion Error, which helps the developer to identify that something impossible had happened.

Hope it helps :)


assert is useful in a debugging context, but should not be relied outside of a debugging context.
U
U12-Forward

My short explanation is:

assert raises AssertionError if expression is false, otherwise just continues the code, and if there's a comma whatever it is it will be AssertionError: whatever after comma, and to code is like: raise AssertionError(whatever after comma)

A related tutorial about this:

https://www.tutorialspoint.com/python/assertions_in_python.htm


The answer provides how to use an assert, but not when to use (or not use) an assert; also noting that an assert can be disabled if __debug__ is False would be useful.
j
jferard

As written in other answers, assert statements are used to check the state of the program at a given point.

I won't repeat what was said about associated message, parentheses, or -O option and __debug__ constant. Check also the doc for first hand information. I will focus on your question: what is the use of assert? More precisely, when (and when not) should one use assert?

The assert statements are useful to debug a program, but discouraged to check user input. I use the following rule of thumb: keep assertions to detect a this should not happen situation. A user input may be incorrect, e.g. a password too short, but this is not a this should not happen case. If the diameter of a circle is not twice as large as its radius, you are in a this should not happen case.

The most interesting, in my mind, use of assert is inspired by the programming by contract as described by B. Meyer in [Object-Oriented Software Construction]( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction%2C_2nd_Edition ) and implemented in the [Eiffel programming language]( https://en.wikipedia.org/wiki/Eiffel_(programming_language)). You can't fully emulate programming by contract using the assert statement, but it's interesting to keep the intent.

Here's an example. Imagine you have to write a head function (like the [head function in Haskell]( http://www.zvon.org/other/haskell/Outputprelude/head_f.html)). The specification you are given is: "if the list is not empty, return the first item of a list". Look at the following implementations:

>>> def head1(xs): return xs[0]

And

>>> def head2(xs):
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

(Yes, this can be written as return xs[0] if xs else None, but that's not the point).

If the list is not empty, both functions have the same result and this result is correct:

>>> head1([1, 2, 3]) == head2([1, 2, 3]) == 1
True

Hence, both implementations are (I hope) correct. They differ when you try to take the head item of an empty list:

>>> head1([])
Traceback (most recent call last):
...
IndexError: list index out of range

But:

>>> head2([]) is None
True

Again, both implementations are correct, because no one should pass an empty list to these functions (we are out of the specification). That's an incorrect call, but if you do such a call, anything can happen. One function raises an exception, the other returns a special value. The most important is: we can't rely on this behavior. If xs is empty, this will work:

print(head2(xs))

But this will crash the program:

print(head1(xs))

To avoid some surprises, I would like to know when I'm passing some unexpected argument to a function. In other words: I would like to know when the observable behavior is not reliable, because it depends on the implementation, not on the specification. Of course, I can read the specification, but programmers do not always read carefully the docs.

Imagine if I had a way to insert the specification into the code to get the following effect: when I violate the specification, e.g by passing an empty list to head, I get a warning. That would be a great help to write a correct (i.e. compliant with the specification) program. And that's where assert enters on the scene:

>>> def head1(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     return xs[0]

And

>>> def head2(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

Now, we have:

>>> head1([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

And:

>>> head2([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

Note that head1 throws an AssertionError, not an IndexError. That's important because an AssertionError is not any runtime error: it signals a violation of the specification. I wanted a warning, but I get an error. Fortunately, I can disable the check (using the -O option), but at my own risks. I will do it a crash is really expensive, and hope for the best. Imagine my program is embedded in a spaceship that travels through a black hole. I will disable assertions and hope the program is robust enough to not crash as long as possible.

This example was only about preconditions, be you can use assert to check postconditions (the return value and/or the state) and invariants (state of a class). Note that checking postconditions and invariants with assert can be cumbersome:

for postconditions, you need to assign the return value to a variable, and maybe to store the iniial state of the object if you are dealing with a method;

for invariants, you have to check the state before and after a method call.

You won't have something as sophisticated as Eiffel, but you can however improve the overall quality of a program.

To summarize, the assert statement is a convenient way to detect a this should not happen situation. Violations of the specification (e.g. passing an empty list to head) are first class this should not happen situations. Hence, while the assert statement may be used to detect any unexpected situation, it is a privilegied way to ensure that the specification is fulfilled. Once you have inserted assert statements into the code to represent the specification, we can hope you have improved the quality of the program because incorrect arguments, incorrect return values, incorrect states of a class..., will be reported.


M
Misaal D'souza

Assertions are statements that state a fact confidently in our program.

Syntax : assert <condition> or assert <condition>,<error message>

It has a condition/expression which is supposed to be always true. If the condition is false, the assert statement will halt the program and throw an error message saying AssertionError. So your assertion expression will be something that you don't want in your program.

e.g.

assert -- using assert without var = int(input("Enter value 1-9 inclusive:")) assert var!=0 print(var) Output : If input is 0 : AssertionError If input is 1 : 1 assert , -- using assert with an var = int(input("Enter value 1-9 inclusive:")) assert var!=0,"Input cannot be zero" print(var) Output : If input is 0 : AssertionError: Input cannot be zero If input is 1 : 1

Key Points :

It is used as a debugging tool. It takes an expression and an optional message. It exists in almost every programming language


I would give you a + for the description, but - for then using assert for input validation. Net score: nothing.
U
User

The assert keyword in Python raises an AssertionError if the code following the assert keyword is False. If not, it continues as nothing happened.

Example 1:

a = 5
b = 6

assert a == b

OUTPUT:

AssertionError

This is because, obviously, a does not equal b. This is particularly useful if you want to raise an Exception in your code.

def get_dict_key(d, k):
    try:
        assert k in d
        return d[k]
    except Exception:
        print("Key must be in dict.")

The above example is practically useless, but remember, it is mostly used for debugging purposes, so you can track down your bugs.


please format your code properly. also, how does this improve on previous answers?
is there any problem in my explanation?
your explanation doesn't add anything to the existing answers, and the poor grammar makes it hard to read. if you're looking for questions to answer, consider browsing the new questions feed.
The provided answer does answer how to use an assert, but does not answer when to use (or not use) an assert.
b
bhavya joshi

format : assert Expression[,arguments] When assert encounters a statement,Python evaluates the expression.If the statement is not true,an exception is raised(assertionError). If the assertion fails, Python uses ArgumentExpression as the argument for the AssertionError. AssertionError exceptions can be caught and handled like any other exception using the try-except statement, but if not handled, they will terminate the program and produce a traceback. Example:

def KelvinToFahrenheit(Temperature):    
    assert (Temperature >= 0),"Colder than absolute zero!"    
    return ((Temperature-273)*1.8)+32    
print KelvinToFahrenheit(273)    
print int(KelvinToFahrenheit(505.78))    
print KelvinToFahrenheit(-5)    

When the above code is executed, it produces the following result:

32.0
451
Traceback (most recent call last):    
  File "test.py", line 9, in <module>    
    print KelvinToFahrenheit(-5)    
  File "test.py", line 4, in KelvinToFahrenheit    
    assert (Temperature >= 0),"Colder than absolute zero!"    
AssertionError: Colder than absolute zero!    

C
Cleb
def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

Can be used to ensure parameters are passed in the function call.


This will work, but from what I understand, asserts shouldn’t be used for checking user-input, because they can be turned off at run-time. If you really want to enforce or validate user-input use the if not user_key: raise ValueError() Check last 2 paragraphs here: wiki.python.org/moin/UsingAssertionsEffectively
assert should not be used for input validation because either the validation will be stripped out if __debug__ is False. Also using assertions for non-debug purposes can cause people to catch the resulting AssertionErrors, which can make debugging more difficult instead of less.
r
rianhariadi.com
>>>this_is_very_complex_function_result = 9
>>>c = this_is_very_complex_function_result
>>>test_us = (c < 4)

>>> #first we try without assert
>>>if test_us == True:
    print("YES! I am right!")
else:
    print("I am Wrong, but the program still RUNS!")

I am Wrong, but the program still RUNS!


>>> #now we try with assert
>>> assert test_us
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    assert test_us
AssertionError
>>>