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

Каков наилучший способ проверить, может ли строка быть представлена ​​в виде числа в Python?

Теперь у меня есть функция:

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

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

1242
задан Daniel Goldberg 09 дек. '08 в 23:03
источник поделиться
31 ответ
  • 1
  • 2

Который, не только уродливый и медленный

Я бы оспаривал оба.

Регулярное выражение или другой синтаксический анализ строк будет более уродливым и медленным.

Я не уверен, что все может быть быстрее, чем выше. Он вызывает функцию и возвращает. Try/Catch не накладывает много накладных расходов, потому что наиболее распространенное исключение попадает без широкого поиска кадров стека.

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

  • Число, если число действительно
  • Код состояния (например, через errno) или исключение, чтобы показать, что действительный номер не может быть проанализирован.

C (как пример) взламывает вокруг этого несколько способов. Python четко и ясно излагает это.

Я думаю, что ваш код для этого идеален.

563
ответ дан S.Lott 09 дек. '08 в 23:30
источник поделиться

Если вы ищете синтаксический анализ (положительные, без знака) целые числа вместо float, вы можете использовать isdigit() для строковых объектов.

>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False

String Methods - isdigit()

Также есть что-то в строках Unicode, которые я не слишком хорошо знаком с Unicode - десятичный/десятичный

1327
ответ дан Zoomulator 09 дек. '08 в 23:15
источник поделиться

Есть одно исключение, которое вы можете принять во внимание: строка "NaN"

Если вы хотите, чтобы is_number возвращал FALSE для "NaN", этот код не будет работать, поскольку Python преобразует его в свое представление числа, которое не является числом (говорить о проблемах с идентификацией):

>>> float('NaN')
nan

В противном случае, я должен поблагодарить вас за кусок кода, который я сейчас широко использую.:)

G.

64
ответ дан gvrocha 01 сент. '10 в 17:06
источник поделиться

TL; DR Лучшее решение - s.replace('.','',1).isdigit()

Я сделал некоторые тесты, сравнивающие разные подходы

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

import re    
def is_number_regex(s):
    """ Returns True is string is a number. """
    if re.match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

Если строка не является числом, блок except выполняется довольно медленно. Но что более важно, метод try-except - единственный подход, который правильно обрабатывает научные обозначения.

funcs = [
          is_number_tryexcept, 
          is_number_regex,
          is_number_repl_isdigit
          ]

a_float = '.1234'

print('Float notation ".1234" is not supported by:')
for f in funcs:
    if not f(a_float):
        print('\t -', f.__name__)

Обозначение с плавающей запятой ".1234" не поддерживается:
- is_number_regex

scientific1 = '1.000000e+50'
scientific2 = '1e50'


print('Scientific notation "1.000000e+50" is not supported by:')
for f in funcs:
    if not f(scientific1):
        print('\t -', f.__name__)




print('Scientific notation "1e50" is not supported by:')
for f in funcs:
    if not f(scientific2):
        print('\t -', f.__name__)

Научная нотация "1.000000e + 50" не поддерживается:
- is_number_regex
- is_number_repl_isdigit
Научная нотация "1e50" не поддерживается:
- is_number_regex
- is_number_repl_isdigit

EDIT: результаты тестов

import timeit

test_cases = ['1.12345', '1.12.345', 'abc12345', '12345']
times_n = {f.__name__:[] for f in funcs}

for t in test_cases:
    for f in funcs:
        f = f.__name__
        times_n[f].append(min(timeit.Timer('%s(t)' %f, 
                      'from __main__ import %s, t' %f)
                              .repeat(repeat=3, number=1000000)))

где были протестированы следующие функции:

from re import match as re_match
from re import compile as re_compile

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

def is_number_regex(s):
    """ Returns True is string is a number. """
    if re_match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


comp = re_compile("^\d+?\.\d+?$")    

