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

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

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

вопрос задан 19.12.2008
Tristan Havelick
22959 репутация

23 ответов


  • 2135 рейтинг
    >>> a = "545.2222"
    >>> float(a)
    545.22220000000004
    >>> int(float(a))
    545
    
    ответ дан Harley Holcombe, с репутацией 105065, 19.12.2008
  • 451 рейтинг
    def num(s):
        try:
            return int(s)
        except ValueError:
            return float(s)
    
    ответ дан Javier, с репутацией 50942, 19.12.2008
  • 426 рейтинг

    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
     

    Вы думаете, что знаете, какие цифры? Вы не так хороши, как думаете! Не большой сюрприз.

    ответ дан Eric Leschinski, с репутацией 81465, 5.01.2014
  • 106 рейтинг

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

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

    То есть, безопасный 'eval'

     >>> import ast
    >>> ast.literal_eval("545.2222")
    545.2222
    >>> ast.literal_eval("31")
    31
     
    ответ дан wim, с репутацией 148234, 1.03.2012
  • 75 рейтинг
    float(x) if '.' in x else int(x)
    
    ответ дан Dino Viehland, с репутацией 1131, 19.12.2008
  • 48 рейтинг

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

    Вы должны рассмотреть возможность запятых в строчном представлении числа, для случаев, подобных float("545,545.2222") которые вызывают исключение. Вместо этого используйте методы в locale для преобразования строк в числа и правильной интерпретации запятых. Метод locale.atof преобразуется в float за один шаг после того, как языковой стандарт был установлен для соглашения о требуемом количестве.

    Пример 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 также доступен, но аргумент должен быть целым числом.

    ответ дан Mark Chackerian, с репутацией 7840, 23.07.2013
  • 23 рейтинг

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

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

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

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

    ответ дан Chris Cameron, с репутацией 6158, 19.12.2008
  • 22 рейтинг

    Если вы не прочь от сторонних модулей, вы можете проверить модуль fastnumbers . Он предоставляет функцию fast_real, которая делает именно то, что задает этот вопрос, и делает это быстрее, чем реализация pure-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
     
    ответ дан SethMMorton, с репутацией 19486, 14.08.2014
  • 18 рейтинг

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

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

    "545.2222" to float:

     >>> float("545.2222")
    545.2222
     

    "31" - целому числу:

     >>> int("31")
    31
     

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

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

    Non-Decimal (т.е. Integer) Литералы из других баз

    Если ваша мотивация состоит в том, чтобы ваш собственный код явно отображал жестко заданные конкретные значения, вам, возможно, не нужно будет конвертировать из баз - вы можете позволить 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
     
    ответ дан Aaron Hall, с репутацией 153756, 23.07.2015
  • 17 рейтинг

    Вопрос кажется немного старым. Но позвольте мне предложить функцию parseStr, которая делает нечто похожее, то есть возвращает целое число или float, и если данная строка 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'
     
    ответ дан krzym, с репутацией 213, 28.09.2011
  • 15 рейтинг

    float("545.2222") и int(float("545.2222"))

    ответ дан codelogic, с репутацией 51493, 19.12.2008
  • 13 рейтинг

    Анализатор 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'>
     
    ответ дан Rafe, с репутацией 800, 16.04.2013
  • 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
    
    ответ дан Totoro, с репутацией 581, 8.10.2015
  • 8 рейтинг

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

     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
     
    ответ дан Shameem, с репутацией 851, 9.07.2017
  • 7 рейтинг
    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')
    
    ответ дан Jerry T, с репутацией 544, 9.10.2015
  • 7 рейтинг

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

    Т.е. 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)
     
    ответ дан Nick, с репутацией 17423, 21.10.2010
  • 3 рейтинг

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

     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
     
    ответ дан Sławomir Lenart, с репутацией 1575, 12.07.2017
  • 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
     
    ответ дан Kuzeko, с репутацией 644, 18.05.2017
  • 3 рейтинг

    Python обладает такой большой гибкостью в синтаксическом анализе в одном лайнере.

     str = "545.2222"
    print ("int: ", + int(float(a)))
    print ("float: ", +(float(a)))
     
    ответ дан Harry_pb, с репутацией 1441, 1.03.2018
  • 2 рейтинг

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

    Например:

     >>>float("23.333")
       23.333
     

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

    ответ дан qwerty12345, с репутацией 43, 1.07.2018
  • 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()
     

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

    ответ дан SeasonalShot, с репутацией 714, 9.10.2016
  • 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'>
     
    ответ дан ateymuri, с репутацией 1177, 11.09.2016
  • -13 рейтинг

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

     def parseIntOrFloat( aString ):
        return eval( aString )
     

    Он работает так ...

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

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

    ответ дан S.Lott, с репутацией 309793, 19.12.2008