我知道这是一个特别古老的问题，但我想补充一个答案，我相信这个答案涵盖了投票最高的答案中缺少的信息，对任何发现这一点的人来说都非常有价值：

对于以下每个方法，如果需要接受任何输入，请将它们与计数连接。（假设我们使用的是整数的语音定义，而不是0-255等）

x.isdigit（）用于检查x是否为整数。

x.replace（'-'，''）.idigit（）用于检查x是否为负值。（值机柜台第一位）

x.replace（'.'，''）.idigit（）用于检查x是否为小数。

x.replace（“：”，“”）.idigit（）用于检查x是否为比率。

x.replace（'/'，''，1）.idigit（）用于检查x是否为分数。

试试这个。

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False

我认为您的解决方案很好，但有一个正确的正则表达式实现。

对于这些答案，似乎有很多正则表达式的仇恨，我认为这是不合理的，正则表达式可以相当干净、正确和快速。这真的取决于你想做什么。最初的问题是如何“检查字符串是否可以表示为数字（浮点数）”（根据你的标题）。在检查了数值/浮点值是否有效后，您可能希望使用它，在这种情况下，try/except非常有意义。但是，如果出于某种原因，您只想验证字符串是数字，那么正则表达式也可以正常工作，但很难得到正确的结果。例如，我认为到目前为止，大多数正则表达式的答案都不能正确解析没有整数部分（如“.7”）的字符串，就python而言，整数部分是一个浮点数。在不需要小数部分的单个正则表达式中检查这一点有点困难。我包含了两个正则表达式来显示这一点。

它确实提出了一个有趣的问题，即“数字”是什么。您是否包含“inf”，它在python中作为浮点数有效？或者您是否包含“数字”但可能无法在python中表示的数字（例如大于float max的数字）。

解析数字的方式也存在歧义。例如，“--20”呢？这是一个“数字”吗？这是代表“20”的合法方式吗？Python将允许您执行“var=--20”并将其设置为20（尽管实际上这是因为它将其作为表达式处理），但float（“--20”）不起作用。

无论如何，在没有更多信息的情况下，这里有一个正则表达式，我相信它涵盖了python解析它们时的所有int和float。

# 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

这篇文章已经有了很好的答案。我想给出一个稍微不同的观点。

我们可以对字母表进行否定搜索，而不是搜索数字、数字或浮点数。即，我们可以要求程序查看它是否不是字母表。

## Check whether it is not alpha rather than checking if it is digit
print(not "-1.2345".isalpha())
print(not "-1.2345e-10".isalpha())

如果你确定你的字符串是一个格式良好的数字（下面的条件1和条件2），它会很好地工作。但是，如果字符串错误地不是一个格式良好的数字，那么它将失败。在这种情况下，即使字符串不是有效的数字，它也会返回数字匹配。为了解决这种情况，必须有许多基于规则的方法。然而，此时此刻，我想起了正则表达式。以下是三个案例。请注意，正则表达式可以更好，因为我不是正则表达式专家。下面有两个列表：一个用于有效数字，一个用于无效数字。必须拾取有效数字，而不能拾取无效数字。

==条件1：确保字符串为有效数字，但未选择“inf”==

Valid_Numbers = ["1","-1","+1","0.0",".1","1.2345","-1.2345","+1.2345","1.2345e10","1.2345e-10","-1.2345e10","-1.2345E10","-inf"]
Invalid_Numbers = ["1.1.1","++1","--1","-1-1","1.23e10e5","--inf"]

################################ Condition 1: Valid number excludes 'inf' ####################################

Case_1_Positive_Result = list(map(lambda x: not x.isalpha(),Valid_Numbers))
print("The below must all be True")
print(Case_1_Positive_Result)

## This check assumes a valid number. So it fails for the negative cases and wrongly detects string as number
Case_1_Negative_Result = list(map(lambda x: not x.isalpha(),Invalid_Numbers))
print("The below must all be False")
print(Case_1_Negative_Result)

The below must all be True
[True, True, True, True, True, True, True, True, True, True, True, True, True]
The below must all be False
[True, True, True, True, True, True]

==条件2：确保字符串为有效数字，并选择“inf”==

################################ Condition 2: Valid number includes 'inf'  ###################################
Case_2_Positive_Result = list(map(lambda x: x=="inf" or not x.isalpha(),Valid_Numbers+["inf"]))
print("The below must all be True")
print(Case_2_Positive_Result)

## This check assumes a valid number. So it fails for the negative cases and wrongly detects string as number
Case_2_Negative_Result = list(map(lambda x: x=="inf" or not x.isalpha(),Invalid_Numbers+["++inf"]))
print("The below must all be False")
print(Case_2_Negative_Result)

The below must all be True
[True, True, True, True, True, True, True, True, True, True, True, True, True, True]
The below must all be False
[True, True, True, True, True, True, True]

==条件3：字符串不保证是有效数字==

import re
CompiledPattern = re.compile(r"([+-]?(inf){1}$)|([+-]?[0-9]*\.?[0-9]*$)|([+-]?[0-9]*\.?[0-9]*[eE]{1}[+-]?[0-9]*$)")
Case_3_Positive_Result = list(map(lambda x: True if CompiledPattern.match(x) else False,Valid_Numbers+["inf"]))
print("The below must all be True")
print(Case_3_Positive_Result)

## This check assumes a valid number. So it fails for the negative cases and wrongly detects string as number
Case_3_Negative_Result = list(map(lambda x: True if CompiledPattern.match(x) else False,Invalid_Numbers+["++inf"]))
print("The below must all be False")
print(Case_3_Negative_Result)

The below must all be True
[True, True, True, True, True, True, True, True, True, True, True, True, True, True]
The below must all be False
[False, False, False, False, False, False, False]

通过返回比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:]), ')'

这不仅丑陋而且缓慢

我对这两个都有异议。

正则表达式或其他字符串解析方法会更丑陋、更慢。

我不确定有什么比上面提到的更快。它调用函数并返回。Try/Catch不会带来太多的开销，因为最常见的异常是在不大量搜索堆栈帧的情况下捕获的。

问题是任何数值转换函数都有两种结果

一个数字，如果该数字有效状态代码（例如，通过errno）或异常，表明无法解析任何有效数字。

C（作为一个例子）通过多种方式解决了这个问题。Python将其清晰明确地展示出来。

我认为你这样做的代码是完美的。