Qual é a melhor maneira possível de verificar se uma string pode ser representada como um número no Python?

A função que atualmente tenho atualmente é:

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

O que, não só é feio e lento, parece desajeitado. No entanto, eu não encontrei um método melhor porque chamar floata função principal é ainda pior.

O que não é apenas feio e lento

Eu disputaria os dois.

Um regex ou outro método de análise de string seria mais feio e mais lento.

Não tenho certeza de que algo muito possa ser mais rápido que o acima. Chama a função e retorna. O Try / Catch não apresenta muita sobrecarga, porque a exceção mais comum é detectada sem uma extensa pesquisa de quadros de pilha.

O problema é que qualquer função de conversão numérica tem dois tipos de resultados

• Um número, se o número for válido
• Um código de status (por exemplo, via errno) ou exceção para mostrar que nenhum número válido pode ser analisado.

C (como exemplo) corta isso de várias maneiras. O Python apresenta de forma clara e explícita.

Eu acho que seu código para fazer isso é perfeito.

Caso esteja procurando analisar números inteiros (positivos, não assinados) em vez de números flutuantes, você pode usar a isdigit()função para objetos de sequência.

>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False

Métodos de seqüência de caracteres - isdigit(): Python2 , Python3

Há também algo nas cadeias de caracteres Unicode, que eu não estou muito familiarizado com Unicode - É decimal / decimal

TL; DR A melhor solução és.replace('.','',1).isdigit()

Eu fiz alguns benchmarks comparando as diferentes abordagens

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()

Se a sequência não for um número, o bloco de exceção será bastante lento. Mais importante, porém, o método try-except é a única abordagem que lida com as notações científicas corretamente.

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__)

A notação flutuante ".1234" não é suportada por:
- 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__)

A notação científica "1.000000e + 50" não é suportada por:
- is_number_regex
- is_number_repl_isdigit
A notação científica "1e50" não é suportada por:
- is_number_regex
- is_number_repl_isdigit

EDIT: Os resultados de referência

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)))

onde as seguintes funções foram testadas

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()

Há uma exceção que você pode levar em consideração: a string 'NaN'

Se você deseja que is_number retorne FALSE para 'NaN', esse código não funcionará, pois o Python o converterá em sua representação de um número que não é um número (fale sobre questões de identidade):

>>> float('NaN')
nan

Caso contrário, devo agradecer o trecho de código que agora uso extensivamente. :)

G.

que tal agora:

'3.14'.replace('.','',1).isdigit()

que retornará verdadeiro somente se houver um ou não '.' na sequência de dígitos.

'3.14.5'.replace('.','',1).isdigit()

retornará falso

edit: acabei de ver outro comentário ... adicionar um .replace(badstuff,'',maxnum_badstuff)para outros casos pode ser feito. se você estiver passando sal e não condimentos arbitrários (ref: xkcd # 974 ), tudo ficará bem: P

O que, não só é feio e lento, parece desajeitado.

Pode levar algum tempo para se acostumar, mas esta é a maneira pitônica de fazê-lo. Como já foi apontado, as alternativas são piores. Mas há uma outra vantagem de fazer as coisas dessa maneira: polimorfismo.

A idéia central por trás da digitação do pato é que "se ele anda e fala como um pato, então é um pato". E se você decidir que precisa da subclasse de seqüência de caracteres para poder alterar como determina se algo pode ser convertido em um flutuador? Ou, se você decidir testar completamente outro objeto? Você pode fazer essas coisas sem precisar alterar o código acima.

Outros idiomas resolvem esses problemas usando interfaces. Vou salvar a análise de qual solução é melhor para outro segmento. O ponto, porém, é que o python está decididamente no lado da digitação do pato da equação, e você provavelmente terá que se acostumar com uma sintaxe como essa se planeja fazer muita programação em Python (mas isso não significa você tem que gostar, é claro).

Outra coisa que você pode querer levar em consideração: o Python é muito rápido ao lançar e capturar exceções em comparação com muitas outras linguagens (30x mais rápido que o .Net, por exemplo). Caramba, o próprio idioma lança exceções para comunicar condições normais não-excepcionais do programa (toda vez que você usa um loop for). Portanto, não me preocuparia muito com os aspectos de desempenho desse código até você notar um problema significativo.

Atualizado depois que o Alfe apontou, você não precisa verificar se o flutuador é separado, pois os complexos manipulam os dois:

def is_number(s):
    try:
        complex(s) # for int, long, float and complex
    except ValueError:
        return False

    return True

Anteriormente dito: Em alguns casos raros, você também pode precisar procurar números complexos (por exemplo, 1 + 2i), que não podem ser representados por um float:

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

Para intusar isto:

>>> "1221323".isdigit()
True

Mas para floatnós precisamos de alguns truques ;-). Cada número flutuante tem um ponto ...

