Quelle est la meilleure façon de vérifier si une chaîne peut être représentée sous forme de nombre en Python?

La fonction que j'ai actuellement en ce moment est:

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

Ce qui, non seulement est laid et lent, semble maladroit. Cependant, je n'ai pas trouvé de meilleure méthode, car appeler floatla fonction principale est encore pire.

Ce qui est non seulement laid et lent

Je contesterais les deux.

Une expression rationnelle ou une autre méthode d'analyse de chaîne serait plus laide et plus lente.

Je ne suis pas sûr que quoi que ce soit pourrait être plus rapide que ce qui précède. Il appelle la fonction et retourne. Try / Catch n'introduit pas beaucoup de surcharge car l'exception la plus courante est interceptée sans une recherche approfondie des trames de pile.

Le problème est que toute fonction de conversion numérique a deux types de résultats

• Un numéro, si le numéro est valide
• Un code d'état (par exemple, via errno) ou une exception pour montrer qu'aucun numéro valide ne peut être analysé.

C (à titre d'exemple) contourne cela de plusieurs façons. Python le présente clairement et explicitement.

Je pense que votre code pour ce faire est parfait.

Si vous recherchez des entiers (positifs, non signés) au lieu de flottants, vous pouvez utiliser la isdigit()fonction pour les objets chaîne.

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

Méthodes de chaîne - isdigit(): Python2 , Python3

Il y a aussi quelque chose sur les chaînes Unicode, que je ne connais pas trop Unicode - est décimal / décimal

TL; DR La meilleure solution ests.replace('.','',1).isdigit()

J'ai fait quelques repères comparant les différentes approches

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

Si la chaîne n'est pas un nombre, le bloc except est assez lent. Mais plus important encore, la méthode try-except est la seule approche qui gère correctement les notations scientifiques.

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

La notation flottante ".1234" n'est pas prise en charge par:
- 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__)

La notation scientifique "1.000000e + 50" n'est pas prise en charge par:
- is_number_regex
- is_number_repl_isdigit
La notation scientifique "1e50" n'est pas prise en charge par:
- is_number_regex
- is_number_repl_isdigit

EDIT: Les résultats de référence

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

où les fonctions suivantes ont été testées

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

Il y a une exception que vous voudrez peut-être prendre en compte: la chaîne 'NaN'

Si vous voulez que is_number renvoie FALSE pour 'NaN', ce code ne fonctionnera pas car Python le convertit en sa représentation d'un nombre qui n'est pas un nombre (parler de problèmes d'identité):

>>> float('NaN')
nan

Sinon, je devrais en fait vous remercier pour le morceau de code que j'utilise maintenant largement. :)

G.

que dis-tu de ça:

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

qui ne retournera vrai que s'il y en a un ou pas '.' dans la chaîne de chiffres.

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

retournera faux

edit: vient de voir un autre commentaire ... l'ajout d'un .replace(badstuff,'',maxnum_badstuff)pour d'autres cas peut être fait. si vous passez du sel et non des condiments arbitraires (ref: xkcd # 974 ) cela fera l'affaire: P

Ce qui, non seulement est laid et lent, semble maladroit.

Cela peut prendre un certain temps pour s'y habituer, mais c'est la façon pythonique de le faire. Comme cela a déjà été souligné, les alternatives sont pires. Mais il y a un autre avantage à faire les choses de cette façon: le polymorphisme.

L'idée centrale derrière la frappe de canard est que "s'il marche et parle comme un canard, alors c'est un canard". Que se passe-t-il si vous décidez que vous devez sous-classer la chaîne afin de pouvoir changer la façon dont vous déterminez si quelque chose peut être converti en flottant? Ou si vous décidez de tester un autre objet entièrement? Vous pouvez faire ces choses sans avoir à changer le code ci-dessus.

D'autres langues résolvent ces problèmes en utilisant des interfaces. Je vais enregistrer l'analyse de la meilleure solution pour un autre thread. Le point, cependant, est que python est décidément du côté du typage du canard de l'équation, et vous devrez probablement vous habituer à une syntaxe comme celle-ci si vous prévoyez de faire beaucoup de programmation en Python (mais cela ne signifie pas vous devez l'aimer bien sûr).

