Float Python : Qu’est-ce que c’est et Comment l’Utiliser ?

Besoin de comprendre ce qu’est un float en Python ? C’est l’un des types de nombres les plus courants.

Ce guide vous montre comment utiliser un float et la fonction `float()` avec des exemples clairs.

La fonction `float()` : Syntaxe et exemples fondamentaux

En Python, la fonction intégrée `float()` est le moyen le plus direct de créer un nombre à virgule flottante à partir d’un autre type de donnée, comme un entier ou une chaîne de caractères.

Voici comment elle réagit selon ce que vous lui donnez :

• Avec un nombre entier (int) : La fonction ajoute simplement un point et un zéro. Par exemple, float(8) retourne 8.0.
• Avec un autre float : La fonction ne change rien. float(10.1) retourne 10.1. C’est déjà le bon format.
• Sans aucun argument : Si vous appelez la fonction vide, float() retourne 0.0.
• Avec une chaîne de caractères (string) : Tant que la chaîne contient un nombre valide, la conversion fonctionne. float("100") retourne 100.0.
• Avec une notation scientifique en string : La fonction gère aussi ce format. Par exemple, float("7e3") (qui signifie 7 * 10³) retourne 7000.0.

Comment créer et déclarer un nombre `float` en Python ?

Il existe plusieurs manières de créer une variable de type `float`. Ce n’est pas toujours en utilisant la fonction `float()`.

Voici les méthodes les plus courantes que vous utiliserez dans votre code.

Par affectation directe

La façon la plus simple de créer un `float` est d’assigner une valeur contenant un point décimal à une variable. Python reconnaîtra automatiquement ce type.

Par exemple :

valeur = 1000.0
print(type(valeur))

Ce code affichera <class 'float'>, ce qui confirme que la variable `valeur` est bien un nombre à virgule flottante. Ça fonctionne aussi avec les nombres négatifs, comme `valeur = -25.5`.

Avec la notation scientifique (e ou E)

Pour représenter des nombres très grands ou très petits, vous pouvez utiliser la notation scientifique. Elle se note avec la lettre `e` (ou `E`) suivie de la puissance de 10.

Voici deux exemples :

• Pour un grand nombre : valeur = 10e2. C’est équivalent à 10 * 10², ce qui donne 1000.0. Le type est `float`.
• Pour un petit nombre : valeur = 123e-3. C’est équivalent à 123 * 10⁻³, ce qui donne 0.123.

Cette syntaxe est très utilisée dans les domaines scientifiques pour manipuler des valeurs qui seraient difficiles à écrire autrement.

À partir d’opérations mathématiques

En Python, dès qu’une opération mathématique implique au moins un nombre `float`, le résultat est toujours un `float`. C’est une règle importante à connaître.

Même si vous additionnez un entier et un `float`, le résultat sera « contaminé » et deviendra un `float` pour ne pas perdre de précision.

resultat = 10 + 3.0
print(resultat) # Affiche 13.0
print(type(resultat)) # Affiche <class 'float'>

De plus, la division standard (avec le symbole `/`) produit presque toujours un `float`, même si vous divisez deux entiers. Par exemple, 10 / 2 ne donnera pas l’entier `5` mais le `float` `5.0`.

À quoi sert un `float` en Python ? Les cas d’usage concrets

Les nombres entiers (`int`) sont utiles, mais ils ne suffisent pas pour tout. Les `float` sont nécessaires dans de nombreuses situations où la précision est clé.

Pour des calculs de haute précision

C’est le cas d’usage le plus évident. Dans les domaines scientifiques, financiers ou statistiques, vous manipulez rarement des nombres ronds. Avoir des décimales est indispensable pour que les calculs soient justes.

Pour manipuler des nombres très grands ou très petits

La notation scientifique (`e`) permet de gérer facilement des valeurs extrêmes sans avoir à écrire des dizaines de zéros. Python permet de manipuler ces nombres sans effort grâce au type `float`.

Pour représenter l’infini (`inf`)

Un `int` ne peut pas représenter une valeur infinie. Un `float`, si. Python utilise les chaînes de caractères `’inf’` ou `’infinity’` pour ça. C’est très pratique dans certains calculs mathématiques où le résultat peut tendre vers l’infini.

• float('inf') pour l’infini positif.
• float('-inf') pour l’infini négatif.

Toute opération sur une valeur `inf` (comme `inf + 100`) donnera toujours `inf`.

Pour représenter des valeurs indéfinies (`NaN`)

Parfois, un calcul n’a pas de résultat numérique possible. Par exemple, la racine carrée d’un nombre négatif ou la division de zéro par zéro. Dans ce cas, Python utilise une valeur spéciale : `NaN` (Not a Number).

Vous pouvez créer cette valeur avec `float(‘nan’)`. `NaN` est utile pour signaler qu’un résultat est indéfini sans faire planter le programme.

Pièges et erreurs à éviter avec les `float`

Travailler avec des `float` est simple en apparence, mais il y a deux pièges courants que tout développeur, même débutant, doit connaître.

Le problème de la précision en virgule flottante

C’est le piège le plus connu. À cause de la manière dont les ordinateurs stockent les nombres à virgule en binaire, certains calculs simples peuvent donner des résultats surprenants.

A = 1.1 + 2.2
print(A) # Affiche 3.3000000000000003
print(A == 3.3) # Affiche False

# La bonne méthode
print(abs(A - 3.3) < 0.001) # Affiche True

Les erreurs de conversion (`ValueError`)

La fonction `float()` est puissante, mais elle ne peut pas faire de miracles. Si vous essayez de convertir une chaîne de caractères qui n’est pas un nombre, Python lèvera une erreur de type `ValueError`.

Voici deux exemples d’erreurs courantes :

• Chaîne non numérique : float("abc") provoquera une erreur car « abc » n’est pas un nombre.
• Mauvais séparateur décimal : En programmation, le séparateur décimal est le point (`.`), pas la virgule (`,`). Essayer `float(« 7,3 »)` génèrera aussi une `ValueError`.

Pour éviter que votre programme ne s’arrête, il est possible de gérer cette erreur avec un bloc `try…except`.

Méthodes utiles des objets `float`

Les objets `float` en Python viennent avec quelques méthodes spécifiques. Elles sont moins utilisées au quotidien mais peuvent être pratiques dans certains cas avancés.

• `is_integer()` : Retourne `True` si le `float` a une partie décimale nulle (par exemple, `10.0`). Sinon, elle retourne `False`.
• `as_integer_ratio()` : Retourne une paire de nombres entiers (un tuple) dont le ratio est exactement égal au `float`. Par exemple, pour `0.5`, elle retourne `(1, 2)`.
• `hex()` : Retourne la représentation hexadécimale (base 16) du nombre `float` sous forme de chaîne de caractères.
• `fromhex()` : C’est l’inverse de `hex()`. Elle permet de créer un `float` à partir de sa représentation hexadécimale.

Ce qu’il faut retenir sur le float en Python

Pour résumer, voici les points essentiels à garder en tête sur le type `float` en Python :

• Un `float` est un nombre avec une partie décimale, comme 12.5.
• Il se crée avec un point, la fonction float() ou la notation scientifique `e`.
• Le résultat d’une division / est toujours un `float`.
• Il faut se méfier des problèmes de précision et ne jamais comparer deux `float` avec `==`.