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

Question

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

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

Answer 1

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

Answer 2

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

Answer 3

Метод 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, тогда у вас гораздо большие проблемы.

Answer 4

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

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

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

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

Answer 5

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

Answer 6

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

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

Answer 7

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

Answer 8

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

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

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

Хорошо, если они все одного типа.

Answer 9

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

Answer 10

В 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