Vérifier si une chaîne de caractères peut être convertie en float en Python

Python méthode pour vérifier float:

def isfloat(value):
  try:
    float(value)
    return True
  except ValueError:
    return False

N'obtenez pas un peu par les gobelins se cachant dans le flotteur bateau! FAIRE LES TESTS UNITAIRES!

Ce qui est, et n'est pas un float peut-être vous surprendre:

Command to parse                        Is it a float?  Comment
--------------------------------------  --------------- ------------
print(isfloat(""))                      False
print(isfloat("1234567"))               True 
print(isfloat("NaN"))                   True            nan is also float
print(isfloat("NaNananana BATMAN"))     False
print(isfloat("123.456"))               True
print(isfloat("123.E4"))                True
print(isfloat(".1"))                    True
print(isfloat("1,234"))                 False
print(isfloat("NULL"))                  False           case insensitive
print(isfloat(",1"))                    False           
print(isfloat("123.EE4"))               False           
print(isfloat("6.523537535629999e-07")) True
print(isfloat("6e777777"))              True            This is same as Inf
print(isfloat("-iNF"))                  True
print(isfloat("1.797693e+308"))         True
print(isfloat("infinity"))              True
print(isfloat("infinity and BEYOND"))   False
print(isfloat("12.34.56"))              False           Two dots not allowed.
print(isfloat("#56"))                   False
print(isfloat("56%"))                   False
print(isfloat("0E0"))                   True
print(isfloat("x86E0"))                 False
print(isfloat("86-5"))                  False
print(isfloat("True"))                  False           Boolean is not a float.   
print(isfloat(True))                    True            Boolean is a float
print(isfloat("+1e1^5"))                False
print(isfloat("+1e1"))                  True
print(isfloat("+1e1.3"))                False
print(isfloat("+1.3P1"))                False
print(isfloat("-+1"))                   False
print(isfloat("(1)"))                   False           brackets not interpreted

Si vous vous souciez de la performance (et je ne dis pas que vous devriez le savoir), l'essai de l'approche fondée sur le gagnant clair (par rapport avec votre partition de base de l'approche ou de la regexp approche), aussi longtemps que vous ne vous attendez pas beaucoup de chaînes non valides, dans ce cas, c'est potentiellement plus (sans doute à cause du coût de la gestion des exceptions).

Encore une fois, je ne dis pas que vous vous souciez de la performance, tout en vous donnant les données dans le cas où vous êtes en train de faire ce 10 milliards de fois par seconde, ou quelque chose. Aussi, la partition à base de code ne gère pas au moins une chaîne valide.

$ ./floatstr.py 
F.. 
partition triste: 3.1102449894 
partition heureux: 2.09208488464 
.. 
re triste: 7.76906108856 
re: heureux: 7.09421992302 
.. 
essayez triste: 12.1525540352 
essayez heureux: 1.44165301323 
. 
====================================================================== 
FAIL: test_partition (__principaux__.ConvertTests) 
---------------------------------------------------------------------- 
Traceback (most recent call last): 
Le fichier "./floatstr.py", ligne 48, dans test_partition 
auto.failUnless(is_float_partition("20e2")) 
AssertionError 
---------------------------------------------------------------------- 
Couru 8 tests dans 33.670 s 
FAILED (échec=1) 

Voici le code (Python 2.6, regexp prises de Jean Gietzen de réponse):

def is_float_try(str):
try:
float(str)
return True
except ValueError:
return False
import re
_float_regexp = re.compile(r"^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$")
def is_float_re(str):
return re.match(_float_regexp, str)
def is_float_partition(element):
partition=element.partition('.')
if (partition[0].isdigit() and partition[1]=='.' and partition[2].isdigit()) or (partition[0]=='' and partition[1]=='.' and pa\
rtition[2].isdigit()) or (partition[0].isdigit() and partition[1]=='.' and partition[2]==''):
return True
if __name__ == '__main__':
import unittest
import timeit
class ConvertTests(unittest.TestCase):
def test_re(self):
self.failUnless(is_float_re("20e2"))
def test_try(self):
self.failUnless(is_float_try("20e2"))
def test_re_perf(self):
print
print 're sad:', timeit.Timer('floatstr.is_float_re("12.2x")', "import floatstr").timeit()
print 're happy:', timeit.Timer('floatstr.is_float_re("12.2")', "import floatstr").timeit()
def test_try_perf(self):
print
print 'try sad:', timeit.Timer('floatstr.is_float_try("12.2x")', "import floatstr").timeit()
print 'try happy:', timeit.Timer('floatstr.is_float_try("12.2")', "import floatstr").timeit()
def test_partition_perf(self):
print
print 'partition sad:', timeit.Timer('floatstr.is_float_partition("12.2x")', "import floatstr").timeit()
print 'partition happy:', timeit.Timer('floatstr.is_float_partition("12.2")', "import floatstr").timeit()
def test_partition(self):
self.failUnless(is_float_partition("20e2"))
def test_partition2(self):
self.failUnless(is_float_partition(".2"))
def test_partition3(self):
self.failIf(is_float_partition("1234x.2"))
unittest.main()

Juste de variété, voici une autre méthode pour le faire.

>>> all([i.isnumeric() for i in '1.2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2.f'.split('.',1)])
False

Edit: je suis sûr que cela ne permettra pas à tous les cas de flotter mais surtout quand il y a un exposant. Pour résoudre ce que ça ressemble à ça. Cela renvoie Vrai que val est un flotteur et False pour les int, mais sans doute moins performantes que les regex.

>>> def isfloat(val):
...     return all([ [any([i.isnumeric(), i in ['.','e']]) for i in val],  len(val.split('.')) == 2] )
...
>>> isfloat('1')
False
>>> isfloat('1.2')
True
>>> isfloat('1.2e3')
True
>>> isfloat('12e3')
False

Si vous n'avez pas besoin de s'inquiéter à propos de scientifiques ou d'autres expressions de chiffres et travaille uniquement avec des chaînes qui pourraient être des nombres, avec ou sans période:

Fonction

def is_float(s):
result = False
if s.count(".") == 1:
if s.replace(".", "").isdigit():
result = True
return result

Lambda version

is_float = lambda x: x.replace('.','',1).isdigit() and "." in x

Exemple

if is_float(some_string):
some_string = float(some_string)
elif some_string.isdigit():
some_string = int(some_string)
else:
print "Does not convert to int or float."

De cette façon, vous n'avez pas accidentellement la conversion de ce que doit être un int, un float.

J'ai utilisé la fonction déjà mentionné, mais j'ai vite remarquer que les chaînes de caractères comme "Nan", "Inf" et variations sont considérées comme nombre. Donc je vous propose version améliorée de la fonction, qui sera de retour faux sur ces type d'entrée et ne manquera pas "1e3" variantes:

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

J'ai été à la recherche pour certains de code similaire, mais il ressemble à l'aide de try/si l'on excepte est le meilleur moyen.
Voici le code que j'utilise. Il comprend une nouvelle tentative de la fonction si l'entrée n'est pas valide. J'avais besoin de vérifier si la valeur d'entrée est supérieure à 0 et si oui, de le convertir à un flotteur.

def cleanInput(question,retry=False): 
inputValue = input("\n\nOnly positive numbers can be entered, please re-enter the value.\n\n{}".format(question)) if retry else input(question)
try:
if float(inputValue) <= 0 : raise ValueError()
else : return(float(inputValue))
except ValueError : return(cleanInput(question,retry=True))
willbefloat = cleanInput("Give me the number: ")