¿Cuál es el uso de “afirmar” en Python?

He estado leyendo algún código fuente y en varios lugares he visto el uso de assert .

¿Qué significa exactamente? ¿Cuál es su uso?

La afirmación de afirmación existe en casi todos los lenguajes de progtwigción. Ayuda a detectar problemas al principio de su progtwig, donde la causa es clara, y no más tarde como un efecto secundario de alguna otra operación.

Cuando tu lo hagas…

 assert condition 

… le está diciendo al progtwig que pruebe esa condición, e inmediatamente active un error si la condición es falsa.

En Python, es aproximadamente equivalente a esto:

 if not condition: raise AssertionError() 

Pruébalo en el shell de Python:

 >>> assert True # nothing happens >>> assert False Traceback (most recent call last): File "", line 1, in  AssertionError 

Las aserciones pueden incluir un mensaje opcional y puede deshabilitarlas al ejecutar el intérprete.

Para imprimir un mensaje si la aserción falla:

 assert False, "Oh no! This assertion failed!" 

No use paréntesis para llamar a assert como una función. Es una afirmación. Si assert(condition, message) , ejecutará la assert con una tupla (condition, message) como primer parámetro.

En cuanto a deshabilitarlos, cuando se ejecuta python en modo optimizado, donde __debug__ es False , se ignorarán las declaraciones de afirmación. Simplemente pase la bandera -O :

 python -O script.py 

Vea aquí para la documentación relevante.

Cuidado con los paréntesis. Como se ha señalado anteriormente, en Python 3, assert sigue siendo una statement , por lo que, por analogía con la print(..) , se puede extrapolar lo mismo para assert(..) o raise(..) pero no debería.

Esto es importante porque:

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

no funcionará, a diferencia de

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

La razón por la que la primera no funcionará es que bool( (False, "Houston we've got a problem") ) evalúa como True .

En la afirmación de afirmación assert(False) , estos son solo paréntesis redundantes alrededor de False , que evalúan su contenido. Pero con assert(False,) los paréntesis son ahora una tupla, y una tupla no vacía se evalúa como True en un contexto booleano.

Como han señalado otras respuestas, assert es similar a lanzar una excepción si una condición dada no es verdadera. Una diferencia importante es que las declaraciones de afirmación se ignoran si comstack su código con la opción de optimización. La documentación dice que assert expression puede describirse mejor como equivalente a

 if __debug__: if not expression: raise AssertionError 

Esto puede ser útil si desea probar minuciosamente su código, luego libere una versión optimizada cuando esté satisfecho de que ninguno de sus casos de afirmación falle: cuando la optimización está __debug__ , la variable __debug__ convierte en False y las condiciones dejarán de ser evaluadas. Esta función también puede atraparlo si confía en las afirmaciones y no se da cuenta de que han desaparecido.

Otros ya te han dado enlaces a la documentación.

Puedes probar lo siguiente en una shell interactiva:

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

La primera statement no hace nada, mientras que la segunda genera una excepción. Esta es la primera sugerencia: las afirmaciones son útiles para verificar las condiciones que deben cumplirse en una posición determinada de su código (generalmente, el principio (condiciones previas) y el final de una función (postcondiciones)).

Las afirmaciones en realidad están altamente ligadas a la progtwigción por contrato, lo que es una práctica de ingeniería muy útil:

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

El objective de una afirmación en Python es informar a los desarrolladores sobre errores irrecuperables en un progtwig.

Las afirmaciones no pretenden señalar las condiciones de error esperadas, como “archivo no encontrado”, donde un usuario puede tomar medidas correctivas (o simplemente intentarlo de nuevo).

Otra forma de verlo es decir que las afirmaciones son autocomprobaciones internas en su código. Funcionan declarando algunas condiciones como imposibles en tu código. Si estas condiciones no se cumplen, significa que hay un error en el progtwig.

Si su progtwig está libre de errores, estas condiciones nunca ocurrirán. Pero si ocurre uno de ellos , el progtwig se bloqueará con un error de confirmación que le indicará exactamente qué condición “imposible” se activó. Esto hace que sea mucho más fácil rastrear y corregir errores en sus progtwigs.

Aquí hay un resumen de un tutorial sobre las aserciones de Python que escribí:

La statement de afirmación de Python es una ayuda de depuración, no un mecanismo para manejar errores en tiempo de ejecución. El objective de usar aserciones es permitir que los desarrolladores encuentren la causa raíz probable de un error más rápidamente. Nunca se debe generar un error de aserción a menos que haya un error en su progtwig.

La aseveración tiene dos formas.

La forma simple, assert , es equivalente a

 if __​debug__: if not : raise AssertionError 

La forma extendida, assert , , es equivalente a

 if __​debug__: if not : raise AssertionError,  

Las afirmaciones son una forma sistemática de verificar que el estado interno de un progtwig es el esperado por el progtwigdor, con el objective de detectar errores. Vea el ejemplo a continuación.

 >>> 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 "", line 1, in  AssertionError: Only positive numbers are allowed! >>> 

De los documentos:

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

Aquí puede leer más: http://docs.python.org/release/2.5.2/ref/assert.html

Aquí hay un ejemplo simple, guárdelo en un archivo (digamos b.py)

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

y el resultado cuando $python b.py

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

si la statement después de afirmar es verdadera, entonces el progtwig continúa, pero si la statement después de afirmar es falsa, entonces el progtwig da un error. Simple como eso.

p.ej:

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

Como resumimos concisamente en la Wiki C2 :

Una afirmación es una expresión booleana en un punto específico de un progtwig que será verdadera a menos que haya un error en el progtwig.

Puede usar una statement de afirmación para documentar su comprensión del código en un punto del progtwig en particular. Por ejemplo, puede documentar suposiciones o garantías sobre entradas (condiciones previas), estado del progtwig (invariantes) o salidas (condiciones posteriores).

Si su afirmación falla alguna vez, esta es una alerta para usted (o su sucesor) que su comprensión del progtwig fue incorrecta cuando lo escribió y que probablemente contiene un error.

Para obtener más información, John Regehr tiene una maravillosa publicación de blog sobre el uso de aserciones , que también se aplica a la statement de afirmación de Python.

Si alguna vez desea saber exactamente qué hace una función reservada en python, escriba help(enter_keyword)

Asegúrese de que, si ingresa una palabra clave reservada, la ingrese como una cadena.

Python Assert es básicamente una ayuda de depuración que prueba la condición de autocomprobación interna de su código. Assert hace que la depuración sea realmente fácil cuando su código se encuentra en casos de borde imposibles. Afirmar comprobar esos casos imposibles.

Digamos que hay una función para calcular el precio del artículo después del descuento:

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

aquí, discounted_price nunca puede ser menor que 0 y mayor que el precio real. Por lo tanto, en caso de que se viole la condición anterior, afirmar genera un error de aserción, lo que ayuda al desarrollador a identificar que algo imposible había ocurrido.

Espero eso ayude 🙂

Mi breve explicación es:

  • assert eleva AssertionError si la expresión es falsa, de lo contrario simplemente continúa con el código, y si hay una coma cualquiera sea AssertionError: whatever after comma , y para el código es como: raise AssertionError(whatever after comma)

Un tutorial relacionado sobre esto:

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

formato: afirmar Expresión [, argumentos] Cuando assert encuentra una statement, Python evalúa la expresión. Si la statement no es verdadera, se genera una excepción (assertionError). Si la aserción falla, Python usa ArgumentExpression como el argumento para AssertionError. Las excepciones de AssertionError se pueden capturar y manejar como cualquier otra excepción usando la statement try-except, pero si no se manejan, terminarán el progtwig y producirán un rastreo. Ejemplo:

 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) 

Cuando se ejecuta el código anterior, produce el siguiente resultado:

 32.0 451 Traceback (most recent call last): File "test.py", line 9, in  print KelvinToFahrenheit(-5) File "test.py", line 4, in KelvinToFahrenheit assert (Temperature >= 0),"Colder than absolute zero!" AssertionError: Colder than absolute zero! 
 def getUser(self, id, Email): user_key = id and id or Email assert user_key 

Puede utilizarse para garantizar que los parámetros se pasan en la llamada de función.

 >>>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 "", line 1, in  assert test_us AssertionError >>> 

Básicamente, el significado de la palabra clave assert es que si la condición no es verdadera, entonces a través de un error de aserción, por ejemplo, continúa en python.

código-1

 a=5 b=6 assert a==b 

SALIDA:

 assert a==b AssertionError 

código-2

 a=5 b=5 assert a==b 

SALIDA:

 Process finished with exit code 0