#### [SOLVED] How do I parse a string to a float or int?

In Python, how can I parse a numeric string like `"545.2222"` to its corresponding float value, `545.2222`? Or parse the string `"31"` to an integer, `31`?

I just want to know how to parse a float `str` to a `float`, and (separately) an int `str` to an `int`.

#### @Cybernetic 2019-12-10 15:25:36

Pass your string to this function:

``````def string_to_number(str):
if("." in str):
try:
res = float(str)
except:
res = str
elif(str.isdigit()):
res = int(str)
else:
res = str
return(res)
``````

It will return int, float or string depending on what was passed.

string that is an int

``````print(type(string_to_number("124")))
<class 'int'>
``````

string that is a float

``````print(type(string_to_number("12.4")))
<class 'float'>
``````

string that is a string

``````print(type(string_to_number("hello")))
<class 'str'>
``````

string that looks like a float

``````print(type(string_to_number("hel.lo")))
<class 'str'>
``````

#### @shrewmouse 2019-11-22 15:14:34

Handles hex, octal, binary, decimal, and float

This solution will handle all of the string conventions for numbers (all that I know about).

``````def to_number(n):
''' Convert any number representation to a number
This covers: float, decimal, hex, and octal numbers.
'''

try:
return int(str(n), 0)
except:
try:
# python 3 doesn't accept "010" as a valid octal.  You must use the
# '0o' prefix
return int('0o' + n, 0)
except:
return float(n)
``````

This test case output illustrates what I'm talking about.

``````======================== CAPTURED OUTPUT =========================
to_number(3735928559)   = 3735928559 == 3735928559
to_number("0xFEEDFACE") = 4277009102 == 4277009102
to_number("0x0")        =          0 ==          0
to_number(100)          =        100 ==        100
to_number("42")         =         42 ==         42
to_number(8)            =          8 ==          8
to_number("0o20")       =         16 ==         16
to_number("020")        =         16 ==         16
to_number(3.14)         =       3.14 ==       3.14
to_number("2.72")       =       2.72 ==       2.72
to_number("1e3")        =     1000.0 ==       1000
to_number(0.001)        =      0.001 ==      0.001
to_number("0xA")        =         10 ==         10
to_number("012")        =         10 ==         10
to_number("0o12")       =         10 ==         10
to_number("0b01010")    =         10 ==         10
to_number("10")         =         10 ==         10
to_number("10.0")       =       10.0 ==         10
to_number("1e1")        =       10.0 ==         10
``````

Here is the test:

``````class test_to_number(unittest.TestCase):

def test_hex(self):
# All of the following should be converted to an integer
#
values = [

#          HEX
# ----------------------
# Input     |   Expected
# ----------------------
("0xFEEDFACE", 4277009102), # Hex
("0x0"       ,          0), # Hex

#        Decimals
# ----------------------
# Input     |   Expected
# ----------------------
(100         ,        100), # Decimal
("42"        ,         42), # Decimal
]

values += [
#        Octals
# ----------------------
# Input     |   Expected
# ----------------------
(0o10        ,          8), # Octal
("0o20"      ,         16), # Octal
("020"       ,         16), # Octal
]

values += [
#        Floats
# ----------------------
# Input     |   Expected
# ----------------------
(3.14        ,       3.14), # Float
("2.72"      ,       2.72), # Float
("1e3"       ,       1000), # Float
(1e-3        ,      0.001), # Float
]

values += [
#        All ints
# ----------------------
# Input     |   Expected
# ----------------------
("0xA"       ,         10),
("012"       ,         10),
("0o12"      ,         10),
("0b01010"   ,         10),
("10"        ,         10),
("10.0"      ,         10),
("1e1"       ,         10),
]

for _input, expected in values:
value = to_number(_input)

if isinstance(_input, str):
cmd = 'to_number("{}")'.format(_input)
else:
cmd = 'to_number({})'.format(_input)

print("{:23} = {:10} == {:10}".format(cmd, value, expected))
self.assertEqual(value, expected)
``````

#### @Abhishek Bhatia 2019-08-12 09:18:46

