¿Cómo puedo analizar una cadena a un flotador o int en Python?

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

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

 >>> a = "545.2222" >>> float(a) 545.22220000000004 >>> int(float(a)) 545 
 def num(s): try: return int(s) except ValueError: return float(s) 

Método de Python para verificar si una cadena es una flotación:

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

 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 gran sorpresa.

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 fonts no confiables sin la necesidad de analizar los valores uno mismo.

Es decir, una ‘eval’ segura.

 >>> import ast >>> ast.literal_eval("545.2222") 545.2222 >>> ast.literal_eval("31") 31 
 float(x) if '.' in x else int(x) 

Localización y comas

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

Ejemplo 1 – Convenciones de número de Estados Unidos

En los Estados Unidos y el Reino Unido, las comas se pueden usar como separadores de miles. En este ejemplo con la configuración regional estadounidense, la coma se maneja correctamente como 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 usan para los decimales en lugar de los puntos. En este ejemplo con la 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 entero.

Los usuarios codelogic y harley son correctos, pero ten en cuenta que si sabes que la cadena es un número entero (por ejemplo, 545), puedes llamar a int (“545”) sin lanzar primero a float.

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.

Si no es reacio a los módulos de terceros, puede revisar el módulo de números rápidos . Proporciona una función llamada fast_real que hace exactamente lo que esta pregunta está haciendo 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 

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 a ninguna de ellas, la devuelve sin tocar. El código, por supuesto, podría ajustarse para hacer solo lo que usted quiere:

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

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 float a una float, y (por separado) una cadena int a un int.

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

"545.2222" para flotar:

 >>> float("545.2222") 545.2222 

"31" a un número entero:

 >>> int("31") 31 

Otras conversiones, ints hacia y desde cadenas y literales:

Conversiones de varias bases, y usted debe saber la base por adelantado (10 es el valor predeterminado). Tenga en cuenta que puede prefijarlos con lo que Python espera para sus literales (ver más abajo) 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án el prefijo correcto, Python puede deducir esto 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 que su propio código represente valores específicos codificados de manera rígida, es posible que no necesite realizar la conversión desde las bases; puede dejar que Python lo haga automáticamente con la syntax correcta.

Puede utilizar los prefijos apropiados 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 cuando se describen banderas binarias, permisos de archivo en el código o valores hexadecimales para los colores; por ejemplo, no tenga 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 ambiguos Python 2 octales compatibles con Python 3

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

 >>> 037 31 

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

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

Convierta sus octales de Python 2 a octales que funcionen tanto en 2 como en 3 con el prefijo 0o :

 >>> 0o37 31 

float("545.2222") e int(float("545.2222"))

El analizador de YAML puede ayudarte a descubrir qué tipo de datos es tu 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)  >>> b = "31" >>> result = yaml.load(b) >>> result 31 >>> type(result)  >>> c = "HI" >>> result = yaml.load(c) >>> result 'HI' >>> type(result)  

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

Es necesario tener en cuenta el redondeo para hacer esto correctamente.

Es decir, int (5.1) => 5 int (5.6) => 5 – incorrecto, debería ser 6, así que hacemos int (5.6 + 0.5) => 6

 def convert(n): try: return int(n) except ValueError: return float(n + 0.5) 
 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') 

Me sorprende que nadie haya mencionado la expresión regular porque a veces la cadena debe estar preparada y normalizada antes de lanzar el 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 

Python tiene esta gran flexibilidad de análisis en una sola línea.

 str = "545.2222" print ("int: ", + int(float(a))) print ("float: ", +(float(a))) 

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

Por ejemplo:

 >>>float("23.333") 23.333 

Detrás de las escenas, python está llamando al método __float__ 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 método __float__ para que pueda convertirse en un flotador usando float (myobject).

Esta es una versión corregida de https://stackoverflow.com/a/33017514/5973334

Esto intentará analizar una cadena y devolver int o float dependiendo de lo que representa la cadena. Puede boost las excepciones de análisis o tener algún comportamiento inesperado .

  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 

Puede usar str() para convertir cualquier variable en cadena, int() para convertir enteros de cadena en enteros y float() para convertir números flotantes de cadena en valor flotante.

 str_to_float = float("545.2222") str_to_int = int("31") 

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 pythonica que se me ocurre.

Utilizar:

 >>> str_float = "545.2222" >>> float(str_float) 545.2222 >>> type(_) # Check its type  >>> str_int = "31" >>> int(str_int) 31 >>> type(_) # Check its type  

Si conoces el str puede ser solo int o float:

 return int(s) if s.isdigit() else float(s) 

Aquí hay otra interpretación de su pregunta (pista: es vaga). 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 

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