Convertir la fraction en flotteur?

Genre de comme cette questionmais dans le sens inverse.

Donné une chaîne de caractères comme 11/2ou 1 2/3quelle est la meilleure façon de le convertir en un float? Je suis en train de réfléchir à l'aide de regexes au cas par cas, mais peut-être que quelqu'un connaît une meilleure façon, ou d'une pré-solution existante. J'espérais que je pourrais simplement utiliser evalmais je pense que le 3ème cas l'en empêche.

source d'informationauteur mpen | 2009-11-27

  1. 28

    peut-être quelque chose comme ceci (2.6+)

    from fractions import Fraction
float(sum(Fraction(s) for s in '1 2/3'.split()))
  2. 6

    J'ai modifié James répondre un peu.

    def convert_to_float(frac_str):
    try:
        return float(frac_str)
    except ValueError:
        num, denom = frac_str.split('/')
        try:
            leading, num = num.split(' ')
            whole = float(leading)
        except ValueError:
            whole = 0
        frac = float(num) / float(denom)
        return whole - frac if whole < 0 else whole + frac


print convert_to_float('3') # 3.0
print convert_to_float('3/2') # 1.5
print convert_to_float('1 1/2') # 1.5
print convert_to_float('-1 1/2') # -1.5

    http://ideone.com/ItifKv

  3. 5

    Bien que vous devriez tsar clair de eval complètement. Peut-être certains version plus raffinée de:

    num,den = s.split( '/' )
wh, num = num.split()
result = wh + (float(num)/float(den))

    Désolé, destiné à être num.split s pas.split, et jette. Édité.

  4. 3

    Je vois, il y a déjà plusieurs bonnes réponses ici, mais j'ai eu de la chance avec cette. Il a également l'avantage qu'il tolère les non-fraction des chaînes si vous êtes l'analyse mixte des ensembles de données, il n'ya donc pas besoin de vérifier si c'est une fraction de la chaîne ou non à l'avance.

    def convert_to_float(frac_str):
    try:
        return float(frac_str)
    except ValueError:
        try:
            num, denom = frac_str.split('/')
        except ValueError:
            return None
        try:
            leading, num = num.split(' ')
        except ValueError:
            return float(num) / float(denom)        
        if float(leading) < 0:
            sign_mult = -1
        else:
            sign_mult = 1
        return float(leading) + sign_mult * (float(num) / float(denom))
    >>> convert_to_float('3')
3.0
>>> convert_to_float('1/4')
0.25
>>> convert_to_float('1 2/3')
1.6666666666666665
>>> convert_to_float('-2/3')
-0.6666666666666666
>>> convert_to_float('-3 1/2')
-3.5
  5. 2

    Qui pourrait être un sale solution de contournement, mais vous pouvez convertir les espaces en un + signe de résoudre le 3ème cas (ou à un - si votre fraction est négatif).

  6. 2
    def fractionToFloat(fraction):

    num = 0
    mult = 1

    if fraction[:1] == "-":
        fraction = fraction[1:]     
        mult = -1

    if " " in fraction:
        a = fraction.split(" ")
        num = float(a[0])
        toSplit = a[1]
    else:
        toSplit = fraction

    frac = toSplit.split("/")
    num += float(frac[0]) / float(frac[1])

    return num * mult

    Il peut également gérer "2 1/1e-8", "-1/3" et "1/5e3".

  7. 1

    Cette mise en œuvre permet d'éviter d'utiliser eval et travaille sur les pré-versions 2.6 de Python.

    # matches a string consting of an integer followed by either a divisor
# ("/" and an integer) or some spaces and a simple fraction (two integers
# separated by "/")
FRACTION_REGEX = re.compile(r'^(\d+)(?:(?:\s+(\d+))?/(\d+))?$')

def parse(x):
  i, n, d = FRACTION_REGEX.match(x).groups()
  if d is None: return i  # if d is None, then n is also None
  if n is None: i, n = 0, i
  return float(i) + float(n) / float(d)

    À tester:

    >>> for x in ['1', '1/2', '1 2/3']: print parse(x)
... 
1
0.5
1.66666666667
  8. 0

    En fonction de ce que la syntaxe que vous voulez prendre en charge pour votre fractions, eval('+'.join(s.split())) (avec de la vraie division en place -- c'est à dire, Python 3 ou from __future__ import division en Python 2, force de travail. Il serait de couvrir tous les cas que vous citez, en particulier.

  9. 0
    >>> s="1/2"
>>> eval('/'.join(map(str,map(float,s.split("/")))))
0.5

>>> s="3/5"
>>> eval('/'.join(map(str,map(float,s.split("/")))))
0.59999999999999998