This is a function which will convert any `object` (not just `str`) to `int` or `float`, based on if the actual string supplied looks like `int` or `float`. Further if it's an object which has both `__float` and `__int__` methods, it defaults to using `__float__`

``````def conv_to_num(x, num_type='asis'):
'''Converts an object to a number if possible.
num_type: int, float, 'asis'
Defaults to floating point in case of ambiguity.
'''
import numbers

is_num, is_str, is_other = [False]*3

if isinstance(x, numbers.Number):
is_num = True
elif isinstance(x, str):
is_str = True

is_other = not any([is_num, is_str])

if is_num:
res = x
elif is_str:
is_float, is_int, is_char = [False]*3
try:
res = float(x)
if '.' in x:
is_float = True
else:
is_int = True
except ValueError:
res = x
is_char = True

else:
if num_type == 'asis':
funcs = [int, float]
else:
funcs = [num_type]

for func in funcs:
try:
res = func(x)
break
except TypeError:
continue
else:
res = x
``````

#### @Jerry T 2015-10-09 18:04:52

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

## Python method to check if a string is a float:

``````def is_float(value):
try:
float(value)
return True
except:
return False
``````

A longer and more accurate name for this function could be: `is_convertible_to_float(value)`

## What is, and is not a float in Python may surprise you:

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

You think you know what numbers are? You are not so good as you think! Not big surprise.

## Don't use this code on life-critical software!

Catching broad exceptions this way, killing canaries and gobbling the exception creates a tiny chance that a valid float as string will return false. The `float(...)` line of code can failed for any of a thousand reasons that have nothing to do with the contents of the string. But if you're writing life-critical software in a duck-typing prototype language like Python, then you've got much larger problems.

#### @FindOutIslamNow 2018-09-11 06:07:38

So true becomes 1, that is I inherited from C++ i think

#### @Eric Leschinski 2018-12-04 18:48:27

I posted this answer in 2014. That `UTF-8` glyph for a Chinese `4` has been transforming over the years depending on how stackoverflow developers change up their character encoding scheme upon their microsoft toolstack. It's a curiosity to see it flip flop over the years as new conversion schemes assert their new ideologies. But yes, Any `UTF-8` glyph for a Eastern oriental numeric is not a Python float. Bazinga.

#### @E.Serra 2019-03-13 11:38:09

how can this be so upvoted, with such a broad exception?

#### @Simon 2019-08-12 13:43:27

Everything with spaces in between cannot be converted, like `"- 12.3"` and `"45 e6"`

#### @wim 2019-08-31 18:11:46

This except clause should be restricted to `TypeError, ValueError`

#### @CODINGeroo 2018-07-01 20:42:31

To typecast in python use the constructor funtions of the type, passing the string (or whatever value you are trying to cast) as a parameter.

For example:

``````>>>float("23.333")
23.333
``````

Behind the scenes, python is calling the objects `__float__` method, which should return a float representation of the parameter. This is especially powerful, as you can define your own types (using classes) with a `__float__` method so that it can be casted into a float using float(myobject).

#### @Shameem 2017-07-09 08:02:56

I use this function for that

``````import ast

def parse_str(s):
try:
return ast.literal_eval(str(s))
except:
return
``````

It will convert the string to its type

``````value = parse_str('1')  # Returns Integer
value = parse_str('1.5')  # Returns Float
``````

#### @musiphil 2019-05-02 19:37:54

Please be noted that `parse_str(' 1')` (with a space) will return `None`, not `1`.

#### @SethMMorton 2014-08-14 03:21:37

If you aren't averse to third-party modules, you could check out the fastnumbers module. It provides a function called fast_real that does exactly what this question is asking for and does it faster than a pure-Python implementation:

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

#### @Sławomir Lenart 2017-07-12 17:01:41

I am surprised nobody mentioned regex because sometimes string must be prepared and normalized before casting to number

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

usage:

``````parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0
``````

and by the way, something to verify you have a number:

``````import numbers
def is_number(value):
return isinstance(value, numbers.Number)
# will work with int, float, long, Decimal
``````

