Как проверить, является ли строка числом (с плавающей запятой)?

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

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

x.isdigit() хорошо подходит для проверки, является ли x целым числом.

x.replace('-','').isdigit() хорошо подходит для проверки, является ли x отрицательным (проверка - в первой позиции)

x.replace('.','').isdigit() хорошо подходит для проверки, является ли x десятичным числом.

x.replace(':','').isdigit() хорошо подходит для проверки, является ли x соотношением.

x.replace('/','',1).isdigit() хорошо подходит для проверки, является ли x дробью.

Преобразование в float и перехват ValueError, вероятно, самый быстрый способ, поскольку float () специально предназначен для этого. Все остальное, что требует синтаксического анализа строк (регулярное выражение и т. Д.), Скорее всего, будет медленнее из-за того, что оно не настроено для этой операции. Мои 0,02 доллара.

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

>>> s = u"345"
>>> s.isnumeric()
True

Or:

>>> s = "345"
>>> u = unicode(s)
>>> u.isnumeric()
True

http://www.tutorialspoint.com/python/string_isnumeric.htm

http://docs.python.org/2/howto/unicode.html

Итак, чтобы собрать все вместе, проверяя Nan, бесконечность и комплексные числа (казалось бы, они указаны с j, а не i, т.е. 1 + 2j), это приводит к:

def is_number(s):
    try:
        n=str(float(s))
        if n == "nan" or n=="inf" or n=="-inf" : return False
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False
    return True

Я хотел посмотреть, какой метод самый быстрый. В целом наилучшие и наиболее последовательные результаты дает функция check_replace. Самые быстрые результаты дает функция check_exception, но только в том случае, если не было запущено исключение - это означает, что ее код является наиболее эффективным, но накладные расходы на создание исключения довольно велики.

Обратите внимание, что проверка успешного приведения - единственный точный метод, например, он работает с check_exception, но две другие тестовые функции вернут False для действительного числа с плавающей запятой:

huge_number = float('1e+100')

Вот код теста:

import time, re, random, string

ITERATIONS = 10000000

class Timer:    
    def __enter__(self):
        self.start = time.clock()
        return self
    def __exit__(self, *args):
        self.end = time.clock()
        self.interval = self.end - self.start

def check_regexp(x):
    return re.compile("^\d*\.?\d*$").match(x) is not None

def check_replace(x):
    return x.replace('.','',1).isdigit()

def check_exception(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

to_check = [check_regexp, check_replace, check_exception]

print('preparing data...')
good_numbers = [
    str(random.random() / random.random()) 
    for x in range(ITERATIONS)]

bad_numbers = ['.' + x for x in good_numbers]

strings = [
    ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(random.randint(1,10)))
    for x in range(ITERATIONS)]

