Nrthugu

Watch out for the parentheses. As has been pointed out above, 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 important because:

assert(2 + 2 == 5, "Houston we've got a problem")

won't work, unlike

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.

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. 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.

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.

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.

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>

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!

>>> 

From docs:

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

Here you can read more: http://docs.python.org/release/2.5.2/ref/assert.html

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

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

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.

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 :)

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

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.

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.

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!