Une autre chose que vous voudrez peut-être prendre en considération: Python lance et capture des exceptions assez rapidement par rapport à beaucoup d'autres langages (30 fois plus rapide que .Net par exemple). Heck, le langage lui-même lève même des exceptions pour communiquer des conditions de programme normales non exceptionnelles (chaque fois que vous utilisez une boucle for). Ainsi, je ne m'inquiéterais pas trop des aspects de performance de ce code jusqu'à ce que vous remarquiez un problème important.

Mis à jour après qu'Alfe ait souligné que vous n'avez pas besoin de vérifier séparément le flotteur car les poignées complexes gèrent les deux:

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

    return True

Dit précédemment: Dans certains cas rares, vous devrez peut-être également vérifier les nombres complexes (par exemple 1 + 2i), qui ne peuvent pas être représentés par un flottant:

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

Pour intutiliser ceci:

>>> "1221323".isdigit()
True

Mais pour floatnous avons besoin de quelques astuces ;-). Chaque nombre flottant a un point ...

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

Pour les nombres négatifs, ajoutez simplement lstrip():

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

Et maintenant, nous obtenons un moyen universel:

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

Just Mimic C #

En C #, il existe deux fonctions différentes qui gèrent l'analyse des valeurs scalaires:

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

float.parse ():

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

Remarque: Si vous vous demandez pourquoi j'ai changé l'exception en TypeError, voici la documentation .

float.try_parse ():

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

Remarque: vous ne voulez pas renvoyer le booléen 'False' car il s'agit toujours d'un type de valeur. Aucune n'est meilleure car elle indique un échec. Bien sûr, si vous voulez quelque chose de différent, vous pouvez changer le paramètre d'échec en ce que vous voulez.

Pour étendre float pour inclure les 'parse ()' et 'try_parse ()', vous devrez monkeypatch la classe 'float' pour ajouter ces méthodes.

Si vous voulez respecter les fonctions préexistantes, le code devrait ressembler à ceci:

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

SideNote: Personnellement, je préfère l'appeler Monkey Punching parce que j'ai l'impression d'abuser de la langue quand je fais ça, mais YMMV.

Usage:

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

Et le grand Sage Pythonas a dit au Saint-Siège Sharpisus: "Tout ce que vous pouvez faire, je peux le faire mieux; je peux faire quelque chose de mieux que vous."

Pour les chaînes de non-nombres, try: except:est en fait plus lent que les expressions régulières. Pour les chaînes de nombres valides, l'expression régulière est plus lente. Ainsi, la méthode appropriée dépend de votre saisie.

Si vous constatez que vous êtes dans une liaison de performances, vous pouvez utiliser un nouveau module tiers appelé fastnumbers qui fournit une fonction appelée isfloat . Divulgation complète, je suis l'auteur. J'ai inclus ses résultats dans les horaires ci-dessous.

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

Comme vous pouvez le voir

• try: except: était rapide pour l'entrée numérique mais très lent pour une entrée invalide
• regex est très efficace lorsque l'entrée n'est pas valide
• fastnumbers gagne dans les deux cas

Je sais que cela est particulièrement ancien, mais j'ajouterais une réponse qui, je crois, couvre les informations manquantes de la réponse la plus votée qui pourraient être très précieuses pour tous ceux qui trouveraient ceci:

Pour chacune des méthodes suivantes, connectez-les avec un nombre si vous avez besoin d'une entrée pour être acceptée. (En supposant que nous utilisons des définitions vocales d'entiers plutôt que de 0 à 255, etc.)

x.isdigit() fonctionne bien pour vérifier si x est un entier.

x.replace('-','').isdigit() fonctionne bien pour vérifier si x est négatif. (Check - in first position)

x.replace('.','').isdigit() fonctionne bien pour vérifier si x est un nombre décimal.

x.replace(':','').isdigit() fonctionne bien pour vérifier si x est un rapport.

x.replace('/','',1).isdigit() fonctionne bien pour vérifier si x est une fraction.

Cette réponse fournit un guide étape par étape ayant une fonction avec des exemples pour trouver la chaîne:

• Entier positif
• Positif / négatif - entier / flottant
• Comment supprimer les chaînes "NaN" (pas un nombre) tout en vérifiant le nombre?

Vérifiez si la chaîne est un entier positif

Vous pouvez utiliser str.isdigit()pour vérifier si une chaîne donnée est un entier positif .

Exemples de résultats:

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

Vérifiez que la chaîne est positive / négative - entier / flottant

str.isdigit()renvoie Falsesi la chaîne est un nombre négatif ou un nombre flottant. Par exemple:

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

