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

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

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

如果你的字符串在列表中，你也可以使用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)

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

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

即 - => 5 => 5 -- 错误，应该是 6，所以我们这样做 => 6int(5.1)int(5.6)int(5.6 + 0.5)

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

这个问题似乎有点老了。但是让我建议一个函数 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'

这里值得一提的另一种方法是ast.literal_eval：

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

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

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

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

本地化和逗号

您应该考虑数字的字符串表示形式中逗号的可能性，例如引发异常的情况。相反，请使用 中的方法来将字符串转换为数字并正确解释逗号。一旦为所需的数字约定设置了区域设置，该方法将在一步中转换为浮点数。float("545,545.2222")localelocale.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

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

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

对于 is_float 的 Python3 版本，请参阅：在 Python 中检查字符串是否可以转换为浮点数

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

Python 中什么是浮点数，什么不是浮点数可能会让你大吃一惊：

以下单元测试是使用 python2 完成的。检查 Python3 对于哪些字符串可以转换为浮点数具有不同的行为。一个令人困惑的区别是，现在允许使用任意数量的内部下划线：is True(float("1_3.4") == float(13.4))

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_2_3.4"             False        Underscores not allowed
"12 34"               False        Spaces not allowed on interior
"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。代码行可能由于与字符串内容无关的一千种原因中的任何一种而失败。但是，如果你用像 Python 这样的鸭子类型原型语言编写生命攸关的软件，那么你就会遇到更大的问题。float(...)

如果您不反对第三方模块，可以查看 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

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

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

“545.2222”浮动：

>>> float("545.2222")
545.2222

“31”转换为整数：

>>> int("31")
31

其他转换，ints 到字符串和文字：

来自各种基数的转换，您应该提前知道基数（默认值为 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

如果你事先不知道基数，但你确实知道它们将具有正确的前缀，如果你作为基数传递，Python 可以为你推断出这一点：0

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

如果您在 Python 2 中看到以 0 开头的整数，则这是（已弃用的）八进制语法。

>>> 037
31

这很糟糕，因为它看起来值应该是 .所以在 Python 3 中，它现在会引发一个：37SyntaxError

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

将 Python 2 八进制转换为在 2 和 3 中都有效的八进制，前缀为：0o

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

这是我能想到的最 Python 的方式。

这是龙猫答案的更正版本。

这将尝试解析字符串并返回 either 或 取决于字符串所代表的内容。它可能会上升解析异常或出现一些意外行为。intfloat

  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

在 Python 中使用该类型的构造函数，将字符串（或您尝试转换的任何值）作为参数传递。typecast

例如：

>>>float("23.333")
   23.333

在幕后，Python 正在调用 objects 方法，该方法应返回参数的浮点表示形式。这特别强大，因为您可以使用方法定义自己的类型（使用类），以便可以使用 将其转换为浮点数。__float____float__float(myobject)

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

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

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

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)

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

int 字符串

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

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

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 getting the integer part:
 print(int(re.search(r'\d+', string_for_int).group())) #498

 # For getting the 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

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

如果您正在处理混合整数和浮点数，并且想要一种一致的方式来处理混合数据，以下是我使用正确文档字符串的解决方案：

def parse_num(candidate):
    """Parse string to number if possible
    It work equally well with negative and positive numbers, integers and floats.

    Args:
        candidate (str): string to convert

    Returns:
        float | int | None: float or int if possible otherwise None
    """
    try:
        float_value = float(candidate)
    except ValueError:
        return None

    # Optional part if you prefer int to float when decimal part is 0
    if float_value.is_integer():
        return int(float_value)
    # end of the optional part

    return float_value

# Test
candidates = ['34.77', '-13', 'jh', '8990', '76_3234_54']
res_list = list(map(parse_num, candidates))
print('Before:')
print(candidates)
print('After:')
print(res_list)

输出：

Before:
['34.77', '-13', 'jh', '8990', '76_3234_54']

After:
[34.77, -13, None, 8990, 76323454]

您可以使用：json.loads

>>> import json
>>> json.loads('123.456')
123.456
>>> type(_)
<class 'float'>
>>> 

正如你所看到的，它变成了一种 .float

如果您不想使用第三方模块，以下可能是最可靠的解决方案：

def string_to_int_or_float(s):
    try:
        f = float(s) # replace s with str(s) if you are not sure that s is a string
    except ValueError:
        print("Provided string '" + s + "' is not interpretable as a literal number.")
        raise
    try:
        i = int(str(f).rstrip('0').rstrip('.'))
    except:
        return f
    return i

它可能不是最快的，但它可以正确处理许多其他解决方案失败的文字数字，例如：

>>> string_to_int_or_float('789.')
789
>>> string_to_int_or_float('789.0')
789
>>> string_to_int_or_float('12.3e2')
1230
>>> string_to_int_or_float('12.3e-2')
0.123
>>> string_to_int_or_float('4560e-1')
456
>>> string_to_int_or_float('4560e-2')
45.6

您可以简单地通过以下方式做到这一点

s = '542.22'

f = float(s) # This converts string data to float data with a decimal point
print(f) 

i = int(f) # This converts string data to integer data by just taking the whole number part of it
print(i) 

有关解析数据类型的更多信息，请查看 python 文档！

如果要将类型更改为其他数据类型，则可以使用显式类型转换，我的意思是必须用于将字符串类型更改为类型并将其更改为类型。int()integerfloat()float

但是，如果我们了解类型转换的概念，我们会意识到，作为程序员，类型转换并不是一个好的选择，除非有必要，因此我们应该只在需要类型转换的情况下使用类型转换，例如当您使用输入函数输入用户输入值时。

额外提示：您还可以使用类型转换将 s 更改为 s，然后将它们转换回 s，因此您可以对不可变数据类型 a 进行更改（并且是各自的函数）。tuplelisttupletuplelist()tuple()