число - функция int python




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

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

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

"545.2222" чтобы плавать:

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

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

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


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

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


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

str = "545.2222"
print ("int: ", + int(float(a)))
print ("float: ", +(float(a)))

Анализатор 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'>

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

def parseIntOrFloat( aString ):
    return eval( aString )

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

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

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


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

Т.е. 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)

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

Например:

>>>float("23.333")
   23.333

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


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

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

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

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


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

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

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

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


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

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

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

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

Это исправленная версия https://.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

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

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

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






integer