declaración “afirmar” con o sin paréntesis

6 minutos de lectura

avatar de usuario del nuevo nombre
nuevo nombre

Aquí hay cuatro invocaciones simples de afirmar:

>>> assert 1==2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AssertionError

>>> assert 1==2, "hi"
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AssertionError: hi

>>> assert(1==2)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AssertionError

>>> assert(1==2, "hi")

Tenga en cuenta que el último no genera un error. ¿Cuál es la diferencia entre llamar a assert con o sin paréntesis que causa este comportamiento? Mi práctica es usar paréntesis, pero lo anterior sugiere que no debería hacerlo.

  • Gracias por las respuestas útiles. La distinción entre palabras clave y funciones integradas parece sutil. Aquí hay una lista de palabras clave, para las cuales supongo que los parens deberían quedar fuera: docs.python.org/reference/lexical_analysis.html#palabras clave

    – nuevo nombre

    24 de junio de 2010 a las 17:31

  • Una diferencia es que puede redefinir funciones integradas pero no puede hacerlo con palabras clave (no es que lo primero sea una buena idea).

    – nuevo nombre

    24 de junio de 2010 a las 17:34

  • No es una distinción entre función y palabra clave, sino Llamada de función contra declaración. (por ejemplo, print solía ser una declaración y funcionaba sin paréntesis).

    – Tomasz Gandor

    18 de abril de 2018 a las 8:51

El último assert te hubiera dado una advertencia (SyntaxWarning: assertion is always true, perhaps remove parentheses?) si lo ejecutó a través de un intérprete completo, no a través de IDLE. Porque assert es una palabra clave y no una función, en realidad está pasando una tupla como primer argumento y omitiendo el segundo argumento.

Recuerde que las tuplas no vacías se evalúan como Truey dado que el mensaje de afirmación es opcional, esencialmente ha llamado assert True cuando escribiste assert(1==2, "hi").

  • La razón es que no sucede por assert (1==2) si los paréntesis alrededor de una sola expresión no crearán una tupla automáticamente; obtendrías el mismo comportamiento que el n. ° 4 si lo hicieras assert (1==2,). Lo mismo pasaría si lo hicieras print ('foo', 'bar') en vez de print 'foo', 'bar'; verías la salida de la tupla

    – Michael Mrozek

    24 de junio de 2010 a las 17:05


  • Vale la pena enfatizar aún más que las declaraciones de la forma assert(test, message) probablemente equivocado, y ciertamente confuso. ¡Sin padres!

    – tcarobruce

    24 de junio de 2010 a las 17:24

  • Entonces, ¿cuál es la forma correcta de sangrar una declaración de afirmación larga, como PEP8? Parece imposible.

    – Stantonk

    11 de abril de 2013 a las 16:53

  • stackoverflow.com/questions/16065482/…

    – Jonatán

    30 de agosto de 2013 a las 12:45

Avatar de usuario de Eric Leschinski
eric leschinski

Si puso el paréntesis allí porque quería una aserción de varias líneas, entonces una alternativa es poner una barra invertida al final de la línea como esta:

foo = 7
assert foo == 8, \
    "derp should be 8, it is " + str(foo)

Huellas dactilares:

AssertionError: "derp should be 8, it is 7

¿Por qué esta pitón assert tiene que ser diferente de todo lo demás:

Creo que la ideología pitónica es que un programa debe autocorregirse sin tener que preocuparse por la bandera especial para activar las afirmaciones. La tentación de desactivar las afirmaciones es demasiado grande y, por lo tanto, está en desuso.

Comparto tu molestia de que la pitón assert tiene una sintaxis única en relación con todas las demás construcciones de programación de python, y esta sintaxis ha cambiado una vez más de python2 a python3 y nuevamente cambió de python 3.4 a 3.6. Hacer declaraciones de aserción no compatibles con versiones anteriores de cualquier versión a cualquier otra versión.

Es un toque en el hombro que assert es un ciudadano de tercera clase, se eliminará por completo en python4, y ciertamente nuevamente en Python 8.1.

  • ¿Hay un documento sobre lo que deberíamos usar en lugar de afirmar? Assert parece un nombre tan lógico para validar, y tiene el comportamiento deseado, por ejemplo, mostrar un mensaje especial en caso de error.

    – AnneTheAgile

    21 mayo 2019 a las 20:22

Puede romper la declaración de afirmación sin \ como esto:

foo = 7
assert foo == 8, (
    'derp should be 8, it is ' + str(foo))

O si tienes un mensaje aún más largo:

foo = 7
assert foo == 8, (
    'Lorem Ipsum is simply dummy text of the printing and typesetting '
    'industry. Lorem Ipsum has been the industry\'s standard dummy text '
    'ever since the 1500s'
)

  • Idea interesante. Odio las barras diagonales inversas para la continuación, y esta es una alternativa a envolver afirmar en una función de utilidad (que fue mi solución).

    – Tomasz Gandor

    18 de abril de 2018 a las 8:53

Avatar de usuario de Amber
Ámbar

assert 1==2, "hi" se analiza como assert 1==2, "hi" con “hola” como segundo parámetro de la palabra clave. Por lo tanto, por qué correctamente da un error.

assert(1==2) se analiza como assert (1==2) que es identico a assert 1==2porque los paréntesis alrededor de un solo elemento no crean una tupla a menos que haya una coma final, por ejemplo (1==2,).

assert(1==2, "hi") se analiza como assert (1==2, "hi")que no da un error porque una tupla no vacía (False, "hi") no es un valor falso y no se proporciona un segundo parámetro a la palabra clave.

No deberías usar paréntesis porque assert no es una función en Python, es una palabra clave.

A continuación se cita de la documento de Python

Las declaraciones de afirmación son una forma conveniente de insertar declaraciones de depuración en un programa:

assert_stmt ::= "assert" expression ["," expression]

La forma simple, expresión de afirmación, es equivalente a

if __debug__:
if not expression: raise AssertionError

La forma extendida, afirmar expresión1, expresión2es equivalente a

if __debug__:
if not expression1: raise AssertionError(expression2)

Entonces, cuando usa paréntesis aquí, está usando la forma simple, y la expresión se evalúa como una tupla, que siempre es verdadera cuando se convierte en bool

afirmar declaración con o sin paréntesis como se muestra a continuación son los mismos:

assert (x == 3)
assert x == 3

Y, otras declaraciones como si, tiempo, por y del con o sin paréntesis como se muestra a continuación también son los mismos:


if (x == "Hello"):
if x == "Hello":

while (x == 3):
while x == 3:

for (x) in (fruits):
for x in fruits:


del (x)
del x

Además, básicamente, la mayoría de los ejemplos de código Python que he visto hasta ahora no usan paréntesis por assert, if, while, for y del declaraciones por lo que prefiero no usar paréntesis para ellos.

¿Ha sido útil esta solución?