#### @Totoro 2015-10-08 13:39:08

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

#### @Greg0ry 2016-03-19 20:30:02

Why would you raise in your `except` section if you are doing nothing there? float() would raise for you.

#### @Totoro 2016-11-02 15:18:07

you are right I guess I copied and paste from a functionality that I was raising a particular exception. will edit. thanks

#### @Kuzeko 2017-05-18 07:28:39

This will try to parse a string and return either `int` or `float` depending on what the string represents. It might rise parsing exceptions or [have some unexpected behaviour][1].

#### @Kuzeko 2017-05-18 07:28:27

This is a corrected version of https://stackoverflow.com/a/33017514/5973334

This will try to parse a string and return either `int` or `float` depending on what the string represents. It might rise parsing exceptions or have some unexpected behaviour.

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

#### @Aaron Hall 2015-07-23 13:26:05

In Python, how can I parse a numeric string like "545.2222" to its corresponding float value, 542.2222? Or parse the string "31" to an integer, 31? I just want to know how to parse a float string to a float, and (separately) an int string to an int.

It's good that you ask to do these separately. If you're mixing them, you may be setting yourself up for problems later. The simple answer is:

`"545.2222"` to float:

``````>>> float("545.2222")
545.2222
``````

`"31"` to an integer:

``````>>> int("31")
31
``````

# Other conversions, ints to and from strings and literals:

Conversions from various bases, and you should know the base in advance (10 is the default). Note you can prefix them with what Python expects for its literals (see below) or remove the prefix:

``````>>> int("0b11111", 2)
31
>>> int("11111", 2)
31
>>> int('0o37', 8)
31
>>> int('37', 8)
31
>>> int('0x1f', 16)
31
>>> int('1f', 16)
31
``````

If you don't know the base in advance, but you do know they will have the correct prefix, Python can infer this for you if you pass `0` as the base:

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

### Non-Decimal (i.e. Integer) Literals from other Bases

If your motivation is to have your own code clearly represent hard-coded specific values, however, you may not need to convert from the bases - you can let Python do it for you automatically with the correct syntax.

You can use the apropos prefixes to get automatic conversion to integers with the following literals. These are valid for Python 2 and 3:

Binary, prefix `0b`

``````>>> 0b11111
31
``````

Octal, prefix `0o`

``````>>> 0o37
31
``````

Hexadecimal, prefix `0x`

``````>>> 0x1f
31
``````

This can be useful when describing binary flags, file permissions in code, or hex values for colors - for example, note no quotes:

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

### Making ambiguous Python 2 octals compatible with Python 3

If you see an integer that starts with a 0, in Python 2, this is (deprecated) octal syntax.

``````>>> 037
31
``````

It is bad because it looks like the value should be `37`. So in Python 3, it now raises a `SyntaxError`:

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

Convert your Python 2 octals to octals that work in both 2 and 3 with the `0o` prefix:

``````>>> 0o37
31
``````

#### @user4813927 2016-09-11 14:32:41

Use:

``````>>> str_float = "545.2222"
>>> float(str_float)
545.2222
>>> type(_) # Check its type
<type 'float'>

>>> str_int = "31"
>>> int(str_int)
31
>>> type(_) # Check its type
<type 'int'>
``````

#### @SeasonalShot 2016-10-09 05:40:12

Use:

``````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()
``````

This is the most Pythonic way I could come up with.

#### @musiphil 2019-05-02 19:43:19

The generator stops after the first interpretation of `float`. The `try``catch` block should probably be inside the `for` loop.

## Localization and commas

You should consider the possibility of commas in the string representation of a number, for cases like `float("545,545.2222")` which throws an exception. Instead, use methods in `locale` to convert the strings to numbers and interpret commas correctly. The `locale.atof` method converts to a float in one step once the locale has been set for the desired number convention.

Example 1 -- United States number conventions

In the United States and the UK, commas can be used as a thousands separator. In this example with American locale, the comma is handled properly as a separator:

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

Example 2 -- European number conventions

In the majority of countries of the world, commas are used for decimal marks instead of periods. In this example with French locale, the comma is correctly handled as a decimal mark:

``````>>> import locale
>>> b = u'545,2222'
>>> locale.setlocale(locale.LC_ALL, 'fr_FR')
'fr_FR'
>>> locale.atof(b)
545.2222
``````

The method `locale.atoi` is also available, but the argument should be an integer.

#### @user5359531 2019-01-02 18:33:36

This seems like an ideal solution when you know if a float or int should be returned, but how can you get this to return an int only if an int was passed? For example, `x = '1'; locale.atof(x)` returns `1.0` when I actually want `1`.

#### @user5359531 2019-01-02 18:52:21

Using Dino's method, I guess the answer would be to use something like this: `locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)`

#### @Mark Chackerian 2019-01-02 19:08:05

I would recommend using Javier's method above (wrapping `locale.atoi` in a try and using `locale.atof` on exception -- it's probably more readable.

#### @Rafe 2013-04-16 03:03:11

The YAML parser can help you figure out what datatype your string is. Use `yaml.load()`, and then you can use `type(result)` to test for type:

``````>>> import yaml

>>> a = "545.2222"
>>> result
545.22220000000004
>>> type(result)
<type 'float'>

>>> b = "31"
>>> result
31
>>> type(result)
<type 'int'>

>>> c = "HI"
>>> result
'HI'
>>> type(result)
<type 'str'>
``````

#### @krzym 2011-09-28 19:45:18

The question seems a little bit old. But let me suggest a function, parseStr, which makes something similar, that is, returns integer or float and if a given ASCII string cannot be converted to none of them it returns it untouched. The code of course might be adjusted to do only what you want:

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

#### @Cees Timmerman 2012-10-04 13:24:06

`1e3` is a number in python, but a string according to your code.

#### @S.Lott 2008-12-19 02:29:34

Here's another interpretation of your question (hint: it's vague). It's possible you're looking for something like this:

``````def parseIntOrFloat( aString ):
return eval( aString )
``````

It works like this...

``````>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545
``````

Theoretically, there's an injection vulnerability. The string could, for example be `"import os; os.abort()"`. Without any background on where the string comes from, however, the possibility is theoretical speculation. Since the question is vague, it's not at all clear if this vulnerability actually exists or not.

#### @Cees Timmerman 2012-10-04 13:12:46

Even if his input is 100% safe, `eval()` is over 3 times as slow as `try: int(s) except: float(s)`.

#### @U10-Forward 2018-10-01 01:26:47

Well, `eval` is bad practice (you must know because you have 310k reputation)

#### @user44484 2008-12-19 02:09:03

Users codelogic and harley are correct, but keep in mind if you know the string is an integer (for example, 545) you can call int("545") without first casting to float.

If your strings are in a list, you could use the map function as well.

``````>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>
``````

It is only good if they're all the same type.

#### @Javier 2008-12-19 02:31:23

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

#### @jfs 2012-11-16 14:35:02

implicit mixing floats/ints might lead to subtle bugs due to possible loss of precision when working with floats or to different results for `/` operator on floats/ints. Depending on context it might be preferable to return either int or float, not both.

#### @TimothyAWiseman 2013-03-05 21:29:04

@J.F.Sebastian You are completely correct, but there are times when you want the input to dictate which one it will be. Letting the input dictate which one can work nicely with duck-typing.

#### @iBug 2018-01-25 12:31:32

You can nest another `try` to throw an exception when it's not convertible to float.

#### @Matt Hancock 2018-11-12 01:26:10

Fails with `s = u'\u0000'`

#### @marcelm 2019-02-05 22:43:17

@iBug Good idea! I recommend throwing `ValueError` in the corresponding `except` :P

#### @wim 2012-03-01 04:23:15

This is another method which deserves to be mentioned here, ast.literal_eval:

This can be used for safely evaluating strings containing Python expressions from untrusted sources without the need to parse the values oneself.

That is, a safe 'eval'

``````>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31
``````

#### @royce3 2018-01-16 16:14:39

