Convertir des valeurs en nombres flottants

Python

float() convertit les nombres et les chaînes numériques compatibles en nombres à virgule flottante en Python. Sans argument, elle renvoie 0.0, mais ne transforme pas automatiquement une chaîne vide ou None en zéro. Une conversion réussie ne garantit ni une valeur finie ni la précision décimale requise.

Conversion simple et valeur initiale

float(value) renvoie un résultat sans changer le type de la variable initiale. La virgule flottante représente les quantités avec un nombre fini de bits et peut approcher les fractions. La présence d’un point décimal ne prouve pas le type ou l’exactitude. Consultez la référence officielle de float().

Les exemples complets utilisent Python 3 et la bibliothèque standard. Enregistrez-les en UTF-8 dans float_example.py, puis lancez python float_example.py ou python3 selon l’environnement. Chaque exemple suivant peut remplacer le contenu du fichier et fonctionner seul.

value = 3
converted = float(value)
print(converted, type(converted).__name__)
print(value, type(value).__name__)
print(float("  -2.5  "))
print(float("1e3"))
print(float())
print(float(True))

Résultat attendu :

3.0 float
3 int
-2.5
1000.0
0.0
1.0

value reste un entier. Des espaces autour du texte, un signe ou une notation exponentielle comme 1e3 sont acceptés. True devient 1.0 : rejetez les booléens séparément si votre entrée ne les autorise pas.

Formats, ValueError et TypeError

Les chaînes numériques ordinaires utilisent . comme séparateur décimal. Séparateurs de milliers, virgules décimales et symboles monétaires ne sont pas interprétés automatiquement. Une chaîne mal formée provoque ValueError ; un objet incompatible comme None provoque TypeError.

for value in ("1,234.5", "2,5", "", None):
    try:
        print(float(value))
    except (ValueError, TypeError) as error:
        print(type(error).__name__)

ValueError
ValueError
ValueError
TypeError

Supprimer aveuglément les virgules peut transformer le décimal voulu 2,5 en 25. Définissez d’abord le format et les règles locales, puis normalisez selon ces seules règles. Décidez si une entrée vide est une erreur ou une donnée manquante, sans la confondre avec un vrai zéro.

Pourquoi 0.1 plus 0.2 peut différer de 0.3

La plupart des systèmes stockent les floats en virgule flottante binaire. Certaines fractions décimales n’ont pas de représentation binaire finie et sont approchées. Il s’agit d’une limite de représentation, pas d’un échec de conversion. Le tutoriel Python sur les flottants explique ce mécanisme.

import math
from decimal import Decimal

result = 0.1 + 0.2
print(result)
print(result == 0.3)
print(math.isclose(result, 0.3))
print(Decimal("0.1") + Decimal("0.2"))

0.30000000000000004
False
True
0.3

math.isclose() permet une comparaison approchée, avec des tolérances adaptées aux unités et à la précision demandée. Près de zéro, examinez aussi abs_tol. Pour des exigences décimales exactes, envisagez Decimal à partir de la chaîne décimale d’origine. Decimal(0.1) commence par une valeur binaire déjà approchée.

Vérifier NaN, l’infini et les dépassements

float() accepte nan et inf. NaN signifie Not a Number ; inf représente l’infini. Une analyse réussie n’est donc pas forcément une mesure finie valide. Utilisez math.isfinite() si une valeur finie est nécessaire.

import math

for text in ("nan", "inf", "-inf", "2.5"):
    number = float(text)
    print(text, math.isfinite(number))

nan False
inf False
-inf False
2.5 True

Une chaîne avec un exposant extrêmement grand peut donner l’infini, tandis qu’un entier immense peut provoquer OverflowError. NaN est même différent de lui-même : ne le détectez pas avec x == float("nan"). Utilisez math.isnan() pour ce besoin précis.

print(float("1e400"))
try:
    print(float(10 ** 400))
except OverflowError:
    print("OverflowError")
print(float("nan") == float("nan"))

inf
OverflowError
False

Accepter uniquement des nombres finis

Combinez gestion des erreurs de conversion et test de finitude. Cette fonction distingue une entrée mal formée d’une valeur non finie et ne renvoie un float qu’en cas de réussite. Les messages anglais de l’exemple peuvent être adaptés à vos utilisateurs.

import math

def finite_number(text):
    try:
        number = float(text)
    except (ValueError, TypeError) as error:
        raise ValueError("not a number") from error
    if not math.isfinite(number):
        raise ValueError("not finite")
    return number

for text in ("2.5", "nan", "abc"):
    try:
        print(finite_number(text))
    except ValueError as error:
        print(error)

2.5
not finite
not a number

La fonction vérifie seulement la finitude. Âges, quantités ou proportions peuvent aussi exiger des bornes et un contrôle d’intégralité. Ne remplacez pas chaque échec par 0.0, car les données invalides deviendraient indiscernables d’un vrai zéro.

Python