Quelle est l'utilisation de "assert" en Python?

Attention aux parenthèses. Comme cela a été souligné ci-dessus, en Python 3, assert est toujours une déclaration , donc par analogie avec print(..), on peut extrapoler la même chose à assert(..) ou raise(..) mais vous ne devriez pas.

C'est important parce que:

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

Ne fonctionnera pas, contrairement à

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

La raison pour laquelle le premier ne fonctionnera pas, c'est que bool( (False, "Houston we've got a problem") ) donne True.

Dans l'instruction assert(False), ce ne sont que des parenthèses redondantes autour de False, qui évaluent à leur contenu. Mais avec assert(False,) les parenthèses sont maintenant un tuple, et un tuple non vide évalue à True dans un contexte booléen.

Comme d'autres réponses ont noté, assert est similaire à lancer une exception si une condition donnée n'est pas vrai. Une différence importante est que les instructions assert sont ignorées si vous compilez votre code avec l'option d'optimisation. La documentation indique que assert expression peut mieux être décrite comme étant équivalente à

if __debug__:
   if not expression: raise AssertionError

Cela peut être utile si vous voulez tester complètement votre code, puis publier une version optimisée lorsque vous êtes heureux qu'aucun de vos cas d'assertion échoue-quand l'optimisation est activée, la variable __debug__ devient False et les conditions cesseront d'être évaluées. Cette fonctionnalité peut également vous attraper si vous comptez sur les affirmations et ne réalisez pas qu'elles ont disparu.

D'autres vous ont déjà donné des liens vers de la documentation.

Vous pouvez essayer ce qui suit dans un shell interactif:

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

La première instruction ne fait rien, tandis que la seconde soulève une exception. C'est le premier indice: les assertions sont utiles pour vérifier les conditions que doit être vrai dans une position donnée de votre code (généralement, le début (conditions préalables) et la fin d'une fonction (postconditions)).

Les affirmations sont en fait fortement liées à la programmation par contrat, ce qui est un pratique d'ingénierie très utile:

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

Le but d'une assertion en Python est d'informer les développeurs des erreursirrécupérables dans un programme.

Les Assertions ne sont pas destinées à signaler les conditions d'erreur attendues, comme "Fichier introuvable", où un utilisateur peut prendre des mesures correctives (ou simplement réessayer).

Une autre façon de le regarder est de dire que les assertions sont auto-vérifications internes dans votre code. Ils travaillent en déclarant certaines conditions comme impossible dans votre code. Si ces conditions ne tiennent pas cela signifie qu'il ya un bug dans le programme.

Si votre programme est exempt de bogues, ces conditions ne se produiront jamais. Mais si l'un d'entre eux se produit , le programme se bloque avec une erreur d'assertion vous indiquant exactement quelle condition "impossible" a été déclenchée. Cela rend beaucoup plus facile de traquer et de corriger les bugs dans vos programmes.

Voici un résumé de Un tutoriel sur les assertions de Python j'ai écrit:

L'instruction assert de Python est une aide au débogage, pas un mécanisme pour gérer les erreurs d'exécution. le but de l'utilisation des assertions est de permettre aux développeurs de trouver plus rapidement la cause d'un bogue. Une erreur d'assertion ne devrait jamais être déclenchée sauf s'il y a un bug dans votre programme.

L'instruction assert a deux formes.

La forme simple, assert <expression>, est équivalent à

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

La forme étendue, assert <expression1>, <expression2>, est équivalente à

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

Les Assertions sont un moyen systématique de vérifier que l'état interne d'un programme est comme prévu par le programmeur, dans le but d'attraper des bogues. Voir l'exemple ci-dessous.

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

De docs:

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

Ici vous pouvez lire plus: http://docs.python.org/release/2.5.2/ref/assert.html

Voici un exemple simple, enregistrez ceci dans le fichier (disons b.py)

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


chkassert('a')

Et le résultat quand $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

Si l'instruction après assert est true alors le programme continue, mais si l'instruction après assert est false alors le programme donne une erreur. Simple que cela.

Par exemple:

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

Si jamais vous voulez savoir exactement ce qu'est une fonction réserve n'en python, tapez help(enter_keyword)

Assurez-vous que si vous entrez un mot-clé réservé, vous le saisissez sous forme de chaîne.

Python assert est fondamentalement une aide au débogage qui teste la condition d'auto-vérification interne de votre code. Assert rend le débogage vraiment facile lorsque votre code entre dans des cas de bord impossibles. Assert vérifier ces cas impossibles.

Disons qu'il existe une fonction pour calculer le prix de l'article après remise:

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

Ici, discounted_price ne peut jamais être inférieur à 0 et supérieur au prix réel. Ainsi, dans le cas où la condition ci-dessus est violée, assert soulève une erreur D'Assertion, ce qui aide le développeur à identifier que quelque chose d'impossible s'était passé.

J'espère que ça aide:)

MA courte explication est:

• assert soulève AssertionError si l'expression est fausse, sinon continue simplement le code, et s'il y a une virgule quoi que ce soit, ce sera AssertionError: whatever after comma, et le code est comme: raise AssertionError(whatever after comma)

Un tutoriel connexe à ce sujet:

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

def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

Peut être utilisé pour assurer que les paramètres sont passés dans l'appel de fonction.

Format : affirmer Expression[,arguments] Lorsque affirmer rencontre une instruction,Python évalue l'expression.Si l'instruction n'est pas true, une exception est déclenchée(assertionError). Si l'assertion échoue, Python utilise ArgumentExpression comme argument pour AssertionError. Les exceptions AssertionError peuvent être interceptées et gérées comme toute autre exception à l'aide de l'instruction try-except, mais si elles ne sont pas gérées, elles mettront fin au programme et produiront un retraçage. Exemple:

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)    

Quand le code ci-dessus est exécuté, il produit le résultat suivant:

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!    

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

Fondamentalement, la signification du mot-clé assert est que si la condition n'est pas vraie, alors elle via une assertionerror sinon elle continue par exemple en python.

Code-1

a=5

b=6

assert a==b

Sortie:

assert a==b

AssertionError

Code-2

a=5

b=5

assert a==b

Sortie:

Process finished with exit code 0