>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False

Também para números negativos basta adicionar lstrip():

>>> '-12'.lstrip('-')
'12'

E agora temos uma maneira universal:

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False

Apenas imitar c #

No C #, existem duas funções diferentes que lidam com a análise de valores escalares:

• Float.Parse ()
• Float.TryParse ()

float.parse ():

def parse(string):
    try:
        return float(string)
    except Exception:
        throw TypeError

Nota: Se você está se perguntando por que alterei a exceção para um TypeError, aqui está a documentação .

float.try_parse ():

def try_parse(string, fail=None):
    try:
        return float(string)
    except Exception:
        return fail;

Nota: Você não deseja retornar o booleano 'False' porque esse ainda é um tipo de valor. Nenhum é melhor porque indica falha. Obviamente, se você quiser algo diferente, poderá alterar o parâmetro de falha para o que quiser.

Para estender o float para incluir o 'parse ()' e 'try_parse ()', você precisará monkeypatch a classe 'float' para adicionar esses métodos.

Se você deseja respeitar as funções preexistentes, o código deve ser algo como:

def monkey_patch():
    if(!hasattr(float, 'parse')):
        float.parse = parse
    if(!hasattr(float, 'try_parse')):
        float.try_parse = try_parse

Nota: Eu, pessoalmente, prefiro chamá-lo de Monkey Punching porque parece que estou abusando do idioma quando faço isso, mas YMMV.

Uso:

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

E o grande sábio Pythonas disse à Santa Sé Sharpisus: "Qualquer coisa que você possa fazer, eu posso fazer melhor; eu posso fazer qualquer coisa melhor que você".

Para cadeias de não-números, try: except:é realmente mais lento que expressões regulares. Para cadeias de números válidos, regex é mais lento. Portanto, o método apropriado depende da sua entrada.

Se você achar que está em uma ligação de desempenho, poderá usar um novo módulo de terceiros chamado fastnumbers, que fornece uma função chamada isfloat . Divulgação completa, eu sou o autor. Eu incluí seus resultados nos horários abaixo.

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

Como você pode ver

• try: except: foi rápido para entrada numérica, mas muito lento para uma entrada inválida
• regex é muito eficiente quando a entrada é inválida
• fastnumbers ganha em ambos os casos

Sei que isso é particularmente antigo, mas gostaria de acrescentar uma resposta que acredito que cubra as informações que faltam na resposta mais votada e que podem ser muito valiosas para quem encontrar isso:

Para cada um dos métodos a seguir, conecte-os a uma contagem, se você precisar de alguma entrada para ser aceita. (Supondo que estamos usando definições vocais de números inteiros em vez de 0 a 255, etc.)

x.isdigit() funciona bem para verificar se x é um número inteiro.

x.replace('-','').isdigit() funciona bem para verificar se x é negativo (primeira posição do check-in)

x.replace('.','').isdigit() funciona bem para verificar se x é um decimal.

x.replace(':','').isdigit() funciona bem para verificar se x é uma proporção.

x.replace('/','',1).isdigit() funciona bem para verificar se x é uma fração.

Esta resposta fornece guia passo a passo com função de exemplos para encontrar a string:

• Número inteiro positivo
• Positivo / negativo - inteiro / flutuante
• Como descartar cadeias de caracteres "NaN" (não um número) enquanto verifica o número?

Verifique se a sequência é um número inteiro positivo

Você pode usar str.isdigit()para verificar se a sequência especificada é um número inteiro positivo .

Resultados da amostra:

# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False

Verifique se a string é positiva / negativa - inteiro / flutuante

str.isdigit()retorna Falsese a sequência for um número negativo ou um número flutuante. Por exemplo:

# returns `False` for float
>>> '123.3'.isdigit()
False
# returns `False` for negative number
>>> '-123'.isdigit()
False

Se você tambémfloat deseja verificar os números inteiros negativos e , pode escrever uma função personalizada para verificar como:

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

Exemplo de execução:

>>> 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

