En python, ¿por qué 0xbin() devuelve Falso? [duplicate]

1 minuto de lectura

avatar de usuario
MattS

Introduciendo el comando 0xbin() devuelve Falso:

>>> 0xbin()
False

¿Por qué sucede eso? Esta sintaxis no debería tener significado alguno. Las funciones no pueden comenzar con 0, no hay “i” ni “n” en hexadecimal, y la función bin debe tener algunos argumentos.

  • ¡Se necesitan argumentos! 0xbin(013,37)

    – nneonne

    25 de julio de 2018 a las 15:34


  • @nneonneo y si quieres conseguir True puedes probar 0xbin(11,) con un solo argumento

    – MattS

    25 de julio de 2018 a las 16:09


  • 0xbin(013,37) también te dará True;) (en Python 2.7)

    – nneonne

    26 de julio de 2018 a las 2:25

  • Compara y contrasta con 0xband(). Tokenizador es codicioso y toma 0xba como token.

    – Wim

    26/07/2018 a las 22:40


  • @personas que votan para reabrir: explique por qué esto no es un engaño. Si me convences, lo volveré a abrir.

    –Kevin

    27 de julio de 2018 a las 16:42

Python parece interpretar 0xbin() como 0xb in (), el significado es once en una tupla vacía. La respuesta es no, por lo tanto False.

  • Entonces, ¿aparentemente “en”, “es”, etc. no requieren espacios? La primera vez que encontré esto, pero tiene sentido ya que “<" y "==" tampoco los requieren.

    – MattS

    25 de julio de 2018 a las 14:22

  • Aparentemente sí. los Referencia de Python dice que los espacios en blanco entre tokens solo son necesarios “si su concatenación podría interpretarse como un token diferente”. Pero solo he visto tal código en código de golf.

    – Yo mismo

    25 de julio de 2018 a las 14:29

  • @MattS Esta es la razón por la cual los identificadores de python válidos (y muchos otros idiomas) solo aceptan alfa o guión bajo para la primera letra del identificador y luego permiten numéricos después. La implementación real es bastante complicada debido a la compatibilidad total con Unicode, pero la expresión regular ASCII pura para un identificador sería: r'[_a-zA-Z][_a-zA-Z0-9]*'

    – Aarón

    25/07/2018 a las 14:30


  • @Aarón: [_[:alpha:]][_[:alnum:]]* en lenguajes de expresiones regulares que permiten clases de caracteres (Unicode), es decir, no de Python. ;-]

    – David Foerster

    25 de julio de 2018 a las 16:20


  • Guau, pensé que este tipo de análisis solo se hacía en Fortran y BASIC. No puedo creer que un lenguaje moderno lo haga.

    – Barmar

    25 de julio de 2018 a las 18:28

avatar de usuario
Chris_Rands

Si desensambla el código, verás la respuesta de Yself, que menciona que 0xbin() se interpreta como 0xb in ()esta confirmado:

>>> import dis
>>> dis.dis('0xbin()')
  1           0 LOAD_CONST               0 (11)
              2 BUILD_TUPLE              0
              4 COMPARE_OP               6 (in)
              6 RETURN_VALUE

  • list(tokenize.tokenize(io.BytesIO(b"0xbin()").readline)) podría ser más apropiado

    – Roman Odaisky

    25 de julio de 2018 a las 16:38

avatar de usuario
Draconis

¡Puedes usar el propio tokenizador de Python para verificar!

import tokenize
import io
line = b'0xbin()'
print(' '.join(token.string for token in tokenize.tokenize(io.BytesIO(line).readline) if token.type!=59))

Esto imprime los tokens en su cadena, separados por espacios. En este caso, el resultado será:

0xb in ( ) 

En otras palabras, devuelve False porque el número 11 (0xb) no está en la tupla vacía (()).

(Gracias a Roman Odaisky por sugerir el uso de tokenize en los comentarios!)

EDITAR: Para explicar el código un poco más a fondo: el tokenize La función espera entrada en un formato un poco extraño, por lo que io.BytesIO(line).readline es una función que convierte una secuencia de bytes en algo tokenize puedo leer. tokenize luego lo tokeniza y devuelve una serie de namedtuples; tomamos la cadena que representa a cada uno y los unimos con espacios. los type != 59 part se usa para ignorar el especificador de codificación que, de lo contrario, aparecería al principio.

  • Esta es la mejor respuesta hasta ahora, las respuestas “dis” y “ast” oscurecen lo que sucede detrás de notaciones poco comunes, esto lo muestra claramente en Python normal.

    – lavado de enchufe

    26 de julio de 2018 a las 18:03

avatar de usuario
Pål GD

Puedes usar el AST módulo para obtener el árbol de sintaxis abstracta de la expresión:

>>> import ast
>>> m = ast.parse('0xbin()')
>>> ast.dump(m)
'Module(
    body=[Expr(
               value=Compare(left=Num(n=11),
                             ops=[In()],
                             comparators=[Tuple(elts=[],
                                                ctx=Load())
                                         ]
                            ))])'

Ver el gramática abstracta para saber cómo interpretar la expresión, pero tl; dr: Num(n=11) es el 0xb parte, y Tuple(elts=[], ...) sugiere una tupla vacía en lugar de una llamada de función.

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad