Как мне разобрать строку в float или int?


2253

В Python, как я могу разобрать числовую строку , как "545.2222"его соответствующее значение поплавка 545.2222? Или разобрать строку "31"в целое число 31?

Я просто хочу знать , как разобрать поплавок str на float, и (отдельно) в Int str к int.


7
Как правило, если у вас есть объект в Python и вы хотите преобразовать его в объект этого типа, вызовите type(my_object)его. Результат обычно может быть вызван как функция для преобразования. Например, type(100)результат int, так что вы можете позвонить, int(my_object)чтобы попытаться преобразовать my_objectв целое число. Это не всегда работает, но это хорошая «первая догадка» при кодировании.
Робертлэйтон

1
int(x) if int(x) == float(x) else float(x)
tcpaiva

Ответы:


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

8
просто интересно, почему в конце есть «04»? почему не просто «00»? Также моя текущая версия Python не имеет «04».
Мангат Рай Моди

54
@MangatRaiModi Числа с плавающей точкой по своей природе несовершенны для представления десятичных знаков. Более подробно см stackoverflow.com/q/21895756/931277
dokkaebi

19
почему не просто int(a)но int(float(a))?
idclev 463035818

24
int(a)выдаст ошибку, что строка не является допустимым целым числом:, ValueError: invalid literal for int() with base 10: '545.222'но преобразование из числа с плавающей точкой в ​​int является поддерживаемым преобразованием.
Дэвид Паркс

4
Вы должны справиться, ValueErrorесли вы хотите быть в безопасности
Джо Бобсон

515
def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)

81
неявное смешивание чисел с плавающей точкой / целочисленных значений может привести к незначительным ошибкам из-за возможной потери точности при работе с /числами с плавающей запятой или к различным результатам для оператора над числами с плавающей запятой. В зависимости от контекста может быть предпочтительным возвращать либо int, либо float, а не оба.
JFS

14
@JFSebastian Вы совершенно правы, но бывают случаи, когда вы хотите, чтобы ввод определял, какой он будет. Позволяя вводу указать, какой из них можно хорошо использовать при наборе утки.
TimothyAWiseman

4
Вы можете вложить другое, tryчтобы сгенерировать исключение, когда оно не конвертируется в плавающее.
iBug

2
Не удается сs = u'\u0000'
Мэтт Хэнкок

1
@iBug Хорошая идея! Я рекомендую бросить ValueErrorв соответствующем except: P
marcelm

511

Метод Python для проверки, является ли строка плавающей точкой:

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

Более длинное и точное имя для этой функции может быть: is_convertible_to_float(value)

То, что есть и не является поплавком в Python, может вас удивить:

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,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. float(...)Строка кода может не удалось по любой из тысячи причин , которые не имеют ничего общего с содержимым строки. Но если вы пишете жизненно важное программное обеспечение на прототипном языке, например Python, то вы столкнетесь с гораздо большими проблемами.


1
Так что истина становится 1, то есть я унаследовал от C ++, я думаю
FindOutIslamNow

6
Я опубликовал этот ответ в 2014 году. Этот UTF-8символ китайского языка 4с годами трансформировался в зависимости от того, как разработчики stackoverflow изменяют свою схему кодировки символов в своем наборе инструментов Microsoft. Любопытно видеть, как с годами это происходит, когда новые схемы конверсии отстаивают свои новые идеологии. Но да, любой UTF-8глиф для восточно-восточного числа не является поплавком Python. Bazinga.
Эрик Лещинский

4
как это может быть так высоко, за таким широким исключением?
E.Serra

Все с пробелами между ними не может быть преобразовано, как "- 12.3"и"45 e6"
Simon

1
Это за исключением пункта должно быть ограниченоTypeError, ValueError
WIM

131

Это еще один метод, который заслуживает упоминания здесь, ast.literal_eval :

Это может использоваться для безопасной оценки строк, содержащих выражения Python из ненадежных источников, без необходимости разбора значений самостоятельно.

То есть, безопасный «Eval»

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

11
это не хорошее решение проблемы. Он отлично работает в Python 2, но в Python 3 происходит следующее: python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> чтобы выяснить, почему это проблема, если вы хотите оставить телефонные номера в покое и не предполагать, что они являются математическими выражениями, тогда этот подход не для вас.
royce3

6
@ royce3 Да, это хороший момент, и пользователи должны остерегаться. Поведение было изначально изменено для решения некоторых проблем с разбором сложных литералов. Это, возможно, ошибка в ast.literal_evalи обсуждалась здесь .
Вим

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

21
Примечание: будьте осторожны при работе с денежными суммами, передаваемыми в виде строк, поскольку некоторые страны используют "," в качестве десятичных разделителей
Бен Г

127
@Emile: я бы не назвал «2e-3» «крайним случаем». Этот ответ просто сломан.
jchl

14
@BENG НЕ манипулируйте деньгами как поплавком. Это напрашивается на неприятности. Используйте десятичную за деньги! (Но ваш комментарий о ',' все еще действителен и важен)
ToolmakerSteve

4
Не забывайте, что «не число» (NaN) и бесконечность +/- также допустимые значения с плавающей точкой. Так float("nan")что вполне допустимое значение с плавающей запятой, которое вышеупомянутый ответ не
Ронни Андерссон

2
Легко ломается по IP-адресу - 192.168.0.1; или"This is not a good approach. :)"
Тодор Минаков

69

Локализация и запятые

Вы должны рассмотреть возможность запятых в строковом представлении числа, для случаев, подобных float("545,545.2222")которым выдается исключение. Вместо этого используйте методы, localeчтобы преобразовать строки в числа и правильно интерпретировать запятые. В locale.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также доступен, но аргумент должен быть целым числом.


Это кажется идеальным решением, когда вы знаете, нужно ли возвращать float или int, но как вы можете заставить это возвращать int, только если int был передан? Например, x = '1'; locale.atof(x)возвращается, 1.0когда я действительно хочу 1.
user5359531

1
Используя метод Дино, я думаю, что ответ будет использовать что-то вроде этого:locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
user5359531

Я бы порекомендовал использовать метод Хавьера, описанный выше (оборачивать locale.atoiпри попытке и использовать locale.atofпри исключении - это, вероятно, более читабельно.
Марк Чакериан,

27

Если вы не противостоите сторонним модулям, вы можете проверить модуль 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

24

Пользователи codelogic и harley верны, но имейте в виду, что если вы знаете, что строка является целым числом (например, 545), вы можете вызвать int ("545") без предварительного приведения к числу с плавающей точкой.

Если ваши строки находятся в списке, вы также можете использовать функцию map.

>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>

Это хорошо, только если они все одного типа.


21

В Python, как я могу разобрать числовую строку, такую ​​как "545.2222", в соответствующее значение с плавающей точкой, 542.2222? Или разобрать строку «31» в целое число 31? Я просто хочу знать, как разобрать строку с плавающей точкой в ​​число с плавающей точкой, и (отдельно) строку int для int.

Хорошо, что вы просите сделать это отдельно. Если вы смешиваете их, возможно, вы позже настроитесь на проблемы. Простой ответ:

"545.2222" держаться на плаву:

>>> float("545.2222")
545.2222

"31" в целое число:

>>> int("31")
31

Другие преобразования, целые числа в и из строк и литералов:

Конверсии из разных баз, и вы должны знать базу заранее (по умолчанию 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

Если вы видите целое число, которое начинается с 0, в Python 2 это (не рекомендуется) восьмеричный синтаксис.

>>> 037
31

Это плохо, потому что похоже, что значение должно быть 37. Таким образом, в Python 3 теперь возникает SyntaxError:

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

Преобразуйте восьмеричные числа Python 2 в восьмеричные, которые работают в 2 и 3 с 0oпрефиксом:

>>> 0o37
31

20

Вопрос кажется немного старым. Но позвольте мне предложить функцию 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'

9
1e3это число в Python, но строка в соответствии с вашим кодом.
Сис Тиммерман

16

float("545.2222") а также int(float("545.2222"))


1
Это даст вам объект с плавающей запятой, если ваша строка окажется "0" или "0.0", а не int, который он дает для других допустимых чисел.
Брайан

14

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

14

Я использую эту функцию для этого

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

Обратите внимание, что parse_str(' 1')(с пробелом) вернется None, а не 1.
Musiphil

11
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

1
Зачем вам повышать в своем exceptразделе, если вы ничего не делаете там? float () поднимет для вас.
Грегори

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

1
Это попытается проанализировать строку и вернуть либо, intлибо в floatзависимости от того, что представляет строка. Это может вызвать синтаксический анализ исключений или [иметь непредвиденное поведение] [1].
Кузеко

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

6

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

Т.е. int (5.1) => 5 int (5.6) => 5 - неправильно, должно быть 6, поэтому мы делаем int (5.6 + 0.5) => 6

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

4
Хорошая точка зрения. Это вызывает инфляцию, поэтому Python 3 и другие современные языки используют банковское округление.
Сис Тиммерман,

2
Этот ответ неверен (как изначально написано). Это путает два случая intи float. И это даст исключение, когда nэто строка, как желательно OP. Возможно , вы имели в виду: Когдаint результат желательно, roundдолжно быть сделано преобразование ПОСЛЕ плавать. Если функция ВСЕГДА должна возвращать int, то вам не нужна часть кроме - может быть все тело функции int(round(float(input))). Если функция должна вернуть int, если это возможно, в противном случае float, тогда оригинальное решение Хавьера верное!
ToolmakerSteve

5

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

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

5

Для Typecast в Python используйте функции конструктора типа, передавая строку (или любое значение, которое вы пытаетесь привести) в качестве параметра.

Например:

>>>float("23.333")
   23.333

За кулисами python вызывает __float__метод objects , который должен возвращать плавающее представление параметра. Это особенно полезно, так как вы можете определять свои собственные типы (используя классы) с помощью __float__метода, чтобы он мог быть преобразован в float с помощью float (myobject).


3

Это исправленная версия от https://stackoverflow.com/a/33017514/5973334

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

  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

2

Передайте вашу строку этой функции:

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

1

Использование:

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

Это самый Pythonic способ, которым я мог придумать.


Генератор останавливается после первой интерпретации float. Блок trycatchвероятно должен быть внутри forцикла.
Musiphil

1

Обрабатывает шестнадцатеричные, восьмеричные, двоичные, десятичные и плавающие

Это решение будет обрабатывать все строковые соглашения для чисел (все, что я знаю).

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)

0

Использование:

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

0

Это функция, которая преобразует любые object(не только str) в intили float, в зависимости от того, выглядит ли фактическая строка какint или float. Кроме того, если это объект, который имеет оба __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

-1

Используя методы int и float, мы можем преобразовать строку в целое число и число с плавающей точкой.

s="45.8"
print(float(s))

y='67'
print(int(y))

Этот ответ не добавляет ничего нового. Смотрите, например, этот ответ, который дает ту же информацию и многое другое.
Георгий

-3

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

if '.' in string:
    print(float(string))
else:
    print(int(string))

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

try:
    print(int(string))
except:
    print(float(string))

-10

Вот еще одна интерпретация вашего вопроса (подсказка: она расплывчатая). Возможно, вы ищете что-то вроде этого:

def parseIntOrFloat( aString ):
    return eval( aString )

Это работает так ...

>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545

Теоретически, существует уязвимость для инъекций. Строка может быть, например "import os; os.abort()". Однако, без каких-либо сведений о происхождении этой строки, существует теоретическое предположение. Поскольку вопрос расплывчат, не совсем понятно, существует ли эта уязвимость на самом деле или нет.


7
Даже если его вход безопасен на 100%, eval()он более чем в 3 раза медленнее try: int(s) except: float(s).
Сис Тиммерман

1
Что ж, evalэто плохая практика (вы должны знать, потому что у вас репутация 310k)
U10-Forward
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.