Si vous souhaitez également vérifier les entiers négatifs etfloat , vous pouvez écrire une fonction personnalisée pour la vérifier comme suit:

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

Exemple d'exécution:

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

Jeter les chaînes "NaN" (pas un nombre) tout en vérifiant le nombre

Les fonctions ci-dessus Truerenverront la chaîne "NAN" (pas un nombre) car pour Python, c'est un flottant valide qui représente que ce n'est pas un nombre. Par exemple:

>>> is_number('NaN')
True

Afin de vérifier si le nombre est "NaN", vous pouvez utiliser math.isnan()comme:

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

>>> math.isnan(nan_num)
True

Ou si vous ne voulez pas importer de bibliothèque supplémentaire pour vérifier cela, vous pouvez simplement la vérifier en la comparant avec elle-même en utilisant ==. Python revient Falselorsque nanfloat est comparé à lui-même. Par exemple:

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

Par conséquent, la fonctionis_numberFalse"NaN" ci-dessus peut être mise à jour pour revenir en tant que:

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

Exemple d'exécution:

>>> 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: Chaque opération pour chaque vérification en fonction du type de numéro s'accompagne de frais généraux supplémentaires. Choisissez la version de is_numberfonction qui correspond à vos besoins.

Caster pour flotter et attraper ValueError est probablement le moyen le plus rapide, car float () est spécifiquement destiné à cela. Tout autre élément nécessitant une analyse de chaîne (regex, etc.) sera probablement plus lent car il n'est pas réglé pour cette opération. Mon 0,02 $.

Vous pouvez utiliser des chaînes Unicode, elles ont une méthode pour faire exactement ce que vous voulez:

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

Je voulais voir quelle méthode est la plus rapide. Dans l'ensemble, les résultats les meilleurs et les plus cohérents ont été donnés par la check_replacefonction. Les résultats les plus rapides ont été donnés par la check_exceptionfonction, mais uniquement si aucune exception n'a été déclenchée - ce qui signifie que son code est le plus efficace, mais la surcharge de lever une exception est assez grande.

Veuillez noter que la vérification d'une conversion réussie est la seule méthode qui est précise, par exemple, cela fonctionne avec check_exceptionmais les deux autres fonctions de test renverront False pour un flottant valide:

huge_number = float('1e+100')

Voici le code de référence:

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

Voici les résultats avec Python 2.7.10 sur un MacBook Pro 13 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

Voici les résultats avec Python 3.6.5 sur un MacBook Pro 13 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

Voici les résultats avec PyPy 2.7.13 sur un MacBook Pro 13 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

Donc, pour mettre tout cela ensemble, en vérifiant les nombres Nan, infini et complexes (il semblerait qu'ils soient spécifiés avec j, pas i, c'est-à-dire 1 + 2j), il en résulte:

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

L'entrée peut être la suivante:

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

1-Entrée générale:

L'entrée de cette fonction peut être tout!

Recherche si la variable donnée est numérique. Les chaînes numériques se composent d'un signe facultatif, d'un nombre quelconque de chiffres, d'une partie décimale facultative et d'une partie exponentielle facultative. Ainsi, + 0123.45e6 est une valeur numérique valide. La notation hexadécimale (par exemple 0xf4c3b00c) et binaire (par exemple 0b10100111001) n'est pas autorisée.

Fonction 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

tester:

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

Fonction is_float

Recherche si la variable donnée est flottante. les chaînes flottantes se composent d'un signe facultatif, d'un nombre quelconque de chiffres, ...

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

tester:

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

ce qui est ast ?

2- Si vous êtes sûr que le contenu de la variable est String :

utiliser la méthode 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 entrées numériques:

détecter la valeur int:

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

détecter flotteur:

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

J'ai fait un test de vitesse. Disons que si la chaîne est susceptible d'être un nombre, la stratégie try / except est la plus rapide possible.Si la chaîne n'est pas susceptible d'être un nombre et que vous êtes intéressé par le contrôle entier , cela vaut la peine de faire un test (isdigit plus en-tête «-»). Si vous souhaitez vérifier le nombre flottant, vous devez utiliser le code try / except sans échappement.

J'avais besoin de déterminer si une chaîne était convertie en types de base (float, int, str, bool). Après n'avoir rien trouvé sur Internet, j'ai créé ceci:

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)

Exemple

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       

Vous pouvez capturer le type et l'utiliser

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

RyanN suggère

