not - turn string to float python




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

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 une string float en float , et (séparément) une string int en un int .


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 une chaine float en float, et (séparément) une chaine int en un int.

C'est bien que vous demandiez de les faire séparément. Si vous les mélangez, vous risquez de vous exposer à des problèmes plus tard. La réponse simple est:

"545.2222" pour flotter:

>>> float("545.2222")
545.2222

"31" à un entier:

>>> int("31")
31

Autres conversions, entrées et sorties de chaînes et littéraux:

Conversions de diverses bases, et vous devriez connaître la base à l'avance (10 est la valeur par défaut). Notez que vous pouvez les préfixer avec ce que Python attend pour ses littéraux (voir ci-dessous) ou supprimer le préfixe:

>>> int("0b11111", 2)
31
>>> int("11111", 2)
31
>>> int('0o37', 8)
31
>>> int('37', 8)
31
>>> int('0x1f', 16)
31
>>> int('1f', 16)
31

Si vous ne connaissez pas la base à l'avance, mais que vous savez qu'ils auront le bon préfixe, Python peut déduire cela pour vous si vous passez 0 comme base:

>>> int("0b11111", 0)
31
>>> int('0o37', 0)
31
>>> int('0x1f', 0)
31

Littéraux non décimaux (entiers) d'autres bases

Si votre motivation est d'avoir votre propre code clairement représenter des valeurs spécifiques codées en dur, vous n'avez pas besoin de convertir à partir des bases - vous pouvez laisser Python le faire automatiquement pour vous avec la syntaxe correcte.

Vous pouvez utiliser les préfixes apropos pour obtenir la conversion automatique en entiers avec les littéraux suivants . Ceux-ci sont valables pour Python 2 et 3:

Binaire, préfixe 0b

>>> 0b11111
31

Octal, préfixe 0o

>>> 0o37
31

Hexadécimal, préfixe 0x

>>> 0x1f
31

Cela peut être utile lorsque vous décrivez des indicateurs binaires, des autorisations de fichier dans le code ou des valeurs hexadécimales pour les couleurs - par exemple, notez des guillemets:

>>> 0b10101 # binary flags
21
>>> 0o755 # read, write, execute perms for owner, read & ex for group & others
493
>>> 0xffffff # the color, white, max values for red, green, and blue
16777215

Faire des octets Python 2 ambigus compatibles avec Python 3

Si vous voyez un entier qui commence par 0, dans Python 2, c'est une syntaxe octale (obsolète).

>>> 037
31

C'est mauvais car il semble que la valeur devrait être 37 . Donc, dans Python 3, il soulève maintenant un SyntaxError :

>>> 037
  File "<stdin>", line 1
    037
      ^
SyntaxError: invalid token

Convertissez vos octets Python 2 en octals qui fonctionnent à la fois en 2 et en 3 avec le préfixe 0o :

>>> 0o37
31

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 lève une exception. Au lieu de cela, utilisez des méthodes dans les locale pour convertir les chaînes en nombres et interpréter les virgules correctement. La méthode locale.atof 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 la majorité des pays du monde , les virgules sont utilisées pour les décimales plutôt que pour les 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.


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

J'utilise cette fonction pour ça

import ast

def parse_str(s):
   try:
      return ast.literal_eval(str(s))
   except:
      return

Il va convertir la chaîne à son type

value = parse_str('1')  # Returns Integer
value = parse_str('1.5')  # Returns Float

L'analyseur YAML peut vous aider à déterminer le type de données de votre chaîne. Utilisez yaml.load() , puis vous pouvez utiliser type(result) pour tester le type:

>>> import yaml

>>> a = "545.2222"
>>> result = yaml.load(a)
>>> result
545.22220000000004
>>> type(result)
<type 'float'>

>>> b = "31"
>>> result = yaml.load(b)
>>> result
31
>>> type(result)
<type 'int'>

>>> c = "HI"
>>> result = yaml.load(c)
>>> result
'HI'
>>> type(result)
<type 'str'>

La question semble un peu vieille. Mais laissez-moi vous suggérer une fonction, parseStr, qui fait quelque chose de similaire, c'est-à-dire retourne un entier ou un float et si une chaîne ASCII donnée ne peut être convertie en aucune d'elles, elle la retourne intacte. Le code de cours pourrait être ajusté pour ne faire que ce que vous voulez:

   >>> import string
   >>> parseStr = lambda x: x.isalpha() and x or x.isdigit() and \
   ...                      int(x) or x.isalnum() and x or \
   ...                      len(set(string.punctuation).intersection(x)) == 1 and \
   ...                      x.count('.') == 1 and float(x) or x
   >>> parseStr('123')
   123
   >>> parseStr('123.3')
   123.3
   >>> parseStr('3HC1')
   '3HC1'
   >>> parseStr('12.e5')
   1200000.0
   >>> parseStr('12$5')
   '12$5'
   >>> parseStr('12.2.2')
   '12.2.2'

Python a cette grande souplesse d'analyse en un seul paquebot.

str = "545.2222"
print ("int: ", + int(float(a)))
print ("float: ", +(float(a)))

Si vous n'êtes pas opposé aux modules tiers, vous pouvez consulter le module fastnumbers . Il fournit une fonction appelée fast_real qui fait exactement ce que cette question demande et qui le fait plus rapidement 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

Utilisation:

def num(s):
    try:
        for each in s:
            yield int(each)
    except ValueError:
        yield float(each)
a = num(["123.55","345","44"])
print a.next()
print a.next()

C'est la manière la plus pythonienne que je puisse trouver.


Voici une autre interprétation de votre question (indice: c'est vague). Il est possible que vous cherchiez quelque chose comme ceci:

def parseIntOrFloat( aString ):
    return eval( aString )

Cela fonctionne comme ça ...

>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545

Théoriquement, il y a une vulnérabilité d'injection. La chaîne pourrait, par exemple, être "import os; os.abort()" . Sans arrière-plan d'où vient la chaîne, cependant, la possibilité est la spéculation théorique. Comme la question est vague, il n'est pas du tout certain que cette vulnérabilité existe ou non.


float("545.2222") et int(float("545.2222"))


Ceci est une version corrigée de https://.com/a/33017514/5973334

Cela va essayer d'analyser une chaîne et retourner int ou float fonction de ce que la chaîne représente. Il peut augmenter les exceptions d'analyse ou avoir un comportement inattendu .

  def get_int_or_float(v):
        number_as_float = float(v)
        number_as_int = int(number_as_float)
        return number_as_int if number_as_float == number_as_int else 
        number_as_float

def get_int_or_float(v):
    number_as_float = float(v)
    number_as_int = int(number_as_float)
    return number_as_int if number_as_float == number_as_int else number_as_float

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

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




integer