Nombres et flottants (float)

Python a deux types numériques

Python dispose de deux types numériques principaux pour manipuler les nombres : int pour les entiers et float (virgule flottante) pour les décimaux.

Les deux sont des nombres, donc tu peux effectuer toutes les opérations arithmétiques de base — addition, soustraction, multiplication, division et modulo — avec l'un ou l'autre.

Mais leur syntaxe et leur précision diffèrent, et tu choisis donc le bon pour chaque situation.

Même si la valeur ressemble à un nombre entier, ajouter .0 comme 3.0 en fait un float. À l'inverse, écrire simplement 175 en fait un int.

Les nombres négatifs fonctionnent de la même manière — -5 est un int, -5.5 est un float.

# int (nombre entier)
age = 25
print(type(age))      # <class 'int'>

# float (virgule flottante)
weight = 175.5
print(type(weight))   # <class 'float'>

# Même "3", types différents selon l'écriture
print(type(3))        # <class 'int'>
print(type(3.0))      # <class 'float'>

# Les négatifs fonctionnent pareil
print(type(-10))      # <class 'int'>
print(type(-10.5))    # <class 'float'>

Vérifie la différence entre int et float dans le terminal.

① Crée count = 7 et pi = 3.14, puis affiche les deux valeurs et types avec print().

② Écris print(type(3.0)) pour voir de tes propres yeux que 3 et 3.0 ont des types différents.

Tour rapide des opérateurs

Il y a 7 opérateurs que tu utilises pour les calculs numériques. Les quatre opérations de base + - * / fonctionnent comme dans d'autres langages, mais // (division entière), % (modulo) et ** (exponentiation) reviennent souvent en Python, donc autant les bien maîtriser.

/ retourne un float même entre ints

10 / 2 vaut 5.0 (float), pas 5.

Le / de Python est conçu pour toujours retourner un float, donc le résultat est un float même quand les deux opérandes sont des ints.

Si tu veux un résultat entier, utilise plutôt //.

# Arithmétique de base
print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30

# La division retourne toujours un float
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0  (toujours un float même si la division tombe juste)

# Division entière (tronque) et modulo
print(10 // 3)   # 3
print(10 % 3)    # 1

# Exponentiation : a ** b signifie « a à la puissance b »
print(2 ** 10)   # 1024
print(3 ** 2)    # 9
print(2 ** 0.5)  # 1.4142135623730951  (utilisable comme racine carrée)

Voyons combien de minutes et de secondes vaut seconds = 365.

① Utilise // pour afficher « combien de minutes ».

② Utilise % pour afficher « combien de secondes restantes ».

③ Utilise `** pour afficher 2 à la puissance 8 (256).

④ Affiche 10 / 2 et confirme que le résultat est un float (5.0) même quand la division tombe juste.

Opérateurs d'affectation combinée (+= / -= etc.)

Les schémas du genre « x = x + 1 » — où tu fais quelque chose à une variable et réécris le résultat dans elle-même — reviennent tout le temps.

Tu peux les raccourcir en « x += 1 », et ces formes raccourcies s'appellent les opérateurs d'affectation combinée.

Chacun de `+ - / // % * a une forme combinée.

score = 10

score += 5      # 10 + 5 -> 15
print(score)    # 15

score *= 2      # 15 * 2 -> 30
print(score)    # 30

score -= 7      # 30 - 7 -> 23
print(score)    # 23

# Fonctionne pareil avec float
weight = 60.0
weight += 1.5
print(weight)   # 61.5

Mets à jour les PV d'un personnage en partant de hp = 100, avec l'affectation combinée.

① Diminue hp de 30 et affiche.

② Puis double hp et affiche.

③ Puis remplace hp par le reste de hp divisé par 5, et affiche.

Mélange d'int et de float dans les opérations

Quand tu mélanges int et float, le résultat est toujours un float. C'est parce que Python promeut automatiquement vers le type le plus précis.

Comme mentionné ci-dessus, / (division) retourne un float même entre ints, alors que // (division entière) retourne un int quand les deux opérandes sont des ints.

# int avec int reste int
print(10 + 3)        # 13   -> int
print(type(10 + 3))  # <class 'int'>

# Si un côté est float, le résultat est un float
print(10 + 3.0)         # 13.0
print(type(10 + 3.0))   # <class 'float'>

# / retourne un float même entre ints
print(10 / 2)           # 5.0
print(type(10 / 2))     # <class 'float'>

# // reste int quand les deux sont des ints
print(10 // 3)          # 3
print(type(10 // 3))    # <class 'int'>

# // devient float si un côté est float
print(10 // 3.0)        # 3.0
print(type(10 // 3.0))  # <class 'float'>

Essaie de prédire le type du résultat, puis vérifie-le.

① Affiche le résultat et le type de 7 + 2.

② Affiche le résultat et le type de 7 + 2.0.

③ Affiche le résultat et le type de 10 / 5 (remarque que c'est un float même quand la division est exacte).

Les float ont une précision limitée

Les ordinateurs stockent les float sous forme d'approximation binaire. C'est pourquoi même des calculs d'apparence simple peuvent produire une petite erreur.

L'exemple ci-dessous est un classique « piège des float » — chaque débutant tombe dessus à un moment donné.

Voyons l'erreur de tes propres yeux.

① Affiche 0.1 + 0.2 (confirme que ça ne devient pas 0.3).

② Affiche 0.1 + 0.1 + 0.1.

③ Affiche 0.1 + 0.2 == 0.3 (ce ne sera pas True).

Utilise Decimal quand tu as besoin de calculs exacts

Dans les situations où même une petite erreur est inacceptable — comme les calculs d'argent — tu peux faire des calculs décimaux exacts avec le type Decimal de la bibliothèque standard. On ne le couvrira pas dans cet article, mais retiens juste : « float est une approximation » et « il existe un autre outil pour les calculs exacts ».

Changer de type avec int() et float()

Pour convertir entre types numériques, utilise les fonctions intégrées int() et float().

Attention à une chose : int() tronque la partie décimale — il n'arrondit pas. Donc passer 3.9 à int() te donne 3, pas 4. Pour les valeurs négatives, il arrondit vers zéro, donc -3.9 devient -3, pas -4.

# float -> int c'est « tronquer » (PAS arrondir !)
print(int(3.9))     # 3
print(int(3.1))     # 3
print(int(-3.9))    # -3   (arrondi vers zéro)

# int -> float ajoute juste .0
print(float(5))     # 5.0
print(float(-2))    # -2.0

# Utiliser la conversion via une variable
a = 3.9
a = int(a)
print(a, type(a))       # 3 <class 'int'>

b = 5
b = float(b)
print(b, type(b))       # 5.0 <class 'float'>

Vérifions le comportement de int().

① Affiche le résultat de int(7.8) (il n'arrondit pas).

② Affiche le résultat de int(-7.8) (vois dans quelle direction il arrondit côté négatif).

③ Affiche le résultat et le type de float(10).

Dans cet article, tu as appris :

• La différence entre int et float
• L'exponentiation avec « ** » et l'affectation combinée (+= et compagnie)
• La différence de type de retour entre « / » (division) et « // » (division entière)
• Les problèmes de précision des float
• La conversion de type avec int() / float()