Descartar cadeias "NaN" (não um número) enquanto verifica o número

As funções acima retornarão Truepara a string "NAN" (não é um número) porque, para o Python, é válido float representando que não é um número. Por exemplo:

>>> is_number('NaN')
True

Para verificar se o número é "NaN", você pode usar math.isnan()como:

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

>>> math.isnan(nan_num)
True

Ou, se você não deseja importar uma biblioteca adicional para verificar isso, basta checá-la através da comparação com ela mesma ==. O Python retorna Falsequando o nanfloat é comparado com ele próprio. Por exemplo:

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

Por isso, acima de função is_numberpode ser atualizado para voltar Falsepara"NaN" como:

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

Exemplo de execução:

>>> 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: Cada operação para cada verificação, dependendo do tipo de número, é fornecida com sobrecarga adicional. Escolha a versão da is_numberfunção que atenda às suas necessidades.

A conversão para float e a captura de ValueError é provavelmente a maneira mais rápida, pois float () se destina especificamente a isso. Qualquer outra coisa que exija análise de string (regex, etc) provavelmente será mais lenta devido ao fato de não estar ajustado para esta operação. Meus US $ 0,02.

Você pode usar strings Unicode, eles têm um método para fazer exatamente o que você deseja:

>>> s = u"345"
>>> s.isnumeric()
True

Ou:

>>> s = "345"
>>> u = unicode(s)
>>> u.isnumeric()
True

http://www.tutorialspoint.com/python/string_isnumeric.htm

http://docs.python.org/2/howto/unicode.html

Eu queria ver qual método é mais rápido. No geral, os melhores e mais consistentes resultados foram dados pela check_replacefunção. Os resultados mais rápidos foram dados pela check_exceptionfunção, mas somente se não houver nenhuma exceção acionada - o que significa que o código é o mais eficiente, mas a sobrecarga de gerar uma exceção é bastante grande.

Observe que a verificação de uma conversão bem-sucedida é o único método preciso, por exemplo, isso funciona, check_exceptionmas as outras duas funções de teste retornam False para um float válido:

huge_number = float('1e+100')

Aqui está o código de referência:

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))

Aqui estão os resultados com o Python 2.7.10 em um MacBook Pro 13 de 2017:

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

Aqui estão os resultados com o Python 3.6.5 em um MacBook Pro 13 de 2017:

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

Aqui estão os resultados com o PyPy 2.7.13 em um MacBook Pro 13 de 2017:

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

Então, para juntar tudo, verificando Nan, infinito e números complexos (parece que eles são especificados com j, não i, ou seja, 1 + 2j), resulta em:

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

A entrada pode ser a seguinte:

a="50" b=50 c=50.1 d="50.1"

Entrada 1-Geral:

A entrada desta função pode ser tudo!

Localiza se a variável especificada é numérica. Sequências numéricas consistem em sinal opcional, qualquer número de dígitos, parte decimal opcional e parte exponencial opcional. Portanto, + 0123.45e6 é um valor numérico válido. Notação hexadecimal (por exemplo, 0xf4c3b00c) e binária (por exemplo, 0b10100111001) não é permitida.

função 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

teste:

>>> is_numeric("54")
True
>>> is_numeric("54.545")
True
>>> is_numeric("0x45")
True

função is_float

Localiza se a variável fornecida é flutuante. strings flutuantes consistem em sinal opcional, qualquer número de dígitos, ...

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

teste:

>>> is_float("5.4")
True
>>> is_float("5")
False
>>> is_float(5)
False
>>> is_float("5")
False
>>> is_float("+5.4")
True

o que é ast ?

2- Se você tem certeza de que o conteúdo da variável é String :

use o método 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

Entrada numérica 3:

detectar valor int:

>>> isinstance("54", int)
False
>>> isinstance(54, int)
True
>>> 

detectar flutuador:

>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True

Eu fiz um teste de velocidade. Vamos dizer que, se a string provavelmente for um número, a estratégia try / except será a mais rápida possível. Se a string provavelmente não for um número e você estiver interessado na verificação de número inteiro , vale a pena fazer algum teste (isdigit mais header '-'). Se você estiver interessado em verificar o número da bóia, use o código try / except sem escape.

Eu precisava determinar se uma string era convertida em tipos básicos (float, int, str, bool). Depois de não encontrar nada na internet, criei isso:

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)

Exemplo

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       

Você pode capturar o tipo e usá-lo

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 

