¿Cómo analizo una cadena en un flotante o int?


2253

En Python, ¿cómo puedo analizar una cadena numérica como "545.2222"su valor flotante correspondiente 545.2222? ¿O analizar la cadena "31"a un entero 31?

Solo quiero saber cómo analizar un flotante str a un float, y (por separado) un int str a un int.


77
Como regla general, si tiene un objeto en Python y desea convertir a ese tipo de objeto, instálelo type(my_object). El resultado generalmente se puede llamar como una función para hacer la conversión. Por ejemplo, los type(100)resultados int, por lo que puede llamar int(my_object)para intentar convertir my_objecta un entero. Esto no siempre funciona, pero es una buena "primera suposición" cuando se codifica.
robertlayton

1
int(x) if int(x) == float(x) else float(x)
tcpaiva

Respuestas:


2628
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545

8
solo me pregunto por qué hay '04' al final? ¿Por qué no simplemente '00'? También mi versión actual de Python no tiene '04'.
Mangat Rai Modi

54
@MangatRaiModi Los números de punto flotante son inherentemente imperfectos para representar decimales. Para obtener más información, consulte stackoverflow.com/q/21895756/931277
dokkaebi el

19
¿Por qué no simplemente int(a)sino int(float(a))?
idclev 463035818

24
int(a)dará un error de que la cadena no es un entero válido: ValueError: invalid literal for int() with base 10: '545.222'pero la conversión de un flotante a un int es una conversión compatible.
David Parks

44
Debe manejar ValueErrorsi quiere estar seguro
Joe Bobson

515
def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)

81
La mezcla implícita de flotadores / ints puede conducir a errores sutiles debido a la posible pérdida de precisión al trabajar con flotadores o a diferentes resultados para el /operador en flotadores / ints. Dependiendo del contexto, puede ser preferible devolver int o float, no ambos.
jfs

14
@JFSebastian Estás completamente en lo correcto, pero hay momentos en que quieres que la entrada dicte cuál será. Dejar que la entrada dicte cuál puede funcionar bien con la escritura de pato.
TimothyAWiseman

44
Puede anidar otro trypara lanzar una excepción cuando no es convertible para flotar.
iBug

2
Falla cons = u'\u0000'
Matt Hancock

1
@iBug Buena idea! Recomiendo tirar ValueErrorel correspondiente except: P
marcelm

511

Método de Python para verificar si una cadena es flotante:

def is_float(value):
  try:
    float(value)
    return True
  except:
    return False

Un nombre más largo y preciso para esta función podría ser: is_convertible_to_float(value)

Lo que es y no es un flotador en Python puede sorprenderte:

val                   is_float(val) Note
--------------------  ----------   --------------------------------
""                    False        Blank string
"127"                 True         Passed string
True                  True         Pure sweet Truth
"True"                False        Vile contemptible lie
False                 True         So false it becomes true
"123.456"             True         Decimal
"      -127    "      True         Spaces trimmed
"\t\n12\r\n"          True         whitespace ignored
"NaN"                 True         Not a number
"NaNanananaBATMAN"    False        I am Batman
"-iNF"                True         Negative infinity
"123.E4"              True         Exponential notation
".1"                  True         mantissa only
"1,234"               False        Commas gtfo
u'\x30'               True         Unicode is fine.
"NULL"                False        Null is not special
0x3fade               True         Hexadecimal
"6e7777777777777"     True         Shrunk to infinity
"1.797693e+308"       True         This is max value
"infinity"            True         Same as inf
"infinityandBEYOND"   False        Extra characters wreck it
"12.34.56"            False        Only one dot allowed
u'四'                 False        Japanese '4' is not a float.
"#56"                 False        Pound sign
"56%"                 False        Percent of what?
"0E0"                 True         Exponential, move dot 0 places
0**0                  True         0___0  Exponentiation
"-5e-5"               True         Raise to a negative number
"+1e1"                True         Plus is OK with exponent
"+1e1^5"              False        Fancy exponent not interpreted
"+1e1.3"              False        No decimals in exponent
"-+1"                 False        Make up your mind
"(1)"                 False        Parenthesis is bad

