检查字符串是否可以在 Python 中表示为数字的最佳方法是什么？
我目前拥有的功能是：
def is_number(s):
try:
float(s)
return True
except ValueError:
return False
这不仅丑陋和缓慢，而且看起来很笨重。但是，我还没有找到更好的方法，因为float()在 main 函数中调用更糟糕。
Daniel Goldberg
问问题
1577075 次
38 回答
1708
如果您正在寻找解析（正，无符号）整数而不是浮点数，您可以使用该isdigit()函数来处理字符串对象。
>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False
字符串方法 -isdigit() : Python2 , Python3
还有一些关于 Unicode 字符串的东西，我对 Unicode 不太熟悉 - 是十进制/十进制
于 2008-12-09T20:15:18.377 回答
764
这不仅丑陋而且缓慢
我对两者都有争议。
正则表达式或其他字符串解析方法会更丑陋且更慢。
我不确定有什么比上述更快。它调用函数并返回。Try/Catch 不会引入太多开销，因为最常见的异常是在没有大量搜索堆栈帧的情况下捕获的。
问题是任何数值转换函数都有两种结果
- 一个数字，如果该数字有效
- 一个状态码（例如，通过 errno）或异常表明没有有效的数字可以被解析。
C（例如）以多种方式解决了这个问题。Python 清楚而明确地列出了它。
我认为你这样做的代码是完美的。
于 2008-12-09T20:30:48.800 回答
256
TL;DR最好的解决方案是s.replace('.','',1).isdigit()
我做了一些基准比较不同的方法
def is_number_tryexcept(s):
""" Returns True is string is a number. """
try:
float(s)
return True
except ValueError:
return False
import re
def is_number_regex(s):
""" Returns True is string is a number. """
if re.match("^\d+?\.\d+?$", s) is None:
return s.isdigit()
return True
def is_number_repl_isdigit(s):
""" Returns True is string is a number. """
return s.replace('.','',1).isdigit()
如果字符串不是数字，则 except-block 非常慢。但更重要的是，try-except 方法是唯一能正确处理科学记数法的方法。
funcs = [
is_number_tryexcept,
is_number_regex,
is_number_repl_isdigit
]
a_float = '.1234'
print('Float notation ".1234" is not supported by:')
for f in funcs:
if not f(a_float):
print('\t -', f.__name__)
浮点表示法“.1234”不受以下支持：
- is_number_regex
scientific1 = '1.000000e+50'
scientific2 = '1e50'
print('Scientific notation "1.000000e+50" is not supported by:')
for f in funcs:
if not f(scientific1):
print('\t -', f.__name__)
print('Scientific notation "1e50" is not supported by:')
for f in funcs:
if not f(scientific2):
print('\t -', f.__name__)
科学记数法“1.000000e+50”不支持：
- is_number_regex
- is_number_repl_isdigit
科学记数法“1e50”不支持：
- is_number_regex
- is_number_repl_isdigit
编辑：基准测试结果
import timeit
test_cases = ['1.12345', '1.12.345', 'abc12345', '12345']
times_n = {f.__name__:[] for f in funcs}
for t in test_cases:
for f in funcs:
f = f.__name__
times_n[f].append(min(timeit.Timer('%s(t)' %f,
'from __main__ import %s, t' %f)
.repeat(repeat=3, number=1000000)))
测试了以下功能
from re import match as re_match
from re import compile as re_compile
def is_number_tryexcept(s):
""" Returns True is string is a number. """
try:
float(s)
return True
except ValueError:
return False
def is_number_regex(s):
""" Returns True is string is a number. """
if re_match("^\d+?\.\d+?$", s) is None:
return s.isdigit()
return True
comp = re_compile("^\d+?\.\d+?$")
def compiled_regex(s):
""" Returns True is string is a number. """
if comp.match(s) is None:
return s.isdigit()
return True
def is_number_repl_isdigit(s):
""" Returns True is string is a number. """
return s.replace('.','',1).isdigit()
于 2014-05-13T19:28:03.887 回答
78
您可能需要考虑一个例外：字符串 'NaN'
如果您希望 is_number 为“NaN”返回 FALSE，则此代码将不起作用，因为 Python 会将其转换为非数字的数字表示（讨论身份问题）：
>>> float('NaN')
nan
否则，我实际上应该感谢您提供我现在广泛使用的代码。:)
G。
于 2010-09-01T14:06:08.107 回答
65
这个怎么样：
'3.14'.replace('.','',1).isdigit()
仅当有一个或没有“。”时才会返回 true。在数字串中。
'3.14.5'.replace('.','',1).isdigit()
将返回 false
编辑：刚刚看到另一条评论......可以.replace(badstuff,'',maxnum_badstuff)为其他情况添加一个。如果您传递的是盐而不是任意调味品（参考：xkcd#974），这会很好：P
于 2012-05-25T22:22:32.990 回答
47
在 Alfe 指出您不需要单独检查浮点数后更新，因为复杂的句柄：
def is_number(s):
try:
complex(s) # for int, long, float and complex
except ValueError:
return False
return True
之前说过：在一些罕见的情况下你可能还需要检查复数（例如 1+2i），它不能用浮点数表示：
def is_number(s):
try:
float(s) # for int, long and float
except ValueError:
try:
complex(s) # for complex
except ValueError:
return False
return True
于 2010-07-26T13:10:15.373 回答
43
这不仅丑陋而且缓慢，而且看起来很笨重。
可能需要一些时间来适应，但这是 Python 的做法。正如已经指出的那样，替代方案更糟。但是以这种方式做事还有另一个优点：多态性。
鸭子打字背后的核心思想是“如果它像鸭子一样走路和说话，那么它就是鸭子”。如果您决定需要对字符串进行子类化，以便更改确定某些内容是否可以转换为浮点数的方式，该怎么办？或者，如果您决定完全测试其他对象怎么办？你可以做这些事情而不必改变上面的代码。
其他语言通过使用接口来解决这些问题。我将保存对另一个线程更好的解决方案的分析。不过，关键是 python 绝对是等式的鸭子类型，如果你打算在 Python 中进行大量编程，你可能不得不习惯这样的语法（但这并不意味着你当然必须喜欢它）。
您可能需要考虑的另一件事：与许多其他语言相比，Python 在抛出和捕获异常方面非常快（例如，比 .Net 快 30 倍）。哎呀，语言本身甚至会抛出异常来传达非异常的正常程序条件（每次使用 for 循环时）。因此，在您注意到一个重大问题之前，我不会太担心这段代码的性能方面。
于 2008-12-11T04:56:26.047 回答
31
为了int使用这个：
>>> "1221323".isdigit()
True
但是因为float我们需要一些技巧;-)。每个浮点数都有一个点...
>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False
同样对于负数只需添加lstrip()：
>>> '-12'.lstrip('-')
'12'
现在我们得到了一个通用的方法：
>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False
于 2015-09-08T08:42:14.193 回答
23
该答案提供了具有示例功能的分步指南，以查找字符串是：
- 正整数
- 正/负 - 整数/浮点数
- 检查数字时如何丢弃“NaN”（不是数字）字符串？
检查字符串是否为正整数
您可以使用str.isdigit()来检查给定的字符串是否为正整数。
样本结果：
# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False
检查字符串为正/负 - 整数/浮点
str.isdigit()False如果字符串是负数或浮点数，则返回。例如：
# returns `False` for float
>>> '123.3'.isdigit()
False
# returns `False` for negative number
>>> '-123'.isdigit()
False
如果您还想检查负整数 和float，那么您可以编写一个自定义函数来检查它：
def is_number(n):
try:
float(n) # Type-casting the string to `float`.
# If string is not a valid `float`,
# it'll raise `ValueError` exception
except ValueError:
return False
return True
样品运行：
>>> is_number('123') # positive integer number
True
>>> is_number('123.4') # positive float number
True
>>> is_number('-123') # negative integer number
True
>>> is_number('-123.4') # negative `float` number
True
>>> is_number('abc') # `False` for "some random" string
False
在检查数字时丢弃“NaN”（不是数字）字符串
上述函数将返回True“NAN”（非数字）字符串，因为对于 Python，它是表示它不是数字的有效浮点数。例如：
>>> is_number('NaN')
True
为了检查数字是否为“NaN”，您可以使用math.isnan()：
>>> import math
>>> nan_num = float('nan')
>>> math.isnan(nan_num)
True
或者，如果您不想导入其他库来检查它，那么您可以简单地通过使用==. False当nanfloat 与自身进行比较时， Python 返回。例如：
# `nan_num` variable is taken from above example
>>> nan_num == nan_num
False
因此，上面的函数is_number可以更新为返回False为"NaN"：
def is_number(n):
is_number = True
try:
num = float(n)
# check for "nan" floats
is_number = num == num # or use `math.isnan(num)`
except ValueError:
is_number = False
return is_number
样品运行：
>>> is_number('Nan') # not a number "Nan" string
False
>>> is_number('nan') # not a number string "nan" with all lower cased
False
>>> is_number('123') # positive integer
True
>>> is_number('-123') # negative integer
True
>>> is_number('-1.12') # negative `float`
True
>>> is_number('abc') # "some random" string
False
PS：每次检查的每个操作都取决于号码的类型，都会带来额外的开销。选择is_number适合您要求的功能版本。
于 2018-02-11T08:34:28.830 回答
17
对于非数字字符串，try: except:实际上比正则表达式慢。对于有效数字的字符串，正则表达式速度较慢。因此，适当的方法取决于您的输入。
如果您发现自己处于性能绑定状态，您可以使用一个名为fastnumbers的新第三方模块，该模块提供一个名为isfloat的函数。完全公开，我是作者。我已将其结果包含在下面的时间安排中。
from __future__ import print_function
import timeit
prep_base = '''\
x = 'invalid'
y = '5402'
z = '4.754e3'
'''
prep_try_method = '''\
def is_number_try(val):
try:
float(val)
return True
except ValueError:
return False
'''
prep_re_method = '''\
import re
float_match = re.compile(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$').match
def is_number_re(val):
return bool(float_match(val))
'''
fn_method = '''\
from fastnumbers import isfloat
'''
print('Try with non-number strings', timeit.timeit('is_number_try(x)',
prep_base + prep_try_method), 'seconds')
print('Try with integer strings', timeit.timeit('is_number_try(y)',
prep_base + prep_try_method), 'seconds')
print('Try with float strings', timeit.timeit('is_number_try(z)',
prep_base + prep_try_method), 'seconds')
print()
print('Regex with non-number strings', timeit.timeit('is_number_re(x)',
prep_base + prep_re_method), 'seconds')
print('Regex with integer strings', timeit.timeit('is_number_re(y)',
prep_base + prep_re_method), 'seconds')
print('Regex with float strings', timeit.timeit('is_number_re(z)',
prep_base + prep_re_method), 'seconds')
print()
print('fastnumbers with non-number strings', timeit.timeit('isfloat(x)',
prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with integer strings', timeit.timeit('isfloat(y)',
prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with float strings', timeit.timeit('isfloat(z)',
prep_base + 'from fastnumbers import isfloat'), 'seconds')
print()
Try with non-number strings 2.39108395576 seconds
Try with integer strings 0.375686168671 seconds
Try with float strings 0.369210958481 seconds
Regex with non-number strings 0.748660802841 seconds
Regex with integer strings 1.02021503448 seconds
Regex with float strings 1.08564686775 seconds
fastnumbers with non-number strings 0.174362897873 seconds
fastnumbers with integer strings 0.179651021957 seconds
fastnumbers with float strings 0.20222902298 seconds
如你看到的
try: except:对于数字输入来说速度很快，但对于无效输入来说非常慢- 当输入无效时，正则表达式非常有效
fastnumbers在这两种情况下都获胜
于 2014-08-14T03:34:08.403 回答
14
只是模仿 C#
在 C# 中有两个不同的函数可以处理标量值的解析：
- Float.Parse()
- Float.TryParse()
浮动.解析（）：
def parse(string):
try:
return float(string)
except Exception:
throw TypeError
注意：如果您想知道为什么我将异常更改为 TypeError，请参阅文档。
float.try_parse():
def try_parse(string, fail=None):
try:
return float(string)
except Exception:
return fail;
注意：您不想返回布尔值“False”，因为它仍然是一种值类型。没有更好，因为它表示失败。当然，如果您想要不同的东西，您可以将失败参数更改为您想要的任何内容。
要扩展 float 以包含“parse()”和“try_parse()”，您需要对“float”类进行猴子补丁以添加这些方法。
如果你想尊重预先存在的功能，代码应该是这样的：
def monkey_patch():
if(!hasattr(float, 'parse')):
float.parse = parse
if(!hasattr(float, 'try_parse')):
float.try_parse = try_parse
旁注：我个人更喜欢称它为 Monkey Punching，因为当我这样做时感觉就像我在滥用语言，但 YMMV。
用法：
float.parse('giggity') // throws TypeException
float.parse('54.3') // returns the scalar value 54.3
float.tryParse('twank') // returns None
float.tryParse('32.2') // returns the scalar value 32.2
伟大的圣人 Pythonas 对教廷 Sharpisus 说：“你能做的任何事我都能做得更好；我能做的任何事都比你更好。”
于 2012-02-18T01:35:32.540 回答
14
我知道这是特别古老的，但我会添加一个答案，我相信它涵盖了最高投票答案中缺少的信息，这对任何发现此问题的人来说都非常有价值：
对于以下每种方法，如果您需要接受任何输入，请将它们与计数连接起来。（假设我们使用整数的声音定义而不是 0-255 等）
x.isdigit()
适用于检查 x 是否为整数。
x.replace('-','').isdigit()
适用于检查 x 是否为负数。（检查 - 在第一个位置）
x.replace('.','').isdigit()
适用于检查 x 是否为小数。
x.replace(':','').isdigit()
适用于检查 x 是否为比率。
x.replace('/','',1).isdigit()
适用于检查 x 是否为分数。
于 2016-01-05T15:21:27.610 回答
12
转换为 float 并捕获 ValueError 可能是最快的方法，因为 float() 就是专门为此而设计的。任何其他需要字符串解析（正则表达式等）的东西都可能会更慢，因为它没有针对此操作进行调整。我的 0.02 美元。
于 2008-12-09T20:31:49.967 回答
11
您可以使用 Unicode 字符串，它们有一种方法可以满足您的需求：
>>> s = u"345"
>>> s.isnumeric()
True
或者：
>>> s = "345"
>>> u = unicode(s)
>>> u.isnumeric()
True
于 2013-03-04T16:12:38.673 回答
9
因此，综上所述，检查 Nan、无穷大和复数（似乎它们是用 j 指定的，而不是 i，即 1+2j），结果是：
def is_number(s):
try:
n=str(float(s))
if n == "nan" or n=="inf" or n=="-inf" : return False
except ValueError:
try:
complex(s) # for complex
except ValueError:
return False
return True
于 2012-03-23T16:10:09.420 回答
9
我想看看哪种方法最快。check_replace总体而言，该函数给出了最好和最一致的结果。该check_exception函数给出了最快的结果，但前提是没有引发异常 - 这意味着它的代码是最有效的，但引发异常的开销非常大。
请注意，检查是否成功转换是唯一准确的方法，例如，这适用于check_exception但其他两个测试函数将返回 False 以获得有效的浮点数：
huge_number = float('1e+100')
这是基准代码：
import time, re, random, string
ITERATIONS = 10000000
class Timer:
def __enter__(self):
self.start = time.clock()
return self
def __exit__(self, *args):
self.end = time.clock()
self.interval = self.end - self.start
def check_regexp(x):
return re.compile("^\d*\.?\d*$").match(x) is not None
def check_replace(x):
return x.replace('.','',1).isdigit()
def check_exception(s):
try:
float(s)
return True
except ValueError:
return False
to_check = [check_regexp, check_replace, check_exception]
print('preparing data...')
good_numbers = [
str(random.random() / random.random())
for x in range(ITERATIONS)]
bad_numbers = ['.' + x for x in good_numbers]
strings = [
''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(random.randint(1,10)))
for x in range(ITERATIONS)]
print('running test...')
for func in to_check:
with Timer() as t:
for x in good_numbers:
res = func(x)
print('%s with good floats: %s' % (func.__name__, t.interval))
with Timer() as t:
for x in bad_numbers:
res = func(x)
print('%s with bad floats: %s' % (func.__name__, t.interval))
with Timer() as t:
for x in strings:
res = func(x)
print('%s with strings: %s' % (func.__name__, t.interval))
以下是在 2017 MacBook Pro 13 上使用 Python 2.7.10 的结果：
check_regexp with good floats: 12.688639
check_regexp with bad floats: 11.624862
check_regexp with strings: 11.349414
check_replace with good floats: 4.419841
check_replace with bad floats: 4.294909
check_replace with strings: 4.086358
check_exception with good floats: 3.276668
check_exception with bad floats: 13.843092
check_exception with strings: 15.786169
以下是 Python 3.6.5 在 2017 MacBook Pro 13 上的结果：
check_regexp with good floats: 13.472906000000009
check_regexp with bad floats: 12.977665000000016
check_regexp with strings: 12.417542999999995
check_replace with good floats: 6.011045999999993
check_replace with bad floats: 4.849356
check_replace with strings: 4.282754000000011
check_exception with good floats: 6.039081999999979
check_exception with bad floats: 9.322753000000006
check_exception with strings: 9.952595000000002
以下是 PyPy 2.7.13 在 2017 MacBook Pro 13 上的结果：
check_regexp with good floats: 2.693217
check_regexp with bad floats: 2.744819
check_regexp with strings: 2.532414
check_replace with good floats: 0.604367
check_replace with bad floats: 0.538169
check_replace with strings: 0.598664
check_exception with good floats: 1.944103
check_exception with bad floats: 2.449182
check_exception with strings: 2.200056
于 2013-01-16T06:09:37.350 回答
9
输入可能如下：
a="50"
b=50
c=50.1
d="50.1"
1-一般输入：
这个函数的输入可以是一切！
查找给定变量是否为数字。数字字符串由可选的符号、任意位数、可选的小数部分和可选的指数部分组成。因此 +0123.45e6 是一个有效的数值。不允许使用十六进制（例如 0xf4c3b00c）和二进制（例如 0b10100111001）表示法。
is_numeric函数
import ast
import numbers
def is_numeric(obj):
if isinstance(obj, numbers.Number):
return True
elif isinstance(obj, str):
nodes = list(ast.walk(ast.parse(obj)))[1:]
if not isinstance(nodes[0], ast.Expr):
return False
if not isinstance(nodes[-1], ast.Num):
return False
nodes = nodes[1:-1]
for i in range(len(nodes)):
#if used + or - in digit :
if i % 2 == 0:
if not isinstance(nodes[i], ast.UnaryOp):
return False
else:
if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
return False
return True
else:
return False
测试：
>>> is_numeric("54")
True
>>> is_numeric("54.545")
True
>>> is_numeric("0x45")
True
is_float函数
查找给定变量是否为浮点数。浮点字符串由可选符号、任意数量的数字、...
import ast
def is_float(obj):
if isinstance(obj, float):
return True
if isinstance(obj, int):
return False
elif isinstance(obj, str):
nodes = list(ast.walk(ast.parse(obj)))[1:]
if not isinstance(nodes[0], ast.Expr):
return False
if not isinstance(nodes[-1], ast.Num):
return False
if not isinstance(nodes[-1].n, float):
return False
nodes = nodes[1:-1]
for i in range(len(nodes)):
if i % 2 == 0:
if not isinstance(nodes[i], ast.UnaryOp):
return False
else:
if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
return False
return True
else:
return False
测试：
>>> is_float("5.4")
True
>>> is_float("5")
False
>>> is_float(5)
False
>>> is_float("5")
False
>>> is_float("+5.4")
True
什么是ast？
2-如果您确信变量内容是String：
使用str.isdigit()方法
>>> a=454
>>> a.isdigit()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit'
>>> a="454"
>>> a.isdigit()
True
3-数字输入：
检测int值：
>>> isinstance("54", int)
False
>>> isinstance(54, int)
True
>>>
检测浮动：
>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True
于 2018-10-06T07:23:24.067 回答
7
True如果字符串中的所有字符都是数字字符，并且至少有一个字符，则返回，False否则。数字字符包括数字字符，以及所有具有 Unicode 数值属性的字符，例如 U+2155、VULGAR FRACTION ONE FIFTH。形式上，数字字符是具有属性值 Numeric_Type=Digit、Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
True如果字符串中的所有字符都是十进制字符并且至少有一个字符，则返回，False否则。十进制字符是可用于形成以 10 为底的数字的字符，例如 U+0660、ARABIC-INDIC DIGIT ZERO。形式上，十进制字符是 Unicode 通用类别“Nd”中的字符。
两者都可用于 Python 3.0 中的字符串类型。
于 2020-04-15T21:48:48.523 回答
6
在浮点数的最一般情况下，人们希望处理整数和小数。我们以字符串"1.1"为例。
我会尝试以下方法之一：
1.> 非数字（）
word = "1.1"
"".join(word.split(".")).isnumeric()
>>> True
2.> isdigit()
word = "1.1"
"".join(word.split(".")).isdigit()
>>> True
3.> isdecimal()
word = "1.1"
"".join(word.split(".")).isdecimal()
>>> True
速度：
► 所有上述方法都具有相似的速度。
%timeit "".join(word.split(".")).isnumeric()
>>> 257 ns ± 12 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit "".join(word.split(".")).isdigit()
>>> 252 ns ± 11 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit "".join(word.split(".")).isdecimal()
>>> 244 ns ± 7.17 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
于 2020-12-06T03:31:53.750 回答
5
我需要确定一个字符串是否转换为基本类型（float、int、str、bool）。在互联网上找不到任何东西后，我创建了这个：
def str_to_type (s):
""" Get possible cast type for a string
Parameters
----------
s : string
Returns
-------
float,int,str,bool : type
Depending on what it can be cast to
"""
try:
f = float(s)
if "." not in s:
return int
return float
except ValueError:
value = s.upper()
if value == "TRUE" or value == "FALSE":
return bool
return type(s)
例子
str_to_type("true") # bool
str_to_type("6.0") # float
str_to_type("6") # int
str_to_type("6abc") # str
str_to_type(u"6abc") # unicode
您可以捕获类型并使用它
s = "6.0"
type_ = str_to_type(s) # float
f = type_(s)
于 2014-07-03T17:12:27.923 回答
5
我认为您的解决方案很好，但是有一个正确的正则表达式实现。
对于这些我认为不合理的答案，似乎确实有很多正则表达式讨厌，正则表达式可以相当干净、正确和快速。这真的取决于你想要做什么。最初的问题是如何“检查字符串是否可以表示为数字（浮点数）”（根据您的标题）。据推测，一旦您检查了数字/浮点值是否有效，您就会想使用它，在这种情况下，您的 try/except 很有意义。但是，如果出于某种原因，您只想验证字符串是否为数字那么正则表达式也可以正常工作，但很难正确。我认为到目前为止，大多数正则表达式的答案，例如，没有正确解析没有整数部分（例如“.7”）的字符串，就python而言这是一个浮点数。在不需要小数部分的单个正则表达式中检查这有点棘手。我已经包含了两个正则表达式来显示这一点。
它确实提出了一个有趣的问题，即“数字”是什么。您是否包含在 python 中作为浮点数有效的“inf”？或者您是否包含“数字”但可能无法在 python 中表示的数字（例如大于浮点最大值的数字）。
解析数字的方式也有歧义。例如，“--20”呢？这是一个“数字”吗？这是代表“20”的合法方式吗？Python 会让你执行 "var = --20" 并将其设置为 20（虽然这实际上是因为它把它视为一个表达式），但 float("--20") 不起作用。
无论如何，在没有更多信息的情况下，这是一个正则表达式，我相信它涵盖了所有整数和浮点数，因为 python 解析它们。
# Doesn't properly handle floats missing the integer part, such as ".7"
SIMPLE_FLOAT_REGEXP = re.compile(r'^[-+]?[0-9]+\.?[0-9]+([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56" # sign (-)
# integer (12)
# mantissa (34)
# exponent (E+56)
# Should handle all floats
FLOAT_REGEXP = re.compile(r'^[-+]?([0-9]+|[0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?$')
# Example "-12.34E+56" # sign (-)
# integer (12)
# OR
# int/mantissa (12.34)
# exponent (E+56)
def is_float(str):
return True if FLOAT_REGEXP.match(str) else False
一些示例测试值：
True <- +42
True <- +42.42
False <- +42.42.22
True <- +42.42e22
True <- +42.42E-22
False <- +42.42e-22.8
True <- .42
False <- 42nope
在@ron-reiter 的答案中运行基准测试代码表明，这个正则表达式实际上比普通正则表达式更快，并且在处理错误值方面比异常快得多，这是有道理的。结果：
check_regexp with good floats: 18.001921
check_regexp with bad floats: 17.861423
check_regexp with strings: 17.558862
check_correct_regexp with good floats: 11.04428
check_correct_regexp with bad floats: 8.71211
check_correct_regexp with strings: 8.144161
check_replace with good floats: 6.020597
check_replace with bad floats: 5.343049
check_replace with strings: 5.091642
check_exception with good floats: 5.201605
check_exception with bad floats: 23.921864
check_exception with strings: 23.755481
于 2019-05-10T21:15:01.920 回答
4
我做了一些速度测试。假设如果字符串可能是数字，则try/except策略是最快的。如果字符串不太可能是数字并且您对整数检查感兴趣，则值得做一些测试（isdigit plus heading '-'）。如果您有兴趣检查浮点数，则必须使用try/except代码来进行转义。
于 2010-10-12T07:43:19.860 回答
3
RyanN 建议
如果要为 NaN 和 Inf 返回 False，请将行更改为 x = float(s); 返回 (x == x) 和 (x - 1 != x)。这应该为除 Inf 和 NaN 之外的所有浮点数返回 True
但这并不完全有效，因为对于足够大的浮点数，x-1 == x返回 true。例如，2.0**54 - 1 == 2.0**54
于 2013-07-29T14:08:23.137 回答
3
此代码处理指数、浮点数和整数，但不使用正则表达式。
return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False
于 2018-12-16T07:12:18.193 回答
2
我正在研究一个导致我进入这个线程的问题，即如何以最直观的方式将数据集合转换为字符串和数字。在阅读了原始代码后，我意识到我需要的内容在两个方面有所不同：
1 - 如果字符串表示整数，我想要一个整数结果
2 - 我希望将数字或字符串结果粘贴到数据结构中
所以我修改了原始代码来产生这个衍生物：
def string_or_number(s):
try:
z = int(s)
return z
except ValueError:
try:
z = float(s)
return z
except ValueError:
return s
于 2014-11-09T14:06:38.993 回答
2
import re
def is_number(num):
pattern = re.compile(r'^[-+]?[-0-9]\d*\.\d*|[-+]?\.?[0-9]\d*$')
result = pattern.match(num)
if result:
return True
else:
return False
>>>: is_number('1')
True
>>>: is_number('111')
True
>>>: is_number('11.1')
True
>>>: is_number('-11.1')
True
>>>: is_number('inf')
False
>>>: is_number('-inf')
False
于 2018-08-02T11:06:14.207 回答
1
这是我的简单方法。假设我正在循环一些字符串，如果它们是数字，我想将它们添加到数组中。
try:
myvar.append( float(string_to_check) )
except:
continue
如果结果是数字，则将 myvar.apppend 替换为您想要对字符串执行的任何操作。这个想法是尝试使用 float() 操作并使用返回的错误来确定字符串是否为数字。
于 2009-07-16T17:45:12.710 回答
1
我也使用了您提到的函数，但很快我注意到字符串为“Nan”、“Inf”及其变体被视为数字。所以我建议你改进你的函数版本，这将在这些类型的输入上返回 false 并且不会失败“1e3”变体：
def is_float(text):
try:
float(text)
# check for nan/infinity etc.
if text.isalpha():
return False
return True
except ValueError:
return False
于 2016-10-15T21:11:09.410 回答
1
用户辅助功能：
def if_ok(fn, string):
try:
return fn(string)
except Exception as e:
return None
然后
if_ok(int, my_str) or if_ok(float, my_str) or if_ok(complex, my_str)
is_number = lambda s: any([if_ok(fn, s) for fn in (int, float, complex)])
于 2019-08-15T22:18:39.407 回答
1
我知道我迟到了，但找到了一个不在这里的解决方案：这个解决方案遵循Python中的EAFP 原则
def get_number_from_string(value):
try:
int_value = int(value)
return int_value
except ValueError:
return float(value)
解释：
如果字符串中的值为 afloat并且我首先尝试将其解析为 a int，它将抛出 a ValueError。因此，我捕获了该错误并将值解析为float并返回。
于 2021-08-14T06:24:35.223 回答
0
您可以通过返回比 True 和 False 更有用的值来以有用的方式概括异常技术。例如，此函数将引号放在字符串中，但不考虑数字。这正是我需要一个快速而肮脏的过滤器来为 R 定义一些变量。
import sys
def fix_quotes(s):
try:
float(s)
return s
except ValueError:
return '"{0}"'.format(s)
for line in sys.stdin:
input = line.split()
print input[0], '<- c(', ','.join(fix_quotes(c) for c in input[1:]), ')'
于 2013-05-24T21:36:36.950 回答
0
试试这个。
def is_number(var):
try:
if var == int(var):
return True
except Exception:
return False
于 2015-05-30T17:12:56.333 回答
0
def is_float(s):
if s is None:
return False
if len(s) == 0:
return False
digits_count = 0
dots_count = 0
signs_count = 0
for c in s:
if '0' <= c <= '9':
digits_count += 1
elif c == '.':
dots_count += 1
elif c == '-' or c == '+':
signs_count += 1
else:
return False
if digits_count == 0:
return False
if dots_count > 1:
return False
if signs_count > 1:
return False
return True
于 2020-04-03T14:39:42.333 回答
0
对于僵尸线程帖子感到抱歉 - 只是想完善代码以确保完整性......
# is_number() function - Uses re = regex library
# Should handle all normal and complex numbers
# Does not accept trailing spaces.
# Note: accepts both engineering "j" and math "i" but only the imaginary part "+bi" of a complex number a+bi
# Also accepts inf or NaN
# Thanks to the earlier responders for most the regex fu
import re
ISNUM_REGEXP = re.compile(r'^[-+]?([0-9]+|[0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?[ij]?$')
def is_number(str):
#change order if you have a lot of NaN or inf to parse
if ISNUM_REGEXP.match(str) or str == "NaN" or str == "inf":
return True
else:
return False
# A couple test numbers
# +42.42e-42j
# -42.42E+42i
print('Is it a number?', is_number(input('Gimme any number: ')))
给我任何号码：+42.42e-42j
是数字吗？真的
于 2021-02-22T03:13:18.383 回答
0
对于我非常简单且非常常见的用例：is this human written string with keyboard a number？
我通读了大多数答案，最终得到：
def isNumeric(string):
result = True
try:
x = float(string)
result = (x == x) and (x - 1 != x)
except ValueError:
result = False
return result
它将返回 False(+-)NaN和(+-)inf。
于 2021-07-16T14:23:19.923 回答
0
一种快速简单的选择是检查数据类型：
def is_number(value):
return type(value) in [int, float]
或者，如果您想测试字符串的值是否为数字：
def isNumber (value):
return True if type(value) in [int, float] else str(value).replace('.','',1).isdigit()
测试：
>>> isNumber(1)
True
>>> isNumber(1/3)
True
>>> isNumber(1.3)
True
>>> isNumber('1.3')
True
>>> isNumber('s1.3')
False
于 2022-01-05T18:20:32.803 回答
-2
我有一个类似的问题。我不想定义 isNumber 函数，而是想将字符串列表转换为浮点数，用高级术语来说是：
[ float(s) for s in list if isFloat(s)]
这是因为我们无法真正将 float(s) 与 isFloat(s) 函数分开：这两个结果应该由同一个函数返回。此外，如果 float(s) 失败，则整个过程都会失败，而不仅仅是忽略有故障的元素。另外，“0”是一个有效数字，应该包含在列表中。过滤掉不良元素时，一定不要排除0。
因此，上述理解必须以某种方式修改为：
- 如果列表中的任何元素无法转换，请忽略它并且不要抛出异常
- 避免为每个元素多次调用 float(s)（一个用于转换，另一个用于测试）
- 如果转换后的值为 0，它仍应出现在最终列表中
我提出了一个受 C# 的 Nullable 数值类型启发的解决方案。这些类型在内部由一个结构体表示，该结构体具有数值并添加一个布尔值，指示该值是否有效：
def tryParseFloat(s):
try:
return(float(s), True)
except:
return(None, False)
tupleList = [tryParseFloat(x) for x in list]
floats = [v for v,b in tupleList if b]
于 2018-03-18T00:18:41.150 回答
-3
使用以下它处理所有情况： -
import re
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' , '2.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' , '2.')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' , '.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' , '2.3sd')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' , '2.3')
于 2017-02-24T11:11:51.287 回答