this is not a good solution to the problem. It works fine in Python 2, but the following happens in Python 3: `python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> ` To clarify why this is a problem, if you want it to leave phone numbers alone and not assume they are mathematical expressions, then this approach is not for you.

#### @wim 2018-01-16 17:57:00

@royce3 Yeah, that's a good point and users should beware. The behaviour was originally modified in order to address some issues with parsing of complex literals. It's arguably a bug in `ast.literal_eval`, and has been discussed here.

#### @Nick 2010-10-21 14:10:01

You need to take into account rounding to do this properly.

I.e. int(5.1) => 5 int(5.6) => 5 -- wrong, should be 6 so we do int(5.6 + 0.5) => 6

``````def convert(n):
try:
return int(n)
except ValueError:
return float(n + 0.5)
``````

#### @Cees Timmerman 2012-10-04 12:58:29

Good point. That causes inflation, though, so Python 3 and other modern languages use banker's rounding.

#### @ToolmakerSteve 2013-12-13 06:02:40

This answer is wrong (as originally written). It muddles the two cases of `int` and `float`. And it will give an exception, when `n` is a string, as OP desired. Maybe you meant: When an `int` result is desired, `round` should be done AFTER conversion to float. If the function should ALWAYS return an int, then you don't need the except part -- the entire function body can be `int(round(float(input)))`. If the function should return an int if possible, otherwise a float, then javier's original solution is correct!

#### @Dino Viehland 2008-12-19 02:32:06

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

#### @Ben G 2011-07-08 11:17:44

Note : be careful when dealing with money amount passed as strings, as some countries use "," as decimal separators

#### @jchl 2011-09-07 10:05:54

@Emile: I wouldn't call "2e-3" an "extreme case". This answer is just broken.

#### @ToolmakerSteve 2013-12-13 06:10:15

@BenG DON'T manipulate money as a float. That's asking for trouble. Use decimal for money! (But your comment about ',' is still valid and important)

Don't forget that "not a number" (NaN) and +/- infinity is also valid float values. So `float("nan")` is a perfectly valid float value that the above answer wouldn't catch at all

#### @Todor Minakov 2019-01-13 19:47:15

Easily breakable by an IP address - `192.168.0.1`; or `"This is not a good approach. :)"`

#### @Harley Holcombe 2008-12-19 01:54:51

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

#### @Mangat Rai Modi 2017-08-17 15:25:30

just wondering why there is '04' in the end? why not simply '00'? also my current version of python is not having '04'.

#### @dokkaebi 2017-08-18 21:44:18

@MangatRaiModi Floating point numbers are inherently imperfect for representing decimals. For more, see stackoverflow.com/q/21895756/931277

#### @formerlyknownas_463035818 2018-04-26 14:36:28

why not simply `int(a)` but `int(float(a))` ?

#### @David Parks 2018-05-07 17:46:13

`int(a)` will give an error that the string isn't a valid integer: `ValueError: invalid literal for int() with base 10: '545.222'`, but converting from a float to an int is a supported conversion.

#### @Joe Bobson 2018-09-09 13:20:43

You should handle `ValueError` if you want to be safe

#### @gaozhidf 2019-07-03 09:57:53

`return int(a) if float(a) == int(float(a)) else float(a)`

#### @plugwash 2019-08-22 03:04:48

@MangatRaiModi python changed it's rounding policy for floating point numbers a while back, it used to use a fixed number of digits, now it uses the "shortest round trip" representation.

#### @codelogic 2008-12-19 01:54:11

`float("545.2222")` and `int(float("545.2222"))`

#### @Brian 2008-12-19 08:42:49

This will give you a float object if your string happens to be "0" or "0.0", rather than the int it gives for other valid numbers.

### [SOLVED] How to print without newline or space?

• 2009-01-29 20:58:25
• Andrea Ambu
• 1797670 View
• 1796 Score
• Tags:   python newline

### [SOLVED] Calling a function of a module by using its name (a string)

• 2008-08-06 03:36:08
• ricree
• 651023 View
• 1629 Score
• Tags:   python object