Как в Python разобрать числовую строку типа "545.2222"
до соответствующего ей значения float, 545.2222
? Или разобрать строку "31"
до целого числа 31
?
Я просто хочу знать, как разобрать float str
в float
, и (отдельно) int str
в int
.
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545
def num(s):
try:
return int(s)
except ValueError:
return float(s)
.
def is_float(value):
try:
float(value)
return True
except:
return False
Более длинное и точное название для этой функции могло бы быть: is_convertible_to_float(value)
.
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
Вы думаете, что знаете, что такое числа? Вы не так хороши, как думаете! Не большой сюрприз.
Ловля широких исключений таким способом, убийство канареек и пожирание исключения создает крошечный шанс, что правильный float как строка вернет false. Строка кода float(...)
может не сработать по любой из тысячи причин, не имеющих никакого отношения к содержимому строки. Но если вы пишете критически важное для жизни программное обеспечение на прототипном языке типа Python, то у вас есть гораздо более серьезные проблемы.
Это еще один метод, который заслуживает того, чтобы быть упомянутым здесь, АСТ.literal_eval:
это может быть использовано для безопасной оценки строк, содержащих выражения Python из ненадежных источников без необходимости разбора значений себя.
То есть, сейфом 'ивала'
>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31
float(x) if '.' in x else int(x)
Вы должны рассмотреть возможность запятых в строковое представление числа, за исключением случаев, как поплавок (на"545,545.2222", У), который бросает исключение. Вместо этого используйте методы в
языкдля преобразования строк в числа и правильно интерпретировать запятые. В
язык.способ это` преобразуется в 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
Язык метод`.Атой также доступны, но аргумент должен быть целым числом.
Если вы еще'т прочь сторонние модули, вы можете проверить 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
Пользователи codelogic и harley правы, но имейте в виду, что если вы знаете, что строка является целым числом (например, 545), вы можете вызвать int("545") без предварительного приведения к float.
Если ваши строки находятся в списке, вы также можете использовать функцию map.
>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>
Она подходит только в том случае, если все они одного типа.
Вопрос, кажется, немного старый. Но позвольте мне предложить функцию, parseStr, что делает что-то подобное, то есть возвращает integer или 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'
в Python, как я могу анализировать числовую строку как-то "545.2222" на его соответствующее значение типа float, 542.2222? Или разобрать строку на "31" на целое число, 31? Я просто хочу знать, как разобрать строку поплавка к поплавку, и (отдельно) тип int string к int.
Это's хорошо, что вы просите делать их отдельно. Если вы'вновь смешивая их, вы можете быть настраиваете себя на проблемы в будущем. Ответ прост:
в"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
Если вы Don'т знать базу заранее, но вы знаете, они будут иметь правильный префикс, питон может определить это для вас, если вы проходите 0
в качестве базового:
>>> int("0b11111", 0)
31
>>> int('0o37', 0)
31
>>> int('0x1f', 0)
31
Если ваша мотивация, чтобы иметь свой собственный кодекс четко представлять жестко определенных значений, однако, возможно, Вам не потребуется конвертировать из базы - вы можете позволить питона сделает это за вас автоматически с правильным синтаксисом.
Вы можете использовать по поводу префиксов, чтобы получить автоматическое преобразование для чисел с следующие литералы. Эти действительны для Python 2 и 3:
Двоичный префикс 0В
>>> 0b11111
31
Восьмеричной, префикс 0о
>>> 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
Если вы видите число, которое начинается с 0, в Python 2, это (устарело) восьмеричной синтаксис.
>>> 037
31
Это плохо, потому что похоже, что значение должно быть 37
. Так что в Python 3, это сейчас поднимает синтаксис ошибка
:
>>> 037
File "<stdin>", line 1
037
^
SyntaxError: invalid token
Преобразовать в Python 2 octals в octals, которые работают в 2 и 3 с 0о
префикс:
>>> 0o37
31
В формате YAML парсер может помочь вам выяснить, какой тип вашей строки. Использовать в YAML.нагрузки(), и затем вы можете использовать тип
(результат)` для проверки типа:
>>> 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'>
Я использую эту функцию для этого
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
деф Нум(ы): на " Агушу&; на"ням(с) кол-во(3),ням(3.7)-->3 Нум('3')-->3, чис('3.7')-->3.7 Нум('3,700')-->ValueError кол-во('3а'),ням('А3'),-->ValueError кол-во('3e4') --> 30000.0 " и" и"в попробуйте: возвращает значение типа int(с) кроме ValueError: попробуйте: возвращение поплавка(с) кроме ValueError: поднять ValueError('аргумент не является строкой номер')
Нужно учитывать округления, чтобы сделать это правильно.
Т. е. инт(5.1) => 5 инт(5.6) => 5 -- неправильно, должно быть 6, поэтому мы делаем инт(5.6 + 0.5) => 6
def convert(n):
try:
return int(n)
except ValueError:
return float(n + 0.5)
Для приведения в Python использовать функции конструктора типа, передавая строку (или другое значение, которое вы пытаетесь разыграть) в качестве параметра.
Например:
>>>float("23.333")
23.333
За кулисами, Python-это призвание объектовплавать метод, который возвращает представление поплавок параметра. Это особенно мощный, как вы можете определить собственные типы (классов) с метод__плавать__
так что он может быть преобразован в float с помощью поплавка(объект MyObject).
Я удивлен, никто не упомянул регулярное выражение, потому что иногда строки должны быть подготовлены и нормализуется до приведения в номер
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://stackoverflow.com/a/33017514/5973334
В этом попытаемся разобрать строку и возвращать int
или поплавок
в зависимости от того, какая строка представляет.
Он может вырасти разбора исключения или есть некоторые неожиданные поведения.
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
Использование:
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()
Это наиболее подходящие для Python способ, который я мог придумать.