RyanN sugere

Se você deseja retornar False para NaN e Inf, altere a linha para x = float (s); return (x == x) e (x - 1! = x). Isso deve retornar True para todos os carros alegóricos, exceto Inf e NaN

Mas isso não funciona muito bem, porque para flutuadores suficientemente grandes, x-1 == xretorna verdadeiro. Por exemplo,2.0**54 - 1 == 2.0**54

Eu acho que a sua solução é bom, mas não é uma implementação regexp correta.

Parece haver muito ódio do regexp em relação a essas respostas, que eu acho injustificadas, o regexps pode ser razoavelmente limpo, correto e rápido. Realmente depende do que você está tentando fazer. A questão original era como você pode "verificar se uma string pode ser representada como um número (float)" (conforme o seu título). Presumivelmente, você desejaria usar o valor numérico / flutuante depois de verificar se ele é válido; nesse caso, sua tentativa / exceção faz muito sentido. Mas se, por algum motivo, você apenas deseja validar que uma string é um númeroentão uma regex também funciona bem, mas é difícil de corrigir. Eu acho que a maioria das respostas do regex até agora, por exemplo, não analisa corretamente as strings sem uma parte inteira (como ".7"), que é um float no que diz respeito ao python. E isso é um pouco complicado de verificar em um único regex em que a parte fracionária não é necessária. Eu incluí dois regex para mostrar isso.

Isso levanta a questão interessante sobre o que é um "número". Você inclui "inf", que é válido como flutuador em python? Ou você inclui números que são "números", mas talvez não possam ser representados em python (como números que são maiores que o número máximo de float).

Também há ambigüidades na maneira como você analisa números. Por exemplo, o que dizer de "--20"? Este é um "número"? Essa é uma maneira legal de representar "20"? O Python permitirá que você faça "var = --20" e defina-o como 20 (embora realmente seja porque o trata como uma expressão), mas o float ("- 20") não funciona.

De qualquer forma, sem mais informações, aqui está uma expressão regular que eu acredito que cobre todas as entradas e flutuações conforme o python as analisa .

# 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

Alguns exemplos de valores de teste:

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

A execução do código de benchmarking na resposta do @ ron-reiter mostra que esse regex é realmente mais rápido que o normal e é muito mais rápido no tratamento de valores ruins que a exceção, o que faz algum sentido. Resultados:

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

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

Aqui está a minha maneira simples de fazer isso. Digamos que eu estou percorrendo algumas strings e quero adicioná-las a uma matriz se elas forem números.

try:
    myvar.append( float(string_to_check) )
except:
    continue

Substitua myvar.apppend por qualquer operação que você queira executar com a string, se for um número. A idéia é tentar usar uma operação float () e usar o erro retornado para determinar se a string é ou não um número.

Também usei a função que você mencionou, mas logo noto que cadeias de caracteres como "Nan", "Inf" e sua variação são consideradas como número. Então, proponho que você versão melhorada de sua função, que retornará false nesse tipo de entrada e não falhe nas variantes "1e3":

def is_float(text):
    try:
        float(text)
        # check for nan/infinity etc.
        if text.isalpha():
            return False
        return True
    except ValueError:
        return False

Esse código lida com os expoentes, flutuadores e números inteiros, sem o uso de regex.

return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False

Função auxiliar do usuário:

def if_ok(fn, string):
  try:
    return fn(string)
  except Exception as e:
    return None

então

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)])

Você pode generalizar a técnica de exceção de uma maneira útil, retornando valores mais úteis que True e False. Por exemplo, essa função coloca aspas em volta das seqüências, mas deixa os números sozinhos. O que é exatamente o que eu precisava para um filtro rápido e sujo para fazer algumas definições de variáveis ​​para 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:]), ')'

Eu estava trabalhando em um problema que me levou a esse segmento, como converter uma coleção de dados em seqüências de caracteres e números da maneira mais intuitiva. Depois de ler o código original, percebi que o que eu precisava era diferente de duas maneiras:

1 - Eu queria um resultado inteiro se a sequência representasse um número inteiro

2 - Eu queria que um resultado de número ou string ficasse em uma estrutura de dados

então eu adaptei o código original para produzir esse derivado:

def string_or_number(s):
    try:
        z = int(s)
        return z
    except ValueError:
        try:
            z = float(s)
            return z
        except ValueError:
            return s

Tente isso.

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

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