¿Crees que sabes qué son los números? ¡No eres tan bueno como crees! No es una gran sorpresa.

¡No use este código en software vital!

Capturando amplias excepciones de esta manera, matando canarios y engullendo la excepción, se crea una pequeña posibilidad de que un flotador válido como cadena devuelva falso. La float(...)línea de código puede fallar por cualquiera de las miles de razones que no tienen nada que ver con el contenido de la cadena. Pero si está escribiendo software vital en un lenguaje prototipo de escritura de pato como Python, entonces tiene problemas mucho mayores.


1
Tan cierto se convierte en 1, es decir, heredé de C ++, creo
FindOutIslamNow

66
Publiqué esta respuesta en 2014. Ese UTF-8glifo para un chino 4se ha transformado a lo largo de los años dependiendo de cómo los desarrolladores de stackoverflow cambien su esquema de codificación de caracteres en su conjunto de herramientas de Microsoft. Es una curiosidad verlo flip flop a lo largo de los años a medida que los nuevos esquemas de conversión afirman sus nuevas ideologías. Pero sí, cualquier UTF-8glifo para un número oriental oriental no es un flotador de Python. Bazinga
Eric Leschinski

44
¿Cómo puede ser tan votado, con una excepción tan amplia?
E.Serra

Todo lo que tenga espacios intermedios no se puede convertir, como "- 12.3"y"45 e6"
Simon

1
Esta cláusula, excepto se debe restringir aTypeError, ValueError
wim

131

Este es otro método que merece ser mencionado aquí, ast.literal_eval :

Esto se puede usar para evaluar de forma segura las cadenas que contienen expresiones de Python de fuentes no confiables sin la necesidad de analizar los valores uno mismo.

Es decir, un 'eval' seguro

>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31

11
Esta no es una buena solución al problema. Funciona bien en Python 2, pero sucede lo siguiente en Python 3: python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> para aclarar por qué esto es un problema, si desea dejar los números de teléfono solos y no asumir que son expresiones matemáticas, entonces este enfoque no es para usted.
royce3

66
@ royce3 Sí, ese es un buen punto y los usuarios deben tener cuidado. El comportamiento se modificó originalmente para abordar algunos problemas con el análisis de literales complejos. Podría decirse que es un error ast.literal_evaly se ha discutido aquí .
wim

79
float(x) if '.' in x else int(x)

21
Nota: tenga cuidado al tratar con la cantidad de dinero aprobada como cadenas, ya que algunos países usan "," como separadores decimales
Ben G

127
@Emile: No llamaría "2e-3" un "caso extremo". Esta respuesta está rota.
jchl

14
@BenG NO manipule dinero como una carroza. Eso es pedir problemas. ¡Usa decimal para dinero! (Pero su comentario sobre ',' sigue siendo válido e importante)
ToolmakerSteve

44
No olvide que "no es un número" (NaN) y +/- infinito también son valores flotantes válidos. Entonces, float("nan")es un valor flotante perfectamente válido que la respuesta anterior no captaría en absoluto
Ronny Andersson

2
Fácilmente rompible por una dirección IP - 192.168.0.1; o"This is not a good approach. :)"
Todor Minakov el

69

Localización y comas

Debe considerar la posibilidad de comas en la representación de cadena de un número, para casos como el float("545,545.2222")que arroja una excepción. En su lugar, utilice métodos localepara convertir las cadenas en números e interpretar comas correctamente. El locale.atofmétodo se convierte en flotante en un paso una vez que la configuración regional se ha establecido para la convención de números deseada.

Ejemplo 1 - Convenciones numéricas de los Estados Unidos

En los Estados Unidos y el Reino Unido, las comas se pueden usar como un separador de miles. En este ejemplo con la configuración regional estadounidense, la coma se maneja correctamente como un separador:

>>> import locale
>>> a = u'545,545.2222'
>>> locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
'en_US.UTF-8'
>>> locale.atof(a)
545545.2222
>>> int(locale.atof(a))
545545
>>>

Ejemplo 2 - Convenciones numéricas europeas

En la mayoría de los países del mundo , las comas se utilizan para las marcas decimales en lugar de puntos. En este ejemplo con configuración regional en francés, la coma se maneja correctamente como una marca decimal:

>>> import locale
>>> b = u'545,2222'
>>> locale.setlocale(locale.LC_ALL, 'fr_FR')
'fr_FR'
>>> locale.atof(b)
545.2222

El método locale.atoitambién está disponible, pero el argumento debe ser un número entero.


Esta parece ser una solución ideal cuando se sabe si se debe devolver un float o int, pero ¿cómo puede hacer que devuelva un int solo si se pasó un int? Por ejemplo, x = '1'; locale.atof(x)regresa 1.0cuando realmente quiero 1.
user5359531

Usando el método de Dino, supongo que la respuesta sería usar algo como esto:locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
user5359531

Recomendaría usar el método anterior de Javier (concluir locale.atoien un intento y usar locale.atofen una excepción, probablemente sea más legible.)
Mark Chackerian

27

Si no eres reacio a los módulos de terceros, puedes consultar el módulo fastnumbers . Proporciona una función llamada fast_real que hace exactamente lo que esta pregunta está pidiendo y lo hace más rápido que una implementación de Python puro:

>>> from fastnumbers import fast_real
>>> fast_real("545.2222")
545.2222
>>> type(fast_real("545.2222"))
float
>>> fast_real("31")
31
>>> type(fast_real("31"))
int

24

Codelogic de usuarios y harley son correctos, pero tenga en cuenta que si sabe que la cadena es un número entero (por ejemplo, 545) puede llamar a int ("545") sin primero emitir un flotante.

Si sus cadenas están en una lista, también puede usar la función de mapa.

>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>

Solo es bueno si todos son del mismo tipo.


21

En Python, ¿cómo puedo analizar una cadena numérica como "545.2222" a su valor flotante correspondiente, 542.2222? ¿O analizar la cadena "31" a un entero, 31? Solo quiero saber cómo analizar una cadena flotante en un flotante y (por separado) una cadena int en un int.

Es bueno que pidas hacer esto por separado. Si los está mezclando, puede estar preparándose para problemas más tarde. La respuesta simple es:

"545.2222" flotar:

>>> float("545.2222")
545.2222

"31" a un entero:

>>> int("31")
31

Otras conversiones, int hacia y desde cadenas y literales:

Conversiones de varias bases, y debe conocer la base de antemano (10 es el valor predeterminado). Tenga en cuenta que puede prefijarlos con lo que Python espera para sus literales (ver a continuación) o eliminar el prefijo:

>>> int("0b11111", 2)
31
>>> int("11111", 2)
31
>>> int('0o37', 8)
31
>>> int('37', 8)
31
>>> int('0x1f', 16)
31
>>> int('1f', 16)
31

Si no conoce la base de antemano, pero sabe que tendrán el prefijo correcto, Python puede inferir esto si lo pasa 0como base:

>>> int("0b11111", 0)
31
>>> int('0o37', 0)
31
>>> int('0x1f', 0)
31

Literales no decimales (es decir, enteros) de otras bases

Si su motivación es que su propio código represente claramente valores específicos codificados, sin embargo, es posible que no necesite convertir desde las bases; puede dejar que Python lo haga automáticamente con la sintaxis correcta.

Puede usar los prefijos apropos para obtener la conversión automática a enteros con los siguientes literales . Estos son válidos para Python 2 y 3:

Binario, prefijo 0b

>>> 0b11111
31

Octal, prefijo 0o

>>> 0o37
31

Hexadecimal, prefijo 0x

>>> 0x1f
31

Esto puede ser útil al describir indicadores binarios, permisos de archivo en código o valores hexadecimales para colores; por ejemplo, no tenga en cuenta las comillas:

>>> 0b10101 # binary flags
21
>>> 0o755 # read, write, execute perms for owner, read & ex for group & others
493
>>> 0xffffff # the color, white, max values for red, green, and blue
16777215

Hacer que los octals ambiguos de Python 2 sean compatibles con Python 3

Si ve un número entero que comienza con un 0, en Python 2, esta es una sintaxis octal (en desuso).

>>> 037
31

Es malo porque parece que el valor debería ser 37. Entonces, en Python 3, ahora genera un SyntaxError:

>>> 037
  File "<stdin>", line 1
    037
      ^
SyntaxError: invalid token

Convierta sus octals de Python 2 a octales que funcionen en 2 y 3 con el 0oprefijo:

>>> 0o37
31

20

La pregunta parece un poco vieja. Pero permítanme sugerir una función, parseStr, que hace algo similar, es decir, devuelve entero o flotante y si una cadena ASCII dada no se puede convertir en ninguna de ellas, la devuelve intacta. El código, por supuesto, puede ajustarse para hacer solo lo que desee:

   >>> import string
   >>> parseStr = lambda x: x.isalpha() and x or x.isdigit() and \
   ...                      int(x) or x.isalnum() and x or \
   ...                      len(set(string.punctuation).intersection(x)) == 1 and \
   ...                      x.count('.') == 1 and float(x) or x
   >>> parseStr('123')
   123
   >>> parseStr('123.3')
   123.3
   >>> parseStr('3HC1')
   '3HC1'
   >>> parseStr('12.e5')
   1200000.0
   >>> parseStr('12$5')
   '12$5'
   >>> parseStr('12.2.2')
   '12.2.2'

8
1e3es un número en python, pero una cadena de acuerdo con su código.
Cees Timmerman

16

float("545.2222") y int(float("545.2222"))


1
Esto le dará un objeto flotante si su cadena resulta ser "0" o "0.0", en lugar del int que da para otros números válidos.
Brian

14

Yo uso esta función para eso

import ast

def parse_str(s):
   try:
      return ast.literal_eval(str(s))
   except:
      return

Convertirá la cadena a su tipo

value = parse_str('1')  # Returns Integer
value = parse_str('1.5')  # Returns Float

Tenga en cuenta que parse_str(' 1')(con un espacio) volverá None, no 1.
musiphil

13

El analizador YAML puede ayudarlo a descubrir qué tipo de datos es su cadena. Use yaml.load(), y luego puede usar type(result)para probar el tipo:

>>> import yaml

>>> a = "545.2222"
>>> result = yaml.load(a)
>>> result
545.22220000000004
>>> type(result)
<type 'float'>

>>> b = "31"
>>> result = yaml.load(b)
>>> result
31
>>> type(result)
<type 'int'>

>>> c = "HI"
>>> result = yaml.load(c)
>>> result
'HI'
>>> type(result)
<type 'str'>

11
def get_int_or_float(v):
    number_as_float = float(v)
    number_as_int = int(number_as_float)
    return number_as_int if number_as_float == number_as_int else number_as_float

1
¿Por qué subirías en tu exceptsección si no estás haciendo nada allí? float () aumentaría para ti.
Greg0ry

1
tienes razón, supongo que copié y pegué desde una funcionalidad que estaba planteando una excepción particular. editará gracias
Totoro

1
Esto intentará analizar una cadena y devolver into floatdependiendo de lo que representa la cadena. Puede aumentar las excepciones de análisis o [tener un comportamiento inesperado] [1].
Kuzeko

9
def num(s):
    """num(s)
    num(3),num(3.7)-->3
    num('3')-->3, num('3.7')-->3.7
    num('3,700')-->ValueError
    num('3a'),num('a3'),-->ValueError
    num('3e4') --> 30000.0
    """
    try:
        return int(s)
    except ValueError:
        try:
            return float(s)
        except ValueError:
            raise ValueError('argument is not a string of number')

6

Debe tener en cuenta el redondeo para hacer esto correctamente.

Es decir, int (5.1) => 5 int (5.6) => 5 - incorrecto, debe ser 6, entonces hacemos int (5.6 + 0.5) => 6

def convert(n):
    try:
        return int(n)
    except ValueError:
        return float(n + 0.5)

44
Buen punto. Sin embargo, eso causa inflación, por lo que Python 3 y otros lenguajes modernos usan el redondeo bancario.
Cees Timmerman el

