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

在Python中，如何将像

“545.2222”

这样的数字字符串解析为其相应的浮点值

545.2222

？或者将字符串

“31”

解析为整数，

31

我只想知道如何将一个float

str

解析为一个

float

，以及（分别）一个int

str

解析为一个

int

，

float（“545.2222”）

float（“545.2222”）

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

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

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

---

只有当它们都是同一类型时才是好的。

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

def parseIntOrFloat( aString ):
    return eval( aString )

它是这样工作的

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

---

---

理论上，存在注入漏洞。例如，字符串可以是

“import os；os.abort（）”

。然而，在没有任何关于字符串来源的背景下，这种可能性只是理论上的推测。由于问题不明确，因此根本不清楚此漏洞是否确实存在。

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

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

即int（5.1）=>5 int（5.6）=>5——错了，应该是6，所以我们做int（5.6+0.5）=>6

---

这个问题似乎有点老了。但我建议使用一个函数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$5')
   '12$5'
   >>> parseStr('12.2.2')
   '12.2.2'

---

这是另一种值得在此提及的方法：

这可以用于安全地计算包含来自不受信任源的Python表达式的字符串，而无需自己解析值

也就是说，安全的“评估”

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

解析器可以帮助您确定字符串的数据类型。使用

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

>>导入yaml
>>>a=“545.2222”
>>>结果=yaml.荷载（a）
>>>结果
545.22220000000004
>>>类型（结果）
>>>b=“31”
>>>结果=yaml.荷载（b）
>>>结果
31
>>>类型（结果）
>>>c=“你好”
>>>结果=yaml.荷载（c）
>>>结果
“嗨”
>>>类型（结果）

本地化和逗号

您应该考虑一个数字的字符串表示中逗号的可能性，例如像代码>浮点（“545545.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——欧洲数字惯例

在中，逗号用于小数点而不是句点。在本例中，使用法语区域设置时，逗号被正确处理为十进制标记：

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

方法

locale.atoi

也可用，但参数应为整数。

检查字符串是否为浮点的Python方法： 此函数的更长更准确的名称可以是：

is\u convertible\u to\u float（value）

什么是浮动，什么不是浮动可能会让你感到惊讶： 你以为你知道数字是什么？你没有你想象的那么好！没什么好惊讶的

不要在生命关键型软件上使用此代码！

---

通过这种方式捕获广泛的异常，杀死金丝雀并吞食异常会产生一个很小的机会，即有效的float-as-string返回false。

float（…）

代码行可能由于与字符串内容无关的一千个原因中的任何一个而失败。但是，如果您正在用Python之类的原型语言编写生命关键型软件，那么您就会遇到更大的问题。

如果您不反对第三方模块，您可以查看该模块。它提供了一个名为的函数，该函数完全满足此问题的要求，并且比纯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

在Python中，如何将像“545.2222”这样的数字字符串解析为其对应的浮点值542.2222？或者将字符串“31”解析为整数31？ 我只想知道如何将浮点字符串解析为浮点，以及（分别）将int字符串解析为int

你要求分开做这些是很好的。如果你把它们混在一起，你可能会为以后的问题做好准备。答案很简单：

“545.2222”

浮动：

>>> float("545.2222")
545.2222

>>> int("31")
31

“31”

转换为整数：

>>> float("545.2222")
545.2222

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

>>> 0o37
31

十六进制，前缀

0x

>>> 0x1f
31

这在描述二进制标志、co中的文件权限时非常有用

>>> 0o37
31

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

>>> 037
31

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

>>> 0o37
31

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

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

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

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

  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

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

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

>>>float("23.333")
   23.333

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)

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)

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

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

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

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