首页 文章

检查字符串是否可以在Python中转换为float

提问于
浏览 次
130

我有一些Python代码通过一个字符串列表运行，如果可能的话将它们转换为整数或浮点数 . 对整数执行此操作非常简单

if element.isdigit():
  newelement = int(element)

浮点数更难 . 现在我正在使用 partition('.') 拆分字符串并检查以确保一侧或两侧都是数字 .

partition = element.partition('.')
if (partition[0].isdigit() and partition[1] == '.' and partition[2].isdigit()) 
    or (partition[0] == '' and partition[1] == '.' and partition[2].isdigit()) 
    or (partition[0].isdigit() and partition[1] == '.' and partition[2] == ''):
  newelement = float(element)

这是有效的，但显然if语句有点像熊 . 我考虑的另一个解决方案是将转换包装在try / catch块中，看看它是否成功，如this question中所述 .

有没有其他想法？关于分区和try / catch方法的相对优点的意见？

python string type-conversion

13 回答

  • 5

    我会用...

    try:
    float(element)
except ValueError:
    print "Not a float"

    ..它很简单，而且很有效

    另一种选择是正则表达式：

    import re
if re.match("^\d+?\.\d+?$", element) is None:
    print "Not float"
    回复于
  • 1

    用于检查float的Python方法：

    def isfloat(value):
  try:
    float(value)
    return True
  except ValueError:
    return False

    不要被隐藏在浮船中的地精弄掉！做单位测试！

    什么是，而不是浮动可能会让你感到惊讶：

    Command to parse                        Is it a float?  Comment
--------------------------------------  --------------- ------------
print(isfloat(""))                      False
print(isfloat("1234567"))               True 
print(isfloat("NaN"))                   True            nan is also float
print(isfloat("NaNananana BATMAN"))     False
print(isfloat("123.456"))               True
print(isfloat("123.E4"))                True
print(isfloat(".1"))                    True
print(isfloat("1,234"))                 False
print(isfloat("NULL"))                  False           case insensitive
print(isfloat(",1"))                    False           
print(isfloat("123.EE4"))               False           
print(isfloat("6.523537535629999e-07")) True
print(isfloat("6e777777"))              True            This is same as Inf
print(isfloat("-iNF"))                  True
print(isfloat("1.797693e+308"))         True
print(isfloat("infinity"))              True
print(isfloat("infinity and BEYOND"))   False
print(isfloat("12.34.56"))              False           Two dots not allowed.
print(isfloat("#56"))                   False
print(isfloat("56%"))                   False
print(isfloat("0E0"))                   True
print(isfloat("x86E0"))                 False
print(isfloat("86-5"))                  False
print(isfloat("True"))                  False           Boolean is not a float.   
print(isfloat(True))                    True            Boolean is a float
print(isfloat("+1e1^5"))                False
print(isfloat("+1e1"))                  True
print(isfloat("+1e1.3"))                False
print(isfloat("+1.3P1"))                False
print(isfloat("-+1"))                   False
print(isfloat("(1)"))                   False           brackets not interpreted
    回复于
  • 4
    '1.43'.replace('.','',1).isdigit()

    只有在数字字符串中有一个或没有'.'时才会返回 true .

    '1.4.3'.replace('.','',1).isdigit()

    将返回 false

    '1.ww'.replace('.','',1).isdigit()

    将返回 false

    回复于
  • 5

    如果你关心性能（我不建议你应该这样做），基于尝试的方法是明显的赢家（与基于分区的方法或正则表达式方法相比），只要你不期望很多无效字符串，在这种情况下它可能更慢（可能是由于异常处理的成本） .

    同样，我并不是建议你关心性能，只是在你每秒100亿次这样做的情况下给你数据 . 此外，基于分区的代码不处理至少一个有效字符串 .

    $ ./floatstr.py