print('running test...')
for func in to_check:
    with Timer() as t:
        for x in good_numbers:
            res = func(x)
    print('%s with good floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in bad_numbers:
            res = func(x)
    print('%s with bad floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in strings:
            res = func(x)
    print('%s with strings: %s' % (func.__name__, t.interval))

Вот результаты с Python 2.7.10 на MacBook Pro 13 2017 года:

check_regexp with good floats: 12.688639
check_regexp with bad floats: 11.624862
check_regexp with strings: 11.349414
check_replace with good floats: 4.419841
check_replace with bad floats: 4.294909
check_replace with strings: 4.086358
check_exception with good floats: 3.276668
check_exception with bad floats: 13.843092
check_exception with strings: 15.786169

Вот результаты с Python 3.6.5 на MacBook Pro 13 2017 года:

check_regexp with good floats: 13.472906000000009
check_regexp with bad floats: 12.977665000000016
check_regexp with strings: 12.417542999999995
check_replace with good floats: 6.011045999999993
check_replace with bad floats: 4.849356
check_replace with strings: 4.282754000000011
check_exception with good floats: 6.039081999999979
check_exception with bad floats: 9.322753000000006
check_exception with strings: 9.952595000000002

Вот результаты PyPy 2.7.13 на MacBook Pro 13 2017 года:

check_regexp with good floats: 2.693217
check_regexp with bad floats: 2.744819
check_regexp with strings: 2.532414
check_replace with good floats: 0.604367
check_replace with bad floats: 0.538169
check_replace with strings: 0.598664
check_exception with good floats: 1.944103
check_exception with bad floats: 2.449182
check_exception with strings: 2.200056

Вход может быть следующим:

a="50" b=50 c=50.1 d="50.1"

1-Общие данные:

Входом в эту функцию может быть что угодно!

Проверяет, является ли данная переменная числовой. Числовые строки состоят из необязательного знака, любого количества цифр, необязательной десятичной части и необязательной экспоненциальной части. Таким образом, + 0123.45e6 - допустимое числовое значение. Шестнадцатеричная (например, 0xf4c3b00c) и двоичная (например, 0b10100111001) нотации не допускаются.

is_numeric функция

import ast
import numbers              
def is_numeric(obj):
    if isinstance(obj, numbers.Number):
        return True
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            #if used + or - in digit :
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

тестовое задание:

>>> is_numeric("54")
True
>>> is_numeric("54.545")
True
>>> is_numeric("0x45")
True

Функция is_float

Проверяет, является ли данная переменная плавающей. Строки с плавающей запятой состоят из необязательного знака, любого количества цифр, ...

import ast

def is_float(obj):
    if isinstance(obj, float):
        return True
    if isinstance(obj, int):
        return False
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        if not isinstance(nodes[-1].n, float):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

тестовое задание:

>>> is_float("5.4")
True
>>> is_float("5")
False
>>> is_float(5)
False
>>> is_float("5")
False
>>> is_float("+5.4")
True

что такое ast?

2- Если вы уверены, что содержимое переменной - Строка:

используйте метод str.isdigit ()

>>> a=454
>>> a.isdigit()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit'
>>> a="454"
>>> a.isdigit()
True

3-числовой ввод:

определить значение int:

>>> isinstance("54", int)
False
>>> isinstance(54, int)
True
>>> 

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

>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True

str.isnumeric()

Вернуть True, если все символы в строке числовые и есть хотя бы один символ, в противном случае False. Числовые символы включают символы цифр и все символы, которые имеют свойство числового значения Unicode, например U + 2155, ВУЛГАРНАЯ ФРАКЦИЯ ОДИН ПЯТЫЙ. Формально числовые символы - это символы со значением свойства Numeric_Type = Digit, Numeric_Type = Decimal или Numeric_Type = Numeric.

str.isdecimal()

Вернуть True, если все символы в строке являются десятичными и есть хотя бы один символ, в противном случае False. Десятичные символы - это те, которые можно использовать для формирования чисел с основанием 10, например U + 0660, АРАБСКО-ИНДИКАЦИОННАЯ ЦИФРА НУЛЬ. Формально десятичный символ - это символ из общей категории Unicode «Nd».

Оба доступны для строковых типов из Python 3.0.

Я сделал тест на скорость. Предположим, что если строка вероятно является числом, стратегия try / except является наиболее быстрой из возможных. Если строка вряд ли будет быть числом и вас интересует проверка Целочисленного, стоит провести некоторый тест (это цифра плюс заголовок '-'). Если вы хотите проверить число с плавающей запятой, вы должны использовать код try / except без выхода.

Мне нужно было определить, преобразуется ли строка в базовые типы (float, int, str, bool). Не найдя ничего в Интернете, я создал это:

def str_to_type (s):
    """ Get possible cast type for a string

    Parameters
    ----------
    s : string

    Returns
    -------
    float,int,str,bool : type
        Depending on what it can be cast to

    """    
    try:                
        f = float(s)        
        if "." not in s:
            return int
        return float
    except ValueError:
        value = s.upper()
        if value == "TRUE" or value == "FALSE":
            return bool
        return type(s)

Пример

str_to_type("true") # bool
str_to_type("6.0") # float
str_to_type("6") # int
str_to_type("6abc") # str
str_to_type(u"6abc") # unicode       

Вы можете захватить тип и использовать его

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 

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

Кажется, есть много ненависти к регулярным выражениям к этим ответам, которые я считаю необоснованными, регулярные выражения могут быть достаточно чистыми, правильными и быстрыми. Это действительно зависит от того, что вы пытаетесь сделать. Первоначальный вопрос заключался в том, как вы можете «проверить, может ли строка быть представлена ​​как число (с плавающей запятой)» (согласно вашему заголовку). Предположительно, вы захотите использовать числовое значение / значение с плавающей запятой после того, как проверите, что оно действительно, и в этом случае ваш try / except имеет большой смысл. Но если по какой-то причине вы просто хотите подтвердить, что строка является числом, тогда регулярное выражение также работает нормально, но его трудно понять правильно. Я думаю, что большинство ответов на регулярные выражения до сих пор, например, не анализируют должным образом строки без целой части (например, «.7»), которая является плавающей для Python. И это немного сложно проверить в одном регулярном выражении, где дробная часть не требуется. Я включил два регулярных выражения, чтобы показать это.

Это поднимает интересный вопрос о том, что такое «число». Вы включаете "inf", который действителен как float в python? Или вы включаете числа, которые являются «числами», но, возможно, не могут быть представлены в python (например, числа, которые больше, чем максимальное значение с плавающей запятой).

Есть также двусмысленность в том, как вы разбираете числа. Например, как насчет «-20»? Это «число»? Это законный способ представлять «20»? Python позволит вам сделать «var = --20» и установить его на 20 (хотя на самом деле это потому, что он обрабатывает его как выражение), но float («- 20») не работает.

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

# Doesn't properly handle floats missing the integer part, such as ".7"
SIMPLE_FLOAT_REGEXP = re.compile(r'^[-+]?[0-9]+\.?[0-9]+([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56"      # sign (-)
                            #     integer (12)
                            #           mantissa (34)
                            #                    exponent (E+56)

# Should handle all floats
FLOAT_REGEXP = re.compile(r'^[-+]?([0-9]+|[0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56"      # sign (-)
                            #     integer (12)
                            #           OR
                            #             int/mantissa (12.34)
                            #                            exponent (E+56)

def is_float(str):
  return True if FLOAT_REGEXP.match(str) else False

Некоторые примеры тестовых значений:

True  <- +42
True  <- +42.42
False <- +42.42.22
True  <- +42.42e22
True  <- +42.42E-22
False <- +42.42e-22.8
True  <- .42
False <- 42nope

Выполнение кода тестирования в ответе @ ron-reiter показывает, что это регулярное выражение на самом деле быстрее, чем обычное регулярное выражение, и намного быстрее обработка неверных значений, чем исключение, что имеет некоторый смысл. Полученные результаты:

check_regexp with good floats: 18.001921
check_regexp with bad floats: 17.861423
check_regexp with strings: 17.558862
check_correct_regexp with good floats: 11.04428
check_correct_regexp with bad floats: 8.71211
check_correct_regexp with strings: 8.144161
check_replace with good floats: 6.020597
check_replace with bad floats: 5.343049
check_replace with strings: 5.091642
check_exception with good floats: 5.201605
check_exception with bad floats: 23.921864
check_exception with strings: 23.755481

RyanN предлагает

Если вы хотите вернуть False для NaN и Inf, измените строку на x = float (s); return (x == x) и (x - 1! = x). Это должно вернуть True для всех чисел с плавающей запятой, кроме Inf и NaN.

Но это не совсем работает, потому что для достаточно больших чисел с плавающей запятой x-1 == x возвращает true. Например, 2.0**54 - 1 == 2.0**54

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

return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False

В наиболее общем случае для числа с плавающей запятой нужно позаботиться о целых и десятичных числах. Возьмем для примера строку "1.1".

Я бы попробовал одно из следующего:

1. ›isnumeric ()

word = "1.1"

"".join(word.split(".")).isnumeric()
>>> True

2. ›isdigit ()

word = "1.1"

"".join(word.split(".")).isdigit()
>>> True

3. ›isdecimal ()

word = "1.1"

"".join(word.split(".")).isdecimal()
>>> True

Скорость:

► Все вышеупомянутые методы имеют одинаковую скорость.

%timeit "".join(word.split(".")).isnumeric()
>>> 257 ns ± 12 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit "".join(word.split(".")).isdigit()
>>> 252 ns ± 11 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit "".join(word.split(".")).isdecimal()
>>> 244 ns ± 7.17 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Вот мой простой способ сделать это. Допустим, я просматриваю несколько строк и хочу добавить их в массив, если они окажутся числами.

try:
    myvar.append( float(string_to_check) )
except:
    continue

Замените myvar.apppend любой операцией, которую вы хотите выполнить со строкой, если она оказывается числом. Идея состоит в том, чтобы попытаться использовать операцию float () и использовать возвращенную ошибку, чтобы определить, является ли строка числом.

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

1 - я хотел получить целочисленный результат, если строка представляла целое число

2 - Я хотел, чтобы числовой или строковый результат вставлялся в структуру данных

поэтому я адаптировал исходный код для создания этой производной:

def string_or_number(s):
    try:
        z = int(s)
        return z
    except ValueError:
        try:
            z = float(s)
            return z
        except ValueError:
            return s

Я также использовал упомянутую вами функцию, но вскоре заметил, что такие строки, как «Nan», «Inf» и их вариации, считаются числами. Итак, я предлагаю вам улучшенную версию вашей функции, которая будет возвращать false для этого типа ввода и не откажет в вариантах "1e3":

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

Вспомогательная функция пользователя:

def if_ok(fn, string):
  try:
    return fn(string)
  except Exception as e:
    return None

тогда

if_ok(int, my_str) or if_ok(float, my_str) or if_ok(complex, my_str)
is_number = lambda s: any([if_ok(fn, s) for fn in (int, float, complex)])

Вы можете обобщить технику исключения полезным способом, вернув больше полезных значений, чем True и False. Например, эта функция помещает строки в кавычки, но оставляет только числа. Это как раз то, что мне нужно для быстрого и грязного фильтра, чтобы сделать некоторые определения переменных для R.

import sys

def fix_quotes(s):
    try:
        float(s)
        return s
    except ValueError:
        return '"{0}"'.format(s)

for line in sys.stdin:
    input = line.split()
    print input[0], '<- c(', ','.join(fix_quotes(c) for c in input[1:]), ')'

Попробуй это.

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False

Извините за сообщение в ветке Zombie - просто хотел завершить код для полноты ...

# is_number() function - Uses re = regex library
# Should handle all normal and complex numbers
# Does not accept trailing spaces. 
# Note: accepts both engineering "j" and math "i" but only the imaginary part "+bi" of a complex number a+bi
# Also accepts inf or NaN
# Thanks to the earlier responders for most the regex fu

import re

ISNUM_REGEXP = re.compile(r'^[-+]?([0-9]+|[0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?[ij]?$')

def is_number(str):
#change order if you have a lot of NaN or inf to parse
    if ISNUM_REGEXP.match(str) or str == "NaN" or str == "inf": 
        return True 
    else:
        return False
# A couple test numbers
# +42.42e-42j
# -42.42E+42i

print('Is it a number?', is_number(input('Gimme any number: ')))

Дайте мне любой номер: + 42.42e-42j

Это число? Правда

Для моего очень простого и очень распространенного варианта использования: is this human written string with keyboard a number?

Я прочитал большинство ответов и получил:

def isNumeric(string):
    result = True
    try:
        x = float(string)
       result = (x == x) and (x - 1 != x)
    except ValueError:
        result = False
    return result

Он вернет False для (+-)NaN и (+-)inf.

Вы можете проверить это здесь: https://trinket.io/python/ce32c0e54e

У меня похожая проблема. Вместо определения функции isNumber я хочу преобразовать список строк в числа с плавающей запятой, что в терминах высокого уровня будет выглядеть так:

[ float(s) for s in list if isFloat(s)]

Очевидно, что мы не можем отделить float (s) от функций isFloat (s): эти два результата должны возвращаться одной и той же функцией. Кроме того, если float (s) терпит неудачу, весь процесс терпит неудачу, вместо того, чтобы просто игнорировать неисправный элемент. Кроме того, «0» - это действительное число, которое должно быть включено в список. При отфильтровывании плохих элементов убедитесь, что не исключили 0.

Следовательно, приведенное выше понимание необходимо как-то изменить, чтобы:

• если какой-либо элемент в списке не может быть преобразован, игнорируйте его и не генерируйте исключение
• избегайте вызова float (ов) более одного раза для каждого элемента (один для преобразования, другой для теста)
• если преобразованное значение равно 0, оно все равно должно присутствовать в окончательном списке

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

def tryParseFloat(s):
    try:
        return(float(s), True)
    except:
        return(None, False)

tupleList = [tryParseFloat(x) for x in list]
floats = [v for v,b in tupleList if b]

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

import re
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3') 
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3sd')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3')