Quelle est l'utilisation de "assert" en Python?
J'ai lu du code source et, à plusieurs endroits, j'ai vu utiliser assert.
Qu'est-ce que cela signifie exactement? Quel est son usage?
L'instruction assert existe dans presque tous les langages de programmation. Cela aide à détecter les problèmes au début de votre programme, où la cause est claire, plutôt que plus tard comme effet secondaire d'une autre opération.
Quand tu fais ...
assert condition
... vous demandez au programme de tester cette condition et de déclencher immédiatement une erreur si la condition est fausse.
En Python, c'est à peu près équivalent à ceci:
if not condition:
raise AssertionError()
Essayez-le dans le shell Python:
>>> assert True # nothing happens
>>> assert False
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError
Les assertions peuvent inclure un message facultatif et vous pouvez les désactiver lors de l'exécution de l'interpréteur.
Pour imprimer un message si l'assertion échoue:
assert False, "Oh no! This assertion failed!"
Ne pas utilisez des parenthèses pour appeler assert comme une fonction. C'est une déclaration. Si vous faites assert(condition, message), vous exécuterez le assert avec un (condition, message) Tuple en premier paramètre.
Pour ce qui est de les désactiver, lors de l'exécution de python en mode optimisé, où __debug__ est False, les instructions d'assertion seront ignorées. Il suffit de passer le drapeau -O:
python -O script.py
Voir ici pour la documentation pertinente.
Attention aux parenthèses. Comme indiqué ci-dessus, en Python 3, assert est toujours une instruction , donc, par analogie avec print(..), on peut extrapoler la même chose assert(..) ou raise(..) mais vous ne devriez pas.
Ceci 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 est que bool( (False, "Houston we've got a problem") ) est évalué à True.
Dans l'instruction assert(False), il ne s'agit que de parenthèses redondantes autour de False, qui correspondent à leur contenu. Mais avec assert(False,), les parenthèses sont maintenant un tuple et un tuple non vide est évalué à True dans un contexte booléen.
Comme d'autres réponses l'ont noté, assert est similaire à la levée d'une exception si une condition donnée n'est pas vraie. 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 être décrit comme équivalent à
if __debug__:
if not expression: raise AssertionError
Cela peut être utile si vous souhaitez tester minutieusement votre code, puis publier une version optimisée lorsque vous êtes heureux qu'aucun de vos cas d'assertion n'échoue. Lorsque l'optimisation est activée, la variable __debug__ devient False et les conditions s'arrêtent. se faire évaluer. Cette fonctionnalité peut également vous surprendre si vous vous appuyez sur les assertions et que vous 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 déclaration ne fait rien, tandis que la seconde soulève une exception. Ceci est le premier indice: les assertions sont utiles pour vérifier les conditions qui devraient être vraies dans une position donnée de votre code (généralement, le début (préconditions) et la fin d'une fonction (postconditions)).
Les affirmations sont en fait très liées à la programmation par contrat, ce qui est une pratique d'ingénierie très utile:
Le but d'une assertion dans Python est d'informer les développeurs des erreurs irrécupérables dans un programme.
Les assertions ne sont pas destinées à signaler les conditions d'erreur attendues, telles que "fichier non trouvé", dans lesquelles un utilisateur peut prendre des mesures correctives (ou simplement essayer à nouveau).
Une autre façon de voir les choses est de dire que les assertions sont des auto-vérifications internes dans votre code. Ils fonctionnent en déclarant certaines conditions comme impossible dans votre code. Si ces conditions ne tiennent pas, cela signifie qu’il ya un bogue 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 bloquera avec une erreur d'assertion vous indiquant exactement quelle condition "impossible" a été déclenchée. Cela facilite beaucoup la recherche et la correction des bogues dans vos programmes.
Voici un résumé de n tutoriel sur les affirmations de Python J'ai écrit:
L'instruction assert de Python est une aide au débogage, et non un mécanisme de gestion des erreurs d'exécution. Le but de l'utilisation d'assertions est de permettre aux développeurs de trouver la cause fondamentale probable d'un bug plus rapidement. Une erreur d’assertion ne doit jamais être déclenchée sauf s’il existe un bogue dans votre programme.
La déclaration d'affirmation a deux formes.
Le formulaire 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 conforme aux attentes du programmeur, l'objectif étant de détecter les 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 en lire plus: http://docs.python.org/release/2.5.2/ref/assert.html
Voici un exemple simple, enregistrez-le dans un 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 la déclaration après assert est vraie, le programme continue, mais si la déclaration après assert est fausse, le programme génère une erreur. Aussi 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
Comme résumé brièvement sur le C2 Wiki :
Une assertion est une expression booléenne à un point spécifique d'un programme qui sera vraie à moins qu'il y ait un bogue dans le programme.
Vous pouvez utiliser une instruction assert pour documenter votre compréhension du code à un point de programme particulier. Par exemple, vous pouvez documenter des hypothèses ou des garanties sur les entrées (conditions préalables), l'état du programme (invariants) ou les sorties (postconditions).
Si votre assertion échoue un jour, ceci constitue une alerte pour vous (ou votre successeur) que votre compréhension du programme était erronée lorsque vous l'avez écrite et qu'elle contient probablement un bogue.
Pour plus d'informations, John Regehr a publié un article merveilleux sur le tilisation d'assertions , qui s'applique également à l'instruction Python assert.
Si vous voulez savoir exactement ce que fait une fonction réservée 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.
L'instruction assert existe dans presque tous les langages de programmation. Cela aide à détecter les problèmes au début de votre programme, où la cause est claire, plutôt que plus tard comme effet secondaire d'une autre opération. Ils s'attendent toujours à une condition True.
Quand vous faites quelque chose comme:
assert condition
Vous demandez au programme de tester cette condition et de déclencher immédiatement une erreur si elle est fausse.
En Python, assert expression , est équivalent à:
if __debug__:
if not <expression>: raise AssertionError
Vous pouvez utiliser l'expression étendue pour transmettre un message facultatif :
if __debug__:
if not (expression_1): raise AssertionError(expression_2)
Essayez-le dans l'interprète Python:
>>> 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
Avant de les utiliser, certaines mises en garde s’appliquent principalement à ceux qui envisagent de basculer entre les instructions assert et if. L'objectif d'utiliser assert est parfois lorsque le programme vérifie une condition et renvoie une valeur qui doit immédiatement arrêter le programme au lieu de prendre un autre moyen de contourner l'erreur:
1. parenthèses
Comme vous l'avez peut-être remarqué, l'instruction assert utilise deux conditions. Par conséquent, ne ( pas n'utilisez pas de parenthèses pour les inclure comme conseils évidents. Si vous faites tel que:
assert (condition, message)
Exemple:
>>> assert (1==2, 1==1)
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
Vous exécuterez le assert avec un (condition, message) qui représente un tuple en tant que premier paramètre, et cela se produit car Tuple non vide dans Python est toujours True. Cependant, vous pouvez faire séparément sans problème:
assert (condition), "message"
Exemple:
>>> 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. But du débogage
Si vous vous demandez quand utiliser l'instruction assert. Prenons un exemple utilisé dans la vie réelle:
* Lorsque votre programme a tendance à contrôler chaque paramètre entré par l'utilisateur ou quoi que ce soit d'autre:
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())
* Un autre cas concerne les mathématiques lorsque 0 ou non positif en tant que coefficient ou constante dans une certaine équation:
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
* ou même un exemple simple d'implémentation booléenne:
def true(a, b):
assert (a == b), "False"
return 1
def false(a, b):
assert (a != b), "True"
return 0
3. Traitement ou validation des données
La plus grande importance est de ne pas compter sur l'instruction assert pour exécuter le traitement ou la validation des données, car cette instruction peut être désactivée sur l'initialisation Python avec -O ou -OO - signifiant valeur 1, 2 et 0 ( par défaut), respectivement - ou PYTHONOPTIMIZE variable d’environnement.
Valeur 1:
* les assertions sont désactivées;
* Les fichiers de code intermédiaire sont générés à l'aide de .pyo extension au lieu de .pyc;
* sys.flags.optimize est défini sur 1 (True);
* et, __debug__ est défini sur False;
Valeur 2: désactive encore un élément.
* les docstrings sont désactivés;
Par conséquent, l'utilisation de l'instruction assert pour valider une sorte de données attendue est extrêmement dangereuse, même pour certains problèmes de sécurité. Ensuite, si vous devez valider une autorisation, je vous recommande plutôt raise AuthError. En tant que condition préalable efficace, un assert est couramment utilisé par les programmeurs de bibliothèques ou de modules sans interaction directe de l'utilisateur.
Ma courte explication est la suivante:
assertsoulèveAssertionErrorsi expression est fausse, sinon le code continue, et s'il y a une virgule, ce seraAssertionError: whatever after commaet le code ressemblera à:raise AssertionError(whatever after comma)
Un tutoriel connexe à ce sujet:
https://www.tutorialspoint.com/python/assertions_in_python.htm
Python assert est fondamentalement une aide au débogage qui conditionne la vérification interne de votre code. Assert facilite grandement le débogage lorsque votre code entre dans des cas impossibles Edge. Assert vérifier ces cas impossibles.
Supposons qu'il existe une fonction permettant de calculer le prix d'un 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 génère une erreur d'assertion, qui aide le développeur à identifier qu'un événement impossible s'est déjà produit.
J'espère que ça aide :)