F..
partition sad: 3.1102449894
partition happy: 2.09208488464
..
re sad: 7.76906108856
re happy: 7.09421992302
..
try sad: 12.1525540352
try happy: 1.44165301323
.
======================================================================
FAIL: test_partition (__main__.ConvertTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./floatstr.py", line 48, in test_partition
    self.failUnless(is_float_partition("20e2"))
AssertionError

----------------------------------------------------------------------
Ran 8 tests in 33.670s

FAILED (failures=1)

    这里's the code (Python 2.6, regexp taken from John Gietzen' s answer）：

    def is_float_try(str):
    try:
        float(str)
        return True
    except ValueError:
        return False

import re
_float_regexp = re.compile(r"^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$")
def is_float_re(str):
    return re.match(_float_regexp, str)


def is_float_partition(element):
    partition=element.partition('.')
    if (partition[0].isdigit() and partition[1]=='.' and partition[2].isdigit()) or (partition[0]=='' and partition[1]=='.' and pa\
rtition[2].isdigit()) or (partition[0].isdigit() and partition[1]=='.' and partition[2]==''):
        return True

if __name__ == '__main__':
    import unittest
    import timeit

    class ConvertTests(unittest.TestCase):
        def test_re(self):
            self.failUnless(is_float_re("20e2"))

        def test_try(self):
            self.failUnless(is_float_try("20e2"))

        def test_re_perf(self):
            print
            print 're sad:', timeit.Timer('floatstr.is_float_re("12.2x")', "import floatstr").timeit()
            print 're happy:', timeit.Timer('floatstr.is_float_re("12.2")', "import floatstr").timeit()

        def test_try_perf(self):
            print
            print 'try sad:', timeit.Timer('floatstr.is_float_try("12.2x")', "import floatstr").timeit()
            print 'try happy:', timeit.Timer('floatstr.is_float_try("12.2")', "import floatstr").timeit()

        def test_partition_perf(self):
            print
            print 'partition sad:', timeit.Timer('floatstr.is_float_partition("12.2x")', "import floatstr").timeit()
            print 'partition happy:', timeit.Timer('floatstr.is_float_partition("12.2")', "import floatstr").timeit()

        def test_partition(self):
            self.failUnless(is_float_partition("20e2"))

        def test_partition2(self):
            self.failUnless(is_float_partition(".2"))

        def test_partition3(self):
            self.failIf(is_float_partition("1234x.2"))

    unittest.main()
    回复于
  • 1

    TL;DR ：

    • 如果您的输入主要是可以转换为浮点数的字符串， try: except: 方法是最好的本机Python方法 .

    • 如果您的输入主要是无法转换为浮点数的字符串，则正则表达式或分区方法会更好 .

    • 如果您1）不确定您的输入或需要更高的速度2）不介意并且可以安装第三方C扩展，fastnumbers非常有效 .

    通过名为fastnumbers的第三方模块可以使用另一种方法（披露，我是作者）;它提供了一个名为isfloat的函数 . 我在this answer中采用了Jacob Gabrielson概述的单元测试示例，但添加了 fastnumbers.isfloat 方法 . 我还应该注意到雅各布的例子并没有对正则表达式选项做出正确的判断，因为该例子中的大部分时间都花在了全局查找上，因为点运算符......我修改了这个函数，以便与 try: except: 进行更公平的比较 .

    def is_float_try(str):
    try:
        float(str)
        return True
    except ValueError:
        return False

import re
_float_regexp = re.compile(r"^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$").match
def is_float_re(str):
    return True if _float_regexp(str) else False

def is_float_partition(element):
    partition=element.partition('.')
    if (partition[0].isdigit() and partition[1]=='.' and partition[2].isdigit()) or (partition[0]=='' and partition[1]=='.' and partition[2].isdigit()) or (partition[0].isdigit() and partition[1]=='.' and partition[2]==''):
        return True
    else:
        return False

from fastnumbers import isfloat


if __name__ == '__main__':
    import unittest
    import timeit

    class ConvertTests(unittest.TestCase):

        def test_re_perf(self):
            print
            print 're sad:', timeit.Timer('ttest.is_float_re("12.2x")', "import ttest").timeit()
            print 're happy:', timeit.Timer('ttest.is_float_re("12.2")', "import ttest").timeit()

        def test_try_perf(self):
            print
            print 'try sad:', timeit.Timer('ttest.is_float_try("12.2x")', "import ttest").timeit()
            print 'try happy:', timeit.Timer('ttest.is_float_try("12.2")', "import ttest").timeit()

        def test_fn_perf(self):
            print
            print 'fn sad:', timeit.Timer('ttest.isfloat("12.2x")', "import ttest").timeit()
            print 'fn happy:', timeit.Timer('ttest.isfloat("12.2")', "import ttest").timeit()


        def test_part_perf(self):
            print
            print 'part sad:', timeit.Timer('ttest.is_float_partition("12.2x")', "import ttest").timeit()
            print 'part happy:', timeit.Timer('ttest.is_float_partition("12.2")', "import ttest").timeit()

    unittest.main()

    在我的机器上，输出是：

    fn sad: 0.220988988876
fn happy: 0.212214946747
.
part sad: 1.2219619751
part happy: 0.754667043686
.
re sad: 1.50515985489
re happy: 1.01107215881
.
try sad: 2.40243887901
try happy: 0.425730228424
.
----------------------------------------------------------------------
Ran 4 tests in 7.761s

OK

    正如你所看到的，正则表达式实际上并没有它最初看起来那么糟糕，如果你真的需要速度，那么 fastnumbers 方法就相当不错了 .

    回复于
  • 142

    只是为了变化，这是另一种方法 .

    >>> all([i.isnumeric() for i in '1.2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2.f'.split('.',1)])
False

    编辑：我确定它不会阻止浮动的所有情况，尤其是当有指数时 . 解决它看起来像这样 . 这将返回True只有val是一个浮点数，而假的是int，但可能性能低于正则表达式 .

    >>> def isfloat(val):
...     return all([ [any([i.isnumeric(), i in ['.','e']]) for i in val],  len(val.split('.')) == 2] )
...
>>> isfloat('1')
False
>>> isfloat('1.2')
True
>>> isfloat('1.2e3')
True
>>> isfloat('12e3')
False
    回复于
  • 11

    这个正则表达式将检查科学浮点数：

    ^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$

    但是，我相信你最好的选择是尝试使用解析器 .

    回复于
  • 0

    如果您不需要担心数字的科学或其他表达方式，并且只使用可能是带或不带句点的数字的字符串：

    Function

    def is_float(s):
    result = False
    if s.count(".") == 1:
        if s.replace(".", "").isdigit():
            result = True
    return result

    Lambda version

    is_float = lambda x: x.replace('.','',1).isdigit() and "." in x

    Example

    if is_float(some_string):
    some_string = float(some_string)
elif some_string.isdigit():
    some_string = int(some_string)
else:
    print "Does not convert to int or float."

    这样你就不会意外地将应该是int的东西转换成浮点数 .

    回复于
  • 0

    我使用了已经提到的功能，但很快我注意到字符串为“Nan”，“Inf”，它的变化被认为是数字 . 所以我建议你改进版本的函数，它将在这些类型的输入上返回false并且不会失败“1e3”变体：

    def is_float(text):
    # check for nan/infinity etc.
    if text.isalpha():
        return False
    try:
        float(text)
        return True
    except ValueError:
        return False
    回复于
  • 2

    尝试转换为float . 如果出现错误，请打印ValueError异常 .

    try:
    x = float('1.23')
    print('val=',x)
    y = float('abc')
    print('val=',y)
except ValueError as err:
    print('floatErr;',err)

    输出：

    val= 1.23
floatErr: could not convert string to float: 'abc'
    回复于
  • 2

    我正在寻找一些类似的代码，但看起来使用try / excepts是最好的方法 . 这是我正在使用的代码 . 如果输入无效，它包括重试功能 . 我需要检查输入是否大于0和如果是这样将它转换为浮点数 .

    def cleanInput(question,retry=False): 
    inputValue = input("\n\nOnly positive numbers can be entered, please re-enter the value.\n\n{}".format(question)) if retry else input(question)
    try:
        if float(inputValue) <= 0 : raise ValueError()
        else : return(float(inputValue))
    except ValueError : return(cleanInput(question,retry=True))


willbefloat = cleanInput("Give me the number: ")
    回复于
  • 225
    str(strval).isdigit()

    似乎很简单 .

    处理以字符串或int或float存储的值

    回复于
  • 0

    Simplified version of the function is_digit(str) ，在大多数情况下都足够了（不考虑指数表示法和"NaN"值）：

    def is_digit(str):
    return str.lstrip('-').replace('.', '').isdigit()
    回复于

相关问题