Cómo convertir cadenas numéricas racionales y decimales a flotantes en python?

Question

¿Cómo puedo convertir cadenas que pueden denotar números decimales o racionales a los flotadores

>>> ["0.1234", "1/2"] 
['0.1234', '1/2'] 

me gustaría [0,1234, 0,5].

eval es lo que estaba pensando, pero no hubo suerte:

>>> eval("1/2") 
0 

Answer 1

me gustaría analizar la cadena si falla la conversión:

>>> def convert(s): 
    try: 
     return float(s) 
    except ValueError: 
     num, denom = s.split('/') 
     return float(num)/float(denom) 
... 

>>> convert("0.1234") 
0.1234 

>>> convert("1/2") 
0.5 

generalmente usando eval es una mala idea, ya que es un riesgo para la seguridad. Especialmente si la cadena que se evalúa proviene del exterior del sistema.

Answer 2

El operador / hace la división entera. Proveedores:

>>> eval("1.0*" + "1/2") 
0.5 

Debido eval() es potencialmente peligrosa, siempre se debe comprobar exactamente lo que está pasando en ella:

>>> import re 
>>> s = "1/2" 
>>> if re.match(r"\d+/\d+$", s): 
...  eval("1.0*" + s) 
... 
0.5 

Sin embargo, si vas a la molestia de hacer coincidir la entrada contra una expresión regular en primer lugar, que también podría utilizar r"(\d+)/(\d+)$" para extraer el numerador y el denominador, hacer la división de ti mismo, y evitar por completo eval():

>>> m = re.match(r"(\d+)/(\d+)$", s) 
>>> if m: 
...  float(m.group(1))/float(m.group(2)) 
... 
0.5 

Answer 3

Esto se debe a que Python interpreta 1 y 2 como enteros y no como flotantes. Necesita ser 1.0/2.0 o alguna combinación de eso.

Answer 4

Use from __future__ import division para obtener el comportamiento que desea. Luego, en caso de necesidad, se puede hacer algo como

from __future__ import division 
strings = ["0.1234", "1/2", "2/3"] 
numbers = map(eval, strings) 

para obtener una lista de los flotadores de sus cadenas. Si quiere hacer esto de la manera "correcta", no use eval(), sino que escriba una función que acepte una cadena y llame al float() si no contiene una barra, o analiza la cadena y divide el numerador y el denominador si hay una barra en ella.

Una forma de hacerlo:

def parse_float_string(x) 
    parts = x.split('/', 1) 
    if len(parts) == 1: 
     return float(x) 
    elif len(parts) == 2: 
     return float(parts[0])/float(parts[1]) 
    else: 
     raise ValueError 

A continuación, sólo map(parse_float_string, strings) le conseguirá su lista.

Answer 5

El problema con eval es que, como en python, el cociente de enteros es un número entero. Entonces, tienes varias opciones.

La primera es simplemente para hacer el retorno división entera flota:

from __future__ import division 

La otra es la de dividir el número racional:

reduce(lambda x, y: x*y, map(int, rat_str.split("/")), 1) 

Dónde rat_str es la cadena con un número racional.

Answer 6

Las sugerencias con from __future__ import division combinadas con eval ciertamente funcionarán.

Probablemente vale la pena señalar que las sugerencias que no utilizan eval sino más bien analizar la cadena, lo hacen porque eval es peligroso: si hay alguna manera de una cadena arbitraria que son enviadas a eval, entonces su sistema es vulnerable . Entonces es un mal hábito. (Pero si esto es sólo rápido y código sucio, es probable que no que gran cosa!)

Answer 7

Como otros han señalado, utilizando eval es potencialmente un riesgo para la seguridad, y sin duda un mal hábito para entrar. (si no se piensa que es tan arriesgado como exec, imaginar eval ing algo como: __import__('os').system('rm -rf /'))

Sin embargo, si usted tiene Python 2.6 o arriba, puede utilizar ast.literal_eval, para los que la cadena entregada:

solamente puede consistir en las siguientes estructuras literales Python: cuerdas, números, tuplas, listas, dicts, booleanos, y ninguno.

Por lo tanto, debe ser bastante seguro :-)

Answer 8

Otra opción (también sólo para 2.6 en adelante) es el módulo fractions.

>>> from fractions import Fraction 
>>> Fraction("0.1234") 
Fraction(617, 5000) 
>>> Fraction("1/2") 
Fraction(1, 2) 
>>> float(Fraction("0.1234")) 
0.1234 
>>> float(Fraction("1/2")) 
0.5 

Answer 9

En Python 3, esto debería funcionar.

>>> x = ["0.1234", "1/2"] 
>>> [eval(i) for i in x] 
[0.1234, 0.5] 

Answer 10

sympy puede ayudar a salir aquí:

import sympy 

half = sympy.Rational('1/2') 
p1234 = sympy.Rational('0.1234') 
print '%f, %f" % (half, p1234)