2
Esta respuesta es incorrecta (como se escribió originalmente). Confunde los dos casos de inty float. Y dará una excepción, cuando nes una cadena, como OP deseado. Quizás quiso decir: cuandoint se desea un resultado, rounddebe hacerse DESPUÉS de la conversión a flotante. Si la función SIEMPRE devuelve un int, entonces no necesita la parte except, puede ser el cuerpo completo de la función int(round(float(input))). Si la función debe devolver un int si es posible, de lo contrario un flotador, ¡entonces la solución original de javier es correcta!
ToolmakerSteve

5

Me sorprende que nadie haya mencionado regex porque a veces la cadena debe estar preparada y normalizada antes de enviarla al número

import re
def parseNumber(value, as_int=False):
    try:
        number = float(re.sub('[^.\-\d]', '', value))
        if as_int:
            return int(number + 0.5)
        else:
            return number
    except ValueError:
        return float('nan')  # or None if you wish

uso:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

y, por cierto, algo para verificar que tienes un número:

import numbers
def is_number(value):
    return isinstance(value, numbers.Number)
    # will work with int, float, long, Decimal

5

Para escribir en python, use las funciones de constructor del tipo, pasando la cadena (o cualquier valor que esté intentando convertir) como parámetro.

Por ejemplo:

>>>float("23.333")
   23.333

Detrás de escena, python está llamando al __float__método de los objetos , que debería devolver una representación flotante del parámetro. Esto es especialmente poderoso, ya que puede definir sus propios tipos (usando clases) con un __float__método para que se pueda convertir en un flotante usando float (myobject).



2

Pase su cadena a esta función:

def string_to_number(str):
  if("." in str):
    try:
      res = float(str)
    except:
      res = str  
  elif(str.isdigit()):
    res = int(str)
  else:
    res = str
  return(res)

Devolverá int, float o string dependiendo de lo que se haya pasado.

cadena que es un int

print(type(string_to_number("124")))
<class 'int'>

cuerda que es un flotador

print(type(string_to_number("12.4")))
<class 'float'>

cadena que es una cadena

print(type(string_to_number("hello")))
<class 'str'>

cuerda que parece un flotador

print(type(string_to_number("hel.lo")))
<class 'str'>

1

Utilizar:

def num(s):
    try:
        for each in s:
            yield int(each)
    except ValueError:
        yield float(each)
a = num(["123.55","345","44"])
print a.next()
print a.next()

Esta es la forma más pitónica que se me ocurrió.


El generador se detiene después de la primera interpretación de float. El try... catchbloque probablemente debería estar dentro del forbucle.
musiphil

1

Maneja hexadecimal, octal, binario, decimal y flotante

Esta solución manejará todas las convenciones de cadena para números (todo lo que sé).

def to_number(n):
    ''' Convert any number representation to a number 
    This covers: float, decimal, hex, and octal numbers.
    '''

    try:
        return int(str(n), 0)
    except:
        try:
            # python 3 doesn't accept "010" as a valid octal.  You must use the
            # '0o' prefix
            return int('0o' + n, 0)
        except:
            return float(n)

Este resultado del caso de prueba ilustra de lo que estoy hablando.

======================== CAPTURED OUTPUT =========================
to_number(3735928559)   = 3735928559 == 3735928559
to_number("0xFEEDFACE") = 4277009102 == 4277009102
to_number("0x0")        =          0 ==          0
to_number(100)          =        100 ==        100
to_number("42")         =         42 ==         42
to_number(8)            =          8 ==          8
to_number("0o20")       =         16 ==         16
to_number("020")        =         16 ==         16
to_number(3.14)         =       3.14 ==       3.14
to_number("2.72")       =       2.72 ==       2.72
to_number("1e3")        =     1000.0 ==       1000
to_number(0.001)        =      0.001 ==      0.001
to_number("0xA")        =         10 ==         10
to_number("012")        =         10 ==         10
to_number("0o12")       =         10 ==         10
to_number("0b01010")    =         10 ==         10
to_number("10")         =         10 ==         10
to_number("10.0")       =       10.0 ==         10
to_number("1e1")        =       10.0 ==         10

Aquí está la prueba:

