如何将字符串解析为float或int？

#1 楼

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

#2 楼

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

#3 楼

检查字符串是否为浮点数的Python方法：

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

此函数的更长，更准确的名称可能是：is_convertible_to_float(value)

是，而不是Python中的浮点数可能会让您感到惊讶：

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

您认为您知道什么是数字？你不像你想的那样好！不足为奇。

不要在对生命至关重要的软件上使用此代码！

以这种方式捕获广泛的异常，杀死金丝雀并吞噬该异常创造了很小的机会有效浮点数，因为字符串将返回false。 float(...)代码行可能由于数千种与字符串内容无关的原因而失败。但是，如果您使用像Python这样的鸭子式原型语言来编写至关重要的软件，那么您将遇到更大的问题。

#4 楼

这是另一个值得在这里提及的方法ast.literal_eval：


此方法可用于安全地评估包含来自不受信任来源的Python表达式的字符串，而无需自己解析值。


即安全的“评估”

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

#5 楼

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

#6 楼

本地化和逗号

对于float("545,545.2222")之类的引发异常的情况，您应该考虑数字的字符串表示形式中逗号的可能性。相反，请使用locale中的方法将字符串转换为数字并正确解释逗号。一旦为所需的数字约定设置了语言环境，则locale.atof方法将一步转换为浮点型。

示例1-美国数字约定

在美国在英国，逗号可以用作千位分隔符。在具有美国语言环境的此示例中，逗号作为分隔符正确处理：

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

示例2-欧洲数字约定

世界上大多数国家/地区，逗号用于小数点而不是句点。在此使用法语语言环境的示例中，逗号已正确地作为小数点处理： br />

#7 楼

如果您不喜欢第三方模块，则可以签出fastnumbers模块。它提供了一个名为fast_real的函数，该函数可以完全满足此问题的要求，并且比纯Python实现要快：

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

#8 楼

用户codelogic和harley是正确的，但是请记住，如果您知道字符串是整数（例如545），则可以调用int（“ 545”），而无需先强制转换为float。

字符串在列表中，您也可以使用map函数。

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

只有它们都是相同的类型，这才是好的。

#9 楼

在Python中，如何将“ 545.2222”之类的数字字符串解析为其对应的浮点值542.2222？还是将字符串“ 31”解析为整数31？
我只想知道如何将float字符串解析为float，以及将int字符串解析为int。


您最好单独进行这些操作。如果您要混合使用它们，则可能会在以后遇到问题。简单的答案是：

"545.2222"浮点数：

>>> float("545.2222")
545.2222

"31"转换为整数：

>>> int("31")
31

其他转换，以及往返于字符串和文字的整数：

来自各种基础的转换，您应该事先知道基础（默认为10）。请注意，可以为它们加上Python期望的字面量（请参见下文），也可以删除前缀：

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

如果您事先不知道基础，但是您知道它们将具有正确的前缀，如果您通过传递0作为基数，Python可以为您推断该前缀：

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

非十进制（即整数）文字其他基础

如果您的动机是让自己的代码清楚地表示硬编码的特定值，但是，您可能不需要从这些基础进行转换-您可以让Python使用正确的语法。

您可以使用apropos前缀自动转换为具有以下文字的整数。这些对Python 2和3有效：

二进制前缀0b

>>> 0b11111
31

八角形前缀0o

>>> 0o37
31

十六进制，前缀0x

>>> 0x1f
31

这在描述二进制标志，代码中的文件权限或颜色的十六进制值时非常有用-例如，请注意不要使用引号：

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

使模棱两可的Python 2八进制与Python 3兼容

如果您看到一个以a开头的整数0，在Python 2中，这是（不建议使用）八进制语法。

>>> 037
31

这很糟糕，因为看起来值应该是37。因此，在Python 3中，它现在会产生一个SyntaxError：

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

将您的Python 2八进制转换为可以在2和3中使用0o前缀的八进制：

>>> 0o37
31

#10 楼

这个问题似乎有点老了。但是让我建议一个函数parseStr，它的功能类似，即返回整数或浮点数，并且如果给定的ASCII字符串无法转换为其中的任何一个，则它将返回原样。当然，可以将代码调整为仅执行所需的操作：

   >>> 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')
   '12'
   >>> parseStr('12.2.2')
   '12.2.2'

#11 楼

float("545.2222")和int(float("545.2222"))

#12 楼

YAML解析器可以帮助您确定字符串是什么数据类型。使用yaml.load()，然后可以使用type(result)测试类型：

>>> import yaml

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

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

>>> c = "HI"
>>> result = yaml.load(c)
>>> result
'HI'
>>> type(result)
<type 'str'>

#13 楼

我为此使用了该函数

import ast

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

它将字符串转换为其类型

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

#14 楼

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

#15 楼

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

#16 楼

您需要考虑到四舍五入才能正确执行此操作。

即int（5.1）=> 5
int（5.6）=> 5-错误，应该为6所以我们做int（5.6 + 0.5）=> 6

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

#17 楼

我很惊讶没有人提及正则表达式，因为有时在转换为数字之前必须准备字符串并进行规范化

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

用法：

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

顺便说一句，可以验证您的电话号码：

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

#18 楼

要在python中进行类型转换，请使用该类型的构造函数，并将字符串（或您要投射的任何值）作为参数传递。

例如：

>>>float("23.333")
   23.333

在后台，python正在调用对象__float__方法，该方法应返回参数的浮点表示形式。这特别强大，因为您可以使用__float__方法定义自己的类型（使用类），以便可以使用float（myobject）将其转换为float。

#19 楼

将您的字符串传递给此函数：

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)

它将返回int，float或string，具体取决于传递的内容。

是整数的字符串

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

是浮点的字符串

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

/>是字符串的字符串

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

看起来像浮子的字符串

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

#20 楼

这是
https://stackoverflow.com/a/33017514/5973334

的更正版本，它将尝试解析字符串并根据字符串表示的内容返回int或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

#21 楼

处理十六进制，八进制，二进制，十进制和浮点数

此解决方案将处理数字的所有字符串约定（我所知道的全部）。

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)

此测试用例输出说明了我在说什么。

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

这里是测试：

class test_to_number(unittest.TestCase):

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

                 #          HEX
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0xDEADBEEF  , 3735928559), # Hex
                ("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)

#22 楼

使用：

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

这是我想出的最Python化的方法。

#23 楼

用途：

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

#24 楼

此函数将根据提供的实际字符串看起来像object还是str将任何int（而不仅仅是float）转换为int或float。此外，如果它是同时具有__float和__int__方法的对象，则默认使用__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
 

#25 楼

将数字和字符一起使用：

string_for_int = "498 results should get"
string_for_float = "498.45645765 results should get"

首次导入：

 import re

 #for get integer part:
 print(int(re.search(r'\d+', string_for_int).group())) #498

 #for get float part:
 print(float(re.search(r'\d+\.\d+', string_for_float).group())) #498.45645765

用于简单模型：

value1 = "10"
value2 = "10.2"
print(int(value1)) #10
print(float(value2)) #10.2

#26 楼

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

#27 楼

通过使用int和float方法，我们可以将字符串转换为整数和浮点数。

s="45.8"
print(float(s))

y='67'
print(int(y))

#28 楼

代替考虑评估，可以使用以下方法来解决问题。
try-except也可以用作替代方法。尝试在try块中将字符串转换为int。如果字符串是浮点型值，则将引发错误，该错误将在except块中捕获，例如

if '.' in string:
    print(float(string))
else:
    print(int(string))

#29 楼

这是您问题的另一种解释（提示：含糊）。您可能正在寻找这样的东西：

def parseIntOrFloat( aString ):
    return eval( aString )

它的工作原理是这样的...

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

从理论上讲，存在注入漏洞。该字符串可以是例如"import os; os.abort()"。但是，由于没有关于字符串来自何处的任何背景，因此可能是理论上的推测。由于问题很模糊，因此尚不清楚此漏洞是否确实存在。