Si vous voulez retourner False pour un NaN et Inf, changez la ligne en x = float (s); retourner (x == x) et (x - 1! = x). Cela devrait retourner True pour tous les flottants sauf Inf et NaN

Mais cela ne fonctionne pas tout à fait, car pour des flotteurs suffisamment grands, x-1 == xrenvoie true. Par exemple,2.0**54 - 1 == 2.0**54

Je pense que votre solution est très bien, mais il y a une implémentation regexp correcte.

Il semble y avoir beaucoup de haine d'expression régulière envers ces réponses, ce qui, à mon avis, n'est pas justifié, les expressions régulières peuvent être raisonnablement propres, correctes et rapides. Cela dépend vraiment de ce que vous essayez de faire. La question initiale était de savoir comment "vérifier si une chaîne peut être représentée sous la forme d'un nombre (float)" (selon votre titre). Vraisemblablement, vous voudrez utiliser la valeur numérique / flottante une fois que vous avez vérifié qu'elle est valide, auquel cas votre essai / sauf a beaucoup de sens. Mais si, pour une raison quelconque, vous voulez simplement valider qu'une chaîne est un nombrealors une expression régulière fonctionne également bien, mais il est difficile de se corriger. Je pense que la plupart des réponses d'expressions régulières jusqu'à présent, par exemple, n'analysent pas correctement les chaînes sans une partie entière (comme ".7") qui est un flottant en ce qui concerne python. Et c'est un peu difficile à vérifier dans une seule expression régulière où la partie fractionnaire n'est pas requise. J'ai inclus deux regex pour le montrer.

Cela soulève la question intéressante de savoir ce qu'est un «nombre». Incluez-vous "inf" qui est valide comme flottant en python? Ou incluez-vous des nombres qui sont des "nombres" mais qui ne peuvent peut-être pas être représentés en python (tels que des nombres plus grands que le flottant max).

Il y a aussi des ambiguïtés dans la façon dont vous analysez les nombres. Par exemple, qu'en est-il de "--20"? Est-ce un "nombre"? Est-ce une manière légale de représenter "20"? Python vous permettra de faire "var = --20" et de le mettre à 20 (bien que ce soit vraiment parce qu'il le traite comme une expression), mais float ("- 20") ne fonctionne pas.

Quoi qu'il en soit, sans plus d'informations, voici une expression régulière qui, je crois, couvre tous les entiers et flotte au fur et à mesure que python les analyse .

# 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

Quelques exemples de valeurs de test:

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

L'exécution du code d'analyse comparative dans la réponse de @ ron-reiter montre que cette expression régulière est en fait plus rapide que l'expression régulière et est beaucoup plus rapide à gérer les mauvaises valeurs que l'exception, ce qui est logique. Résultats:

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

Voici ma façon simple de le faire. Disons que je fais une boucle sur certaines chaînes et que je veux les ajouter à un tableau si elles se révèlent être des nombres.

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

Remplacez myvar.apppend par l'opération que vous souhaitez effectuer avec la chaîne s'il s'avère qu'il s'agit d'un nombre. L'idée est d'essayer d'utiliser une opération float () et d'utiliser l'erreur retournée pour déterminer si la chaîne est ou non un nombre.

J'ai également utilisé la fonction que vous avez mentionnée, mais bientôt je remarque que les chaînes comme "Nan", "Inf" et sa variation sont considérées comme des nombres. Je vous propose donc une version améliorée de votre fonction, qui retournera false sur ce type d'entrée et ne manquera pas les 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

Ce code gère les exposants, les flottants et les entiers, sans utiliser d'expression régulière.

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

Fonction d'assistance utilisateur:

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

puis

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

Vous pouvez généraliser la technique d'exception de manière utile en renvoyant des valeurs plus utiles que True et False. Par exemple, cette fonction met des guillemets autour des chaînes mais laisse les nombres seuls. C'est exactement ce dont j'avais besoin pour un filtre rapide et sale pour faire des définitions de variables pour 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:]), ')'

Je travaillais sur un problème qui m'a conduit à ce fil, à savoir comment convertir une collection de données en chaînes et en nombres de la manière la plus intuitive. J'ai réalisé après avoir lu le code original que ce dont j'avais besoin était différent de deux manières:

1 - Je voulais un résultat entier si la chaîne représentait un entier

2 - Je voulais qu'un nombre ou un résultat de chaîne colle dans une structure de données

j'ai donc adapté le code original pour produire ce dérivé:

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

Essaye ça.

 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