我需要确定字符串是否转换为基本类型（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) 

该答案提供了一步一步的指导，具有查找字符串的示例：

正整数正/负-整数/浮点如何在检查数字时丢弃“NaN”（不是数字）字符串？

检查字符串是否为正整数

您可以使用str.idigit（）检查给定的字符串是否为正整数。

样本结果：

# 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

如果您还想检查负整数和浮点数，那么您可以编写一个自定义函数来检查它，如下所示：

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”（非数字）字符串

上述函数将为“NAN”（非数字）字符串返回True，因为对于Python，它是表示它不是数字的有效浮点数。例如：

>>> is_number('NaN')
True

为了检查数字是否为“NaN”，可以使用math.isnan（）作为：

>>> import math
>>> nan_num = float('nan')

>>> math.isnan(nan_num)
True

或者，如果您不想导入其他库来检查它，那么您可以通过使用==将其与自身进行比较来检查它。当nan float与自身比较时，Python返回False。例如：

# `nan_num` variable is taken from above example
>>> nan_num == nan_num
False

因此，上述函数is_number可以更新为“NaN”返回False，如下所示：

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函数版本。

我做了一些速度测试。让我们假设，如果字符串可能是一个数字，则try/except策略是最快的。如果字符串不可能是数字，并且您对整数检查感兴趣，则值得进行一些测试（isdigit加上标题“-”）。如果您有兴趣检查浮点数，则必须使用try/except代码而不进行转义。

对于非数字字符串，请尝试：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在这两种情况下都获胜

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

str.inumeric（）

如果字符串中的所有字符都是数字字符，则返回True，并且至少有一个字符，否则为False。数字字符包括数字字符Unicode数值属性，例如U+2155，VULGAR FRACTION ONE第五。形式上，数字字符是具有属性值的字符Numeric_Type=数字，Numeric_Type=十进制或Numeric_Type=数字。

str.isdecimal（）

如果字符串中的所有字符都是十进制字符，并且至少有一个字符，否则为False。十进制字符是可用于在基数10中形成数字的那些，阿拉伯数字零。形式上，十进制字符是一个字符在Unicode通用类别“Nd”中。

两者都适用于Python 3.0中的字符串类型。