class test_to_number(unittest.TestCase):

    def test_hex(self):
        # All of the following should be converted to an integer
        #
        values = [

                 #          HEX
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0xDEADBEEF  , 3735928559), # Hex
                ("0xFEEDFACE", 4277009102), # Hex
                ("0x0"       ,          0), # Hex

                 #        Decimals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (100         ,        100), # Decimal
                ("42"        ,         42), # Decimal
            ]



        values += [
                 #        Octals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0o10        ,          8), # Octal
                ("0o20"      ,         16), # Octal
                ("020"       ,         16), # Octal
            ]


        values += [
                 #        Floats
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (3.14        ,       3.14), # Float
                ("2.72"      ,       2.72), # Float
                ("1e3"       ,       1000), # Float
                (1e-3        ,      0.001), # Float
            ]

        values += [
                 #        All ints
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                ("0xA"       ,         10), 
                ("012"       ,         10), 
                ("0o12"      ,         10), 
                ("0b01010"   ,         10), 
                ("10"        ,         10), 
                ("10.0"      ,         10), 
                ("1e1"       ,         10), 
            ]

        for _input, expected in values:
            value = to_number(_input)

            if isinstance(_input, str):
                cmd = 'to_number("{}")'.format(_input)
            else:
                cmd = 'to_number({})'.format(_input)

            print("{:23} = {:10} == {:10}".format(cmd, value, expected))
            self.assertEqual(value, expected)

0

Utilizar:

>>> str_float = "545.2222"
>>> float(str_float)
545.2222
>>> type(_) # Check its type
<type 'float'>

>>> str_int = "31"
>>> int(str_int)
31
>>> type(_) # Check its type
<type 'int'>

0

Esta es una función que convertirá cualquiera object(no solo str) intao float, en función de si la cadena real suministrada se parece a int o float. Además, si se trata de un objeto que tiene ambos __floaty __int__métodos, el uso predeterminado es__float__

def conv_to_num(x, num_type='asis'):
    '''Converts an object to a number if possible.
    num_type: int, float, 'asis'
    Defaults to floating point in case of ambiguity.
    '''
    import numbers

    is_num, is_str, is_other = [False]*3

    if isinstance(x, numbers.Number):
        is_num = True
    elif isinstance(x, str):
        is_str = True

    is_other = not any([is_num, is_str])

    if is_num:
        res = x
    elif is_str:
        is_float, is_int, is_char = [False]*3
        try:
            res = float(x)
            if '.' in x:
                is_float = True
            else:
                is_int = True
        except ValueError:
            res = x
            is_char = True

    else:
        if num_type == 'asis':
            funcs = [int, float]
        else:
            funcs = [num_type]

        for func in funcs:
            try:
                res = func(x)
                break
            except TypeError:
                continue
        else:
            res = x

-1

Mediante el uso de métodos int y float podemos convertir una cadena en enteros y flotantes.

s="45.8"
print(float(s))

y='67'
print(int(y))

Esta respuesta no agrega nada nuevo. Vea, por ejemplo, esta respuesta que brinda la misma información y más.
Georgy

-3

eval()Es una muy buena solución a esta pregunta. No necesita verificar si el número es int o flotante, solo da el equivalente correspondiente. Si se requieren otros métodos, intente

if '.' in string:
    print(float(string))
else:
    print(int(string))

try-except también se puede utilizar como alternativa. Intente convertir la cadena a int dentro del bloque try. Si la cadena fuera un valor flotante, arrojará un error que será atrapado en el bloque excepto, como este

try:
    print(int(string))
except:
    print(float(string))

-10

Aquí hay otra interpretación de su pregunta (pista: es vago). Es posible que estés buscando algo como esto:

def parseIntOrFloat( aString ):
    return eval( aString )

Funciona así...

>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545

Teóricamente, hay una vulnerabilidad de inyección. La cadena podría, por ejemplo, ser "import os; os.abort()". Sin ningún antecedente sobre el origen de la cadena, sin embargo, la posibilidad es la especulación teórica. Como la pregunta es vaga, no está del todo claro si esta vulnerabilidad realmente existe o no.


77
Incluso si su entrada es 100% segura, eval()es más de 3 veces más lenta que try: int(s) except: float(s).
Cees Timmerman

1
Bueno, evales una mala práctica (debes saberlo porque tienes 310k de reputación)
U10-Forward
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.