Python convert percentage number representations to float

Question

Is there an easy way to convert string representations such as "50%" to a float in python? I have data in yaml and am parsing it. I would like to support "0.5" and "50%" as valid representations. So, stripping "%" alone is not enough.

Answer 1

What about:

def parseFloat(str):
    try:
        return float(str)
    except:
        str = str.strip()
        if str.endswith("%"):
            return float(str.strip("%").strip()) / 100
        raise Exception("Don't know how to parse %s" % str)

print(parseFloat("50%"))
print(parseFloat("0.5"))

The code even supports parsing a string that looks like so:

print(parseFloat("  50  % "))

Answer 2

You could convert the string using this:

a = "40.3%"
b = float(a[:-1])/100

Answer 3

Any number sequence in YAML that ends in a percentage sign, will normally be loaded as a string scalar, because the % will not make the scalar match any other pattern (in particular not that of integers or floats). You can of course walk recursively over the data structure loaded from YAML and patch things, but if there are tags in the datastructure, for constructing specific objects, recursing into those is at least non-trivial, if not impossible to do generically.

The best solution would be that your YAML would explicitly state what is a percentage via a tag. E.g.:

a: !Percentage 60%

, where the object loaded from that tag behaves like a the float 0.6. But tags are underused when working with YAML and you don't indicate your input is tagged in such a way.

Fortunately it is not too difficult to setup a parser for percentages in a loader, in the following I will do so for the default RoundTripLoader.

The YAML document in.yaml, to be parsed:

%YAML 1.2
---
a: 60.3%
42%: 'abc'

You can hook into the representer for strings to check if they consist of numbers and end in a percentage sign, but it is faster to add a resolver:

import sys
import re
from pathlib import Path
import ruamel.yaml
from ruamel.yaml.util import RegExp 


ruamel.yaml.resolver.VersionedResolver.add_implicit_resolver(
    u'percentage',
    RegExp(u'''^(?:[-+]?[0-9_]+%
        |[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+]?[0-9]+)?%
        )$''', re.X
    ),
    list(u'-+0123456789.'))


def construct_percentage(self, node):
     value = float(node.value[:-1]) / 100.0
     return value


ruamel.yaml.constructor.RoundTripConstructor.add_constructor(
    u'percentage', construct_percentage
)


yaml = ruamel.yaml.YAML()
data = yaml.load(Path('in.yaml'))
print(dict(data))

which gives:

{'a': 0.603, 0.42: 'abc'}

Please note:

• by default the data is loaded in a subclass of ordereddict, hence the call to dict().
• if you also want to dump the percentages, you should load them as a subclass of float, so they are distinguisable from normal floats when you are going to dump them.
• I intentionally left out the additional formats of ints (hex, octal, etc.) and floats (scientific notation, NaN, etc). They don't make much sense IMO, but they could be re-allowed via the patterns matcher.