Answers:
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545
int(a)
,但int(float(a))
?
int(a)
会给出错误消息,该字符串不是有效的整数:ValueError: invalid literal for int() with base 10: '545.222'
,但是支持从float到int的转换。
ValueError
,如果你想成为安全
def num(s):
try:
return int(s)
except ValueError:
return float(s)
/
运算符对浮点数/整数的不同结果。根据上下文,可能最好返回int或float而不是两者都返回。
try
当不可转换为float时,可以嵌套另一个以引发异常。
s = u'\u0000'
ValueError
相应的except
:P
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这样的鸭子式原型语言来编写至关重要的软件,那么您将遇到更大的问题。
UTF-8
中文字形4
一直在变化,具体取决于stackoverflow开发人员如何在其Microsoft工具栈上更改其字符编码方案。多年来,随着新的转换方案断言其新的意识形态,看到它失败是令人好奇的。但是,是的,UTF-8
东方东方数字的任何字形都不是Python浮点数。巴津加。
"- 12.3"
和"45 e6"
TypeError, ValueError
这是另一个值得一提的方法ast.literal_eval:
这可用于安全地评估包含来自不受信任来源的Python表达式的字符串,而无需自己解析值。
也就是说,一个安全的“评估”
>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31
python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>>
为了弄清为什么这是一个问题,如果您希望它不理会电话号码,而不是假设它们是数学表达式,那么这种方法不适合您。
float(x) if '.' in x else int(x)
float("nan")
是一个完全有效的浮点值,上面的答案根本
192.168.0.1
; 或"This is not a good approach. :)"
您应该考虑数字的字符串表示形式中可能出现逗号的情况,例如 float("545,545.2222")
抛出异常的情况。而是使用in 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
也可用,但参数应为整数。
x = '1'; locale.atof(x)
返回。1.0
1
locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
locale.atoi
尝试包装并locale.atof
在异常上使用-可能更具可读性。)
如果您不喜欢第三方模块,则可以签出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
在Python中,如何将“ 545.2222”之类的数字字符串解析为其对应的浮点值542.2222?还是将字符串“ 31”解析为整数31? 我只想知道如何将float字符串解析为float,以及将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
如果您不预先知道基础,但是您知道它们将具有正确的前缀,那么如果您通过0
作为基础,Python可以为您推断出这个前缀:
>>> 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中看到一个以0开头的整数,则这是(不建议使用的)八进制语法。
>>> 037
31
这很糟糕,因为看起来值应该是37
。因此,在Python 3中,它现在引发了SyntaxError
:
>>> 037
File "<stdin>", line 1
037
^
SyntaxError: invalid token
使用0o
前缀将Python 2八进制转换为在2和3中均可使用的八进制:
>>> 0o37
31
这个问题似乎有点老了。但是让我建议一个函数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'
1e3
是python中的数字,但根据您的代码为字符串。
该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 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
except
如果您在那里什么也不做,为什么要在自己的部分加薪?float()会为您加注。
int
或float
取决于该字符串表示什么。它可能会引起解析异常或[具有某些意外行为] [1]。
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')
您需要考虑到四舍五入才能正确执行此操作。
即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)
int
和的两个情况float
。如果需要,它将n
是字符串时的异常。也许您的意思是:当需要int
结果时,round
应在转换为float后执行。如果函数总是返回一个int,那么您就不需要剩下的部分-整个函数体可以是int(round(float(input)))
。如果函数尽可能返回一个int值,否则返回一个float值,那么javier的原始解决方案是正确的!
我很惊讶没有人提到正则表达式,因为有时必须在转换为数字之前准备好字符串并对其进行规范化
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
或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
将您的字符串传递给此函数:
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'>
处理十六进制,八进制,二进制,十进制和浮点数
该解决方案将处理数字的所有字符串约定(我所知道的全部)。
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)
这是将转换任何一个函数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
eval()
是这个问题的很好解决方案。它不需要检查数字是int还是float,它只给出相应的等价物。如果需要其他方法,请尝试
if '.' in string:
print(float(string))
else:
print(int(string))
try-except也可以用作替代方法。尝试在try块中将字符串转换为int。如果该字符串是一个浮点值,它将抛出一个错误,该错误将在except块中捕获,像这样
try:
print(int(string))
except:
print(float(string))
这是您问题的另一种解释(提示:含糊)。您可能正在寻找这样的东西:
def parseIntOrFloat( aString ):
return eval( aString )
它是这样的...
>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545
从理论上讲,存在注入漏洞。字符串可以是例如"import os; os.abort()"
。但是,由于没有关于字符串来自何处的任何背景,因此可能是理论上的推测。由于问题很模糊,因此尚不清楚此漏洞是否确实存在。
eval()
其速度也是的3倍以上try: int(s) except: float(s)
。
eval
是一种不好的做法(您必须知道,因为您拥有310k信誉)
type(my_object)
就可以了。通常可以将结果称为进行转换的函数。例如,type(100)
结果为int
,因此您可以调用int(my_object)
尝试将其转换my_object
为整数。这并不总是有效,但是在编码时是一个很好的“第一猜测”。