def compiled_regex(s):
    """ Returns True is string is a number. """
    if comp.match(s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

введите описание изображения здесь

63
ответ дан Sebastian 13 мая '14 в 22:28
источник поделиться

как насчет этого:

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

который вернет true, только если есть один или нет. в строке цифр.

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

вернет false

edit: просто увидел другой комментарий... добавление a .replace(badstuff,'',maxnum_badstuff) для других случаев может быть выполнено. если вы пропустите соль, а не произвольные приправы (ref: xkcd # 974), это будет хорошо: P

52
ответ дан haxwithaxe 26 мая '12 в 1:22
источник поделиться

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

def is_number(s):
    try:
        complex(s) # for int, long, float and complex
    except ValueError:
        return False

    return True

Ранее говорилось: есть ли некоторые редкие случаи, которые вам также могут понадобиться для проверки сложных чисел (например, 1 + 2i), которые не могут быть представлены с помощью float:

def is_number(s):
    try:
        float(s) # for int, long and float
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False

    return True
38
ответ дан Matthew Wilcoxson 26 июля '10 в 16:10
источник поделиться

Который, не только уродливый и медленный, кажется неуклюжим.

Это может занять некоторое время, но это питонический способ сделать это. Как уже отмечалось, альтернативы хуже. Но есть еще одно преимущество в этом: полиморфизм.

Центральная идея утиной печати заключается в том, что "если она ходит и разговаривает, как утка, то это утка". Что, если вы решите, что вам нужно подклассифицировать строку, чтобы вы могли изменить, как вы определяете, может ли что-то быть преобразовано в float? Или что, если вы решите полностью протестировать какой-либо другой объект? Вы можете делать это без изменения вышеуказанного кода.

Другие языки решают эти проблемы с помощью интерфейсов. Я сохраню анализ того, какое решение лучше для другого потока. Дело в том, что python определенно зависит от утиной печатной стороны уравнения, и вам, вероятно, придется привыкнуть к синтаксису, например, если вы планируете много программировать на Python (но это не значит вам это должно понравиться, конечно).

Еще одна вещь, которую вы, возможно, захотите принять во внимание: Python довольно быстро бросает и ломает исключения по сравнению со многими другими языками (в 30 раз быстрее, чем .NET). Черт возьми, сам язык даже создает исключения для передачи не исключительных нормальных условий программы (каждый раз, когда вы используете цикл for). Таким образом, я не стал бы слишком беспокоиться об аспектах производительности этого кода, пока вы не заметите существенную проблему.

37
ответ дан Jason Baker 11 дек. '08 в 7:56
источник поделиться

Для int используйте это:

>>> "1221323".isdigit()
True

Но для float нам нужны некоторые трюки;-). Каждое число с плавающей точкой имеет одну точку...

>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False

Также для отрицательных чисел просто добавьте lstrip():

>>> '-12'.lstrip('-')
'12'

И теперь мы получаем универсальный способ:

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False
18
ответ дан Sdwdaw 08 сент. '15 в 11:42
источник поделиться

Просто Mimic С#

В С# существуют две различные функции, которые обрабатывают разбор скалярных значений:

  • Float.Parse()
  • Float.TryParse()

float.parse():

def parse(string):
    try:
        return float(string)
    except Exception:
        throw TypeError

Примечание. Если вам интересно, почему я изменил исключение на TypeError, здесь документацию.

float.try_parse():

def try_parse(string, fail=None):
    try:
        return float(string)
    except Exception:
        return fail;

Примечание. Вы не хотите возвращать логическое значение "False", потому что это еще тип значения. Нет лучше, потому что это указывает на сбой. Конечно, если вы хотите что-то другое, вы можете изменить параметр fail на все, что хотите.

Чтобы расширить float, чтобы включить "parse()" и "try_parse()", вам нужно будет обезвредить класс "float", чтобы добавить эти методы.

Если вы хотите уважать ранее существовавшие функции, код должен выглядеть примерно так:

def monkey_patch():
    if(!hasattr(float, 'parse')):
        float.parse = parse
    if(!hasattr(float, 'try_parse')):
        float.try_parse = try_parse

SideNote: Я лично предпочитаю называть это Monkey Punching, потому что кажется, что я злоупотребляю языком, когда я это делаю, но YMMV.

Применение:

float.parse('giggity') // throws TypeException
float.parse('54.3') // returns the scalar value 54.3
float.tryParse('twank') // returns None
float.tryParse('32.2') // returns the scalar value 32.2

И великий мудрец Пифон сказал Священному Престолу Шарпису: "Все, что вы можете сделать, я могу сделать лучше, я могу сделать что-нибудь лучше вас".

14
ответ дан Evan Plaice 18 февр. '12 в 4:35
источник поделиться

Для строк не чисел, try: except: на самом деле медленнее, чем регулярные выражения. Для строк допустимых чисел регулярное выражение работает медленнее. Таким образом, соответствующий метод зависит от вашего ввода.

Если вы обнаружите, что находитесь в привязке к производительности, вы можете использовать новый сторонний модуль под названием fastnumbers, который обеспечивает функция называется isfloat. Полное раскрытие, я автор. Я включил его результаты в тайминги ниже.


from __future__ import print_function
import timeit

prep_base = '''\
x = 'invalid'
y = '5402'
z = '4.754e3'
'''

prep_try_method = '''\
def is_number_try(val):
    try:
        float(val)
        return True
    except ValueError:
        return False

'''

prep_re_method = '''\
import re
float_match = re.compile(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$').match
def is_number_re(val):
    return bool(float_match(val))

'''

fn_method = '''\
from fastnumbers import isfloat

'''

print('Try with non-number strings', timeit.timeit('is_number_try(x)',
    prep_base + prep_try_method), 'seconds')
print('Try with integer strings', timeit.timeit('is_number_try(y)',
    prep_base + prep_try_method), 'seconds')
print('Try with float strings', timeit.timeit('is_number_try(z)',
    prep_base + prep_try_method), 'seconds')
print()
print('Regex with non-number strings', timeit.timeit('is_number_re(x)',
    prep_base + prep_re_method), 'seconds')
print('Regex with integer strings', timeit.timeit('is_number_re(y)',
    prep_base + prep_re_method), 'seconds')
print('Regex with float strings', timeit.timeit('is_number_re(z)',
    prep_base + prep_re_method), 'seconds')
print()
print('fastnumbers with non-number strings', timeit.timeit('isfloat(x)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with integer strings', timeit.timeit('isfloat(y)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with float strings', timeit.timeit('isfloat(z)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print()

Try with non-number strings 2.39108395576 seconds
Try with integer strings 0.375686168671 seconds
Try with float strings 0.369210958481 seconds

Regex with non-number strings 0.748660802841 seconds
Regex with integer strings 1.02021503448 seconds
Regex with float strings 1.08564686775 seconds

fastnumbers with non-number strings 0.174362897873 seconds
fastnumbers with integer strings 0.179651021957 seconds
fastnumbers with float strings 0.20222902298 seconds

Как вы можете видеть

  • try: except: был быстрым для числового ввода, но очень медленным для недопустимого ввода
  • regex очень эффективен, когда вход недействителен
  • fastnumbers выигрывает в обоих случаях
14
ответ дан SethMMorton 14 авг. '14 в 6:34
источник поделиться

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

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

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

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

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

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

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

13
ответ дан Aruthawolf 05 янв. '16 в 18:21
источник поделиться

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

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

Или:

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

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

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

10
ответ дан Blackzafiro 04 марта '13 в 19:12
источник поделиться

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

9
ответ дан codelogic 09 дек. '08 в 23:31
источник поделиться

Допустим, у вас есть цифры в строке. str = "100949" и вы хотите проверить, есть ли у него только числа

if str.isdigit():
returns TRUE or FALSE 

isdigit docs

в противном случае ваш метод отлично работает, чтобы найти появление цифры в строке.

8
ответ дан Clayton 13 окт. '14 в 12:17
источник поделиться

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

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

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

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

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

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
7
ответ дан Ron Reiter 16 янв. '13 в 9:09
источник поделиться

Этот ответ предоставляет пошаговое руководство, в котором функция с примерами для поиска строки:

  • Положительное число
  • Положительный/отрицательный - integer/float
  • Как отбросить строки "NaN" (не число) при проверке номера?

Проверьте, является ли строка положительным целым числом

Вы можете использовать str.isdigit() чтобы проверить, является ли данная строка положительным целым числом.

Примеры результатов:

# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False

Проверьте, что строка положительная/отрицательная - integer/float

str.isdigit() возвращает False если строка является отрицательным числом или числом с плавающей точкой. Например:

# returns 'False' for float
>>> '123.3'.isdigit()
False
# returns 'False' for negative number
>>> '-123'.isdigit()
False

Если вы хотите также проверить отрицательные целые числа и float, вы можете написать пользовательскую функцию, чтобы проверить ее как:

def is_number(n):
    try:
        float(n)   # Type-casting the string to 'float'.
                   # If string is not a valid 'float', 
                   # it'll raise 'ValueError' exception
    except ValueError:
        return False
    return True

Пример прогона:

>>> is_number('123')    # positive integer number
True

>>> is_number('123.4')  # positive float number
True

>>> is_number('-123')   # negative integer number
True

>>> is_number('-123.4') # negative 'float' number
True

>>> is_number('abc')    # 'False' for "some random" string
False

Отбросьте строки "NaN" (не число) при проверке номера

Вышеупомянутые функции вернут True для строки "NAN" (Not number), потому что для Python это допустимое значение float, представляющее его, не является числом. Например:

>>> is_number('NaN')
True

Чтобы проверить, является ли число "NaN", вы можете использовать math.isnan() как:

>>> import math
>>> nan_num = float('nan')

>>> math.isnan(nan_num)
True

Или если вы не хотите импортировать дополнительную библиотеку, чтобы проверить это, вы можете просто проверить ее, сравнив ее с самим собой, используя ==. Python возвращает False когда nan float сравнивается с самим собой. Например:

# 'nan_num' variable is taken from above example
>>> nan_num == nan_num
False

Следовательно, выше функция is_number может быть обновлена, чтобы вернуть False для "NaN" следующим образом:

def is_number(n):
    is_number = True
    try:
        num = float(n)
        # check for "nan" floats
        is_number = num == num   # or use 'math.isnan(num)'
    except ValueError:
        is_number = False
    return is_number

Пример прогона:

>>> is_number('Nan')   # not a number "Nan" string
False

>>> is_number('nan')   # not a number string "nan" with all lower cased
False

>>> is_number('123')   # positive integer
True

>>> is_number('-123')  # negative integer
True

>>> is_number('-1.12') # negative 'float'
True

>>> is_number('abc')   # "some random" string
False

PS: Каждая операция для каждой проверки в зависимости от типа номера имеет дополнительные накладные расходы. Выберите версию функции is_number которая соответствует вашим требованиям.

7
ответ дан Moinuddin Quadri 11 февр. '18 в 11:34
источник поделиться

Итак, чтобы собрать все вместе, проверив 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
6
ответ дан a1an 23 марта '12 в 19:10
источник поделиться

Ваш код выглядит хорошо для меня.

Возможно, вы считаете, что код "неуклюжий" из-за использования исключений? Обратите внимание, что программисты Python склонны использовать исключения либерально, когда улучшают удобочитаемость кода благодаря его низкой производительности.

5
ответ дан Dubhead 11 дек. '08 в 7:03
источник поделиться

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

4
ответ дан FxIII 12 окт. '10 в 10:43
источник поделиться

Мне нужно было определить, была ли строка передана в базовые типы (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) 
4
ответ дан astrodsg 03 июля '14 в 20:12
источник поделиться

РайанН предлагает

Если вы хотите вернуть 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

3
ответ дан philh 29 июля '13 в 17:08
источник поделиться

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

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False
1
ответ дан TheRedstoneLemon 30 мая '15 в 20:12
источник поделиться

Я также использовал указанную вами функцию, но вскоре я заметил, что строки как "Нан", "Инф" и ее вариация считаются цифрами. Поэтому я предлагаю вам улучшенную версию вашей функции, которая вернет 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
1
ответ дан mathfac 16 окт. '16 в 0:11
источник поделиться

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

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

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

1
ответ дан Anil 16 июля '09 в 20:45
источник поделиться

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

1
ответ дан m_eiman 10 дек. '08 в 12:15
источник поделиться

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

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
1
ответ дан user1508746 09 нояб. '14 в 17:06
источник поделиться

Вы можете использовать регулярное выражение.

number = raw_input("Enter a number: ")
if re.match(r'^\d+$', number):
    print "It integer"
    print int(number)
elif re.match(r'^\d+\.\d+$', number):
    print "It float"
    print float(number)
else:
    print("Please enter a number")
1
ответ дан Avinash Raj 23 авг. '15 в 16:22
источник поделиться

Вы можете обобщить технику исключения полезным способом, возвращая более полезные значения, чем 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:]), ')'
0
ответ дан Thruston 25 мая '13 в 0:36
источник поделиться

Чтобы проверить, является ли входное значение float, вы можете сравнить тип ввода с float

def isFloat(s):
    realFloat = 0.1

    if type(s) == type(realFloat):
        return True
    else:
        return False

Возврат:

False     # s = 5
True      # s = 1.2345

Первоначальное сообщение фактически вернет True для s = 5, так как это число (целое число), и вы можете использовать int для float без ValueError. Если вы пытаетесь проверить, что это фактический float, а не просто номер, вам нужно будет учитывать этот случай.

0
ответ дан ode2k 16 сент. '16 в 8:00
источник поделиться

использовать его для всех случаев: -

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')
0
ответ дан donald 24 февр. '17 в 14:11
источник поделиться
  • 1
  • 2

Другие вопросы по меткам