Pregunta ¿Cómo analizo una cadena en float o int en Python?


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 número entero, 31?

Solo quiero saber cómo analizar un flotador  string a un floaty (por separado) un En t  string a una int.


1757
2017-12-19 01:52


origen


Respuestas:


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

2084
2017-12-19 01:54



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

441
2017-12-19 02:31



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

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

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

Lo que es, y no es una carroza en Pitón puede sorprenderte:

val                   isfloat(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é números son? ¡No eres tan bueno como crees! No es una gran sorpresa.


416
2018-01-05 04:15



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

Esto se puede usar para evaluar de forma segura 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

104
2018-03-01 04:23



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

74
2017-12-19 02:32



Localización y comas

Debería considerar la posibilidad de comas en la representación de cadena de un número, para casos como float("545,545.2222") que arroja una excepción. En cambio, usa métodos en locale para convertir las cadenas en números e interpretar las comas correctamente. los locale.atof El método se convierte en un flotante en un solo paso una vez que la configuración regional se ha establecido para la convención numérica deseada.

Ejemplo 1 - convenciones de números de Estados Unidos 

En los Estados Unidos y el Reino Unido, las comas se pueden usar como separadores de miles. En este ejemplo con 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 europeas de números

En el mayoría de países del mundo, las comas se usan para marcas decimales en lugar de puntos. En este ejemplo con configuración regional francesa, 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.atoi también está disponible, pero el argumento debe ser un número entero.


45
2017-07-23 16:00



Usuarios Codelogic 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 fundir primero para flotar.

Si sus cadenas están en una lista, también podría 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.


22
2017-12-19 02:09



Si no te oponen a los módulos de terceros, puedes consultar Números rápidos módulo. Proporciona una función llamada fast_real eso hace exactamente lo que esta pregunta está pidiendo y lo hace más rápido que una implementación pura de Python:

>>> 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

21
2017-08-14 03:21



En Python, ¿cómo puedo analizar una cadena numérica como "545.2222" con su correspondiente valor flotante, 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, es posible que se esté preparando para problemas posteriores. La respuesta simple es:

"545.2222" flotar:

>>> float("545.2222")
545.2222

"31"a un número entero:

>>> int("31")
31

Otras conversiones, entradas ay desde cadenas y literales:

Conversiones de varias bases, y debe conocer la base por adelantado (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 por adelantado, pero sabe que tendrá el prefijo correcto, Python puede inferir esto por usted si pasa 0 como la base:

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

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

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

Puede usar los prefijos a propósito 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 archivos en código o valores hexadecimales para colores, por ejemplo, no tener citas:

>>> 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 Python 2 octals ambiguos compatibles con Python 3

Si ve un entero que comienza con un 0, en Python 2, esta es la sintaxis octal (obsoleta).

>>> 037
31

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

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

Convierta su Python 2 octals en octals que funcionen tanto en 2 como en 3 con el 0o prefijo:

>>> 0o37
31

17
2017-07-23 13:26