Question Comment puis-je analyser une chaîne à un float ou un int en Python?


En Python, comment puis-je analyser une chaîne numérique comme "545.2222" à sa valeur flottante correspondante, 542.2222? Ou analyser la chaîne "31" à un entier, 31?

Je veux juste savoir comment analyser flotte  string à un floatet (séparément) un int  string à un int.


1757
2017-12-19 01:52


origine


Réponses:


>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545

2084
2017-12-19 01:54



def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)

441
2017-12-19 02:31



Méthode Python pour vérifier si une chaîne est un float:

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

Un nom plus long et plus précis pour cette fonction pourrait être: isConvertibleToFloat(value)

Qu'est-ce qui est et n'est pas un flotteur Python peut vous surprendre:

val                   isfloat(val) Note
--------------------  ----------   --------------------------------
""                    False        Blank string
"127"                 True         Passed string
True                  True         Pure sweet Truth
"True"                False        Vile contemptible lie
False                 True         So false it becomes true
"123.456"             True         Decimal
"      -127    "      True         Spaces trimmed
"\t\n12\r\n"          True         whitespace ignored
"NaN"                 True         Not a number
"NaNanananaBATMAN"    False        I am Batman
"-iNF"                True         Negative infinity
"123.E4"              True         Exponential notation
".1"                  True         mantissa only
"1,234"               False        Commas gtfo
u'\x30'               True         Unicode is fine.
"NULL"                False        Null is not special
0x3fade               True         Hexadecimal
"6e7777777777777"     True         Shrunk to infinity
"1.797693e+308"       True         This is max value
"infinity"            True         Same as inf
"infinityandBEYOND"   False        Extra characters wreck it
"12.34.56"            False        Only one dot allowed
u'四'                 False        Japanese '4' is not a float.
"#56"                 False        Pound sign
"56%"                 False        Percent of what?
"0E0"                 True         Exponential, move dot 0 places
0**0                  True         0___0  Exponentiation
"-5e-5"               True         Raise to a negative number
"+1e1"                True         Plus is OK with exponent
"+1e1^5"              False        Fancy exponent not interpreted
"+1e1.3"              False        No decimals in exponent
"-+1"                 False        Make up your mind
"(1)"                 False        Parenthesis is bad

Tu penses savoir quels sont les nombres? Vous n'êtes pas si bon que vous le pensez! Pas grosse surprise.


416
2018-01-05 04:15



C'est une autre méthode qui mérite d'être mentionnée ici, ast.literal_eval:

Cela peut être utilisé pour évaluer en toute sécurité des chaînes contenant des expressions Python de sources non fiables sans avoir besoin d'analyser les valeurs soi-même.

Autrement dit, un 'eval' sûr

>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31

104
2018-03-01 04:23



float(x) if '.' in x else int(x)

74
2017-12-19 02:32



Localisation et virgules

Vous devriez considérer la possibilité de virgules dans la représentation sous forme de chaîne d'un nombre, pour des cas comme float("545,545.2222") qui jette une exception. Au lieu de cela, utilisez des méthodes dans locale convertir les chaînes en nombres et interpréter les virgules correctement. le locale.atof méthode convertit en un seul flottant une fois que les paramètres régionaux ont été définis pour la convention de nombre souhaitée.

Exemple 1 - Conventions de numérotation des États-Unis 

Aux États-Unis et au Royaume-Uni, les virgules peuvent être utilisées comme séparateur de milliers. Dans cet exemple avec les paramètres régionaux américains, la virgule est correctement gérée en tant que séparateur:

>>> import locale
>>> a = u'545,545.2222'
>>> locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
'en_US.UTF-8'
>>> locale.atof(a)
545545.2222
>>> int(locale.atof(a))
545545
>>>

Exemple 2 - Conventions de numérotation européennes

dans le majorité des pays du monde, les virgules sont utilisées pour les virgules décimales au lieu des points. Dans cet exemple avec les paramètres régionaux français, la virgule est correctement gérée comme une marque décimale:

>>> import locale
>>> b = u'545,2222'
>>> locale.setlocale(locale.LC_ALL, 'fr_FR')
'fr_FR'
>>> locale.atof(b)
545.2222

La méthode locale.atoi est également disponible, mais l'argument doit être un entier.


45
2017-07-23 16:00



Utilisateurs codélogique et harley sont corrects, mais gardez à l'esprit si vous savez que la chaîne est un nombre entier (par exemple, 545), vous pouvez appeler int ("545") sans lancer d'abord pour float.

Si vos chaînes sont dans une liste, vous pouvez également utiliser la fonction de carte.

>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>

C'est seulement bon s'ils sont tous du même type.


22
2017-12-19 02:09



Si vous n'êtes pas opposé aux modules tiers, vous pouvez consulter le fastnumbers module. Il fournit une fonction appelée fast_real cela fait exactement ce que cette question demande et le fait plus vite qu'une implémentation pure-Python:

>>> from fastnumbers import fast_real
>>> fast_real("545.2222")
545.2222
>>> type(fast_real("545.2222"))
float
>>> fast_real("31")
31
>>> type(fast_real("31"))
int

21
2017-08-14 03:21