Проверка возможности преобразования строки в число с плавающей запятой в Python

я бы просто воспользовалась..

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

.. это просто, и это работает. Обратите внимание, что он по-прежнему будет вызывать OverflowError, если элемент, например. 1‹‹1024.

Другим вариантом может быть регулярное выражение:

import re
if re.match(r'^-?\d+(?:\.\d+)$', element) is None:
    print "Not 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

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

который вернет true только в том случае, если есть один или нет '.' в строке цифр.

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

вернет false

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

вернется false

TL;DR:

• Если вы вводите в основном строки, которые можно преобразовать в числа с плавающей запятой, метод try: except: — лучший собственный метод Python.
• Если вы вводите в основном строки, которые нельзя преобразовать в числа с плавающей запятой, лучше использовать регулярные выражения или метод разделения.
• Если вы 1) не уверены в своем вводе или вам нужно больше скорости и 2) не возражаете и можете установить стороннее расширение C, fastnumbers работает очень хорошо.

Существует еще один метод, доступный через сторонний модуль под названием fastnumbers (раскрытие информации, я автор); он предоставляет функцию под названием isfloat. Я взял пример unittest, описанный Джейкобом Габриэлсоном в этом ответе, но добавил метод 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 вполне подойдет.

Просто для разнообразия вот еще один способ сделать это.

>>> 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 является числом с плавающей запятой и False для 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

Если вы заботитесь о производительности (а я не предлагаю вам этого делать), подход, основанный на попытках, является явным победителем (по сравнению с вашим подходом на основе разделов или подходом с регулярными выражениями), если вы не ожидаете многого. недопустимые строки, и в этом случае это потенциально медленнее (предположительно из-за стоимости обработки исключений).

Опять же, я не предлагаю вам заботиться о производительности, просто предоставляю вам данные на случай, если вы делаете это 10 миллиардов раз в секунду или что-то в этом роде. Кроме того, код на основе секций не обрабатывает хотя бы одну допустимую строку.

$ ./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)

Вот код (Python 2.6, регулярное выражение взято из ответ):

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

Упрощенная версия функции is_digit(str), которой достаточно в большинстве случаев (не учитывает экспоненциальное представление и значение "NaN"):

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

Это регулярное выражение будет проверять научные числа с плавающей запятой:

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

Тем не менее, я считаю, что лучше всего попробовать использовать синтаксический анализатор.

Если вам не нужно беспокоиться о научных или других выражениях чисел и вы работаете только со строками, которые могут быть числами с точкой или без нее:

Функция

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

Лямбда-версия

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

Пример

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, в число с плавающей запятой.

Я использовал уже упомянутую функцию, но вскоре замечаю, что строки типа "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

Вы можете использовать предложение try-except-else, это уловит любые ошибки преобразования/значения, возникающие, когда переданное значение не может быть преобразовано в число с плавающей запятой.

  def try_parse_float(item):
      result = None
      try:
        float(item)
      except:
        pass
      else:
        result = float(item)
      return result

Я искал похожий код, но, похоже, лучше всего использовать 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: ")

Попробуйте преобразовать в 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'

Передавая словарь в качестве аргумента, он преобразует строки, которые можно преобразовать в числа с плавающей запятой, и оставит другие

def covertDict_float(data):
        for i in data:
            if data[i].split(".")[0].isdigit():
                try:
                    data[i] = float(data[i])
                except:
                    continue
        return data

Я попробовал некоторые из вышеперечисленных простых вариантов, используя пробный тест для преобразования в число с плавающей запятой, и обнаружил, что в большинстве ответов есть проблема.

Простой тест (в соответствии с приведенными выше ответами):

entry = ttk.Entry(self, validate='key')
entry['validatecommand'] = (entry.register(_test_num), '%P')

def _test_num(P):
    try: 
        float(P)
        return True
    except ValueError:
        return False

Проблема возникает, когда:

• Вы вводите «-», чтобы начать отрицательное число:

Затем вы пытаетесь float('-'), что не удается

• Вы вводите число, но затем пытаетесь удалить все цифры

Затем вы пытаетесь float(''), что также не удается

Быстрое решение, которое у меня было:

def _test_num(P):
    if P == '' or P == '-': return True
    try: 
        float(P)
        return True
    except ValueError:
        return False

Кажется, что многие регулярные выражения пропускают то или иное. Это работало для меня до сих пор:

(?i)^\s*[+-]?(?:inf(inity)?|nan|(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*$

Он допускает бесконечность (или inf) со знаком, nan, отсутствием цифры перед десятичной дробью и начальными/конечными пробелами (при желании). ^ и $ необходимы, чтобы не допустить частичного совпадения чего-то вроде 1.2f-2 с 1.2.

Вы можете использовать [ed] вместо e, если вам нужно проанализировать некоторые файлы, где D используется для экспоненциальной записи с двойной точностью. Вы хотели бы заменить его позже или просто заменить их перед проверкой, так как функция float() не позволит этого.

Я нашел способ, который также может работать. нужно это проверить. первый раз сюда что-то кладу.

def isfloat(a_str):
    try:
        x=float(a_str)
        if x%1 == 0:
            return False
        elif x%1 != 0: #an else also do
            return True
    except Exception as error:
            return False

Это работает как шарм:

[dict([a,int(x) if isinstance(x, str)
 and x.isnumeric() else float(x) if isinstance(x, str)
 and x.replace('.', '', 1).isdigit() else x] for a, x in json_data.items())][0]

Мы можем использовать регулярное выражение как: import re if re.match('[0-9]*.?[0-9]+', <your_string>): print("Its a float/int") else: print("Its something alien") позвольте мне объяснить регулярное выражение на английском языке,

• * -› 0 или более вхождений
• + -› 1 или более случаев
• ? -› 0/1 появление

теперь давайте конвертировать

• '[0-9]* -> пусть будет 0 или более вхождений цифр между 0-9
• \.? -›, за которым следует 0 или один '.' (если вам нужно проверить, может ли это быть int/float, иначе мы также можем использовать вместо ?, используйте {1})
• [0-9]+ -›, за которым следует 0 или более цифр в диапазоне от 0 до 9

str(strval).isdigit()

кажется простым.

Обрабатывает значения, хранящиеся в виде строки, int или float.