Numérique et sciences informatiques (spécialité) · Première

Les nombres réels en flottants : cours de Première NSI

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

Un ordinateur ne peut pas représenter exactement tous les nombres réels : il en garde une approximation, d'aussi près qu'on veut mais jamais parfaite.¹
La virgule flottante écrit un nombre comme en notation scientifique, en binaire : un signe, une mantisse et un exposant.²
L'ensemble des flottants est fini, et la mantisse a toujours le même nombre de chiffres significatifs : la précision relative est constante.²
Un nombre comme 1,1 a un développement binaire infini, coupé à la fin : d'où des erreurs d'arrondi et des résultats parfois inattendus.³
Conséquences en programmation : on ne compare pas deux flottants avec ==, on teste l'écart avec une tolérance, et l'ordre des additions peut changer le résultat.²

Introduction : un ordinateur ne connaît pas tous les réels

Tu as déjà vu en Python un calcul qui donne un résultat très légèrement faux, comme un 3.3000000000000003 là où tu attendais 3.3. Ce n'est pas un bogue du langage, et ce n'est pas non plus ta faute. C'est une conséquence directe de la façon dont la machine range les nombres à virgule dans sa mémoire.

Dans ce cours, tu vas comprendre cette représentation, appelée virgule flottante. Tu y retrouveras ce que tu sais déjà : l'écriture d'un entier en base 2 et la représentation des entiers relatifs. Il s'agit maintenant de ranger des nombres qui ne sont pas entiers.

Le fil conducteur est simple. La mémoire d'un ordinateur est finie : un nombre y occupe un nombre fixé de bits. Or il existe une infinité de nombres réels, et beaucoup d'entre eux ont une écriture infinie. Il faut donc accepter de ne garder qu'une approximation.

Le cours suit cet ordre : d'abord le problème (pourquoi approcher), puis la solution (la notation scientifique binaire), puis la conversion des parties décimales, et enfin les conséquences concrètes sur tes programmes.

Pourquoi il faut approcher les nombres réels

Un nombre réel peut avoir une infinité de chiffres après la virgule. Pense à $\frac{1}{3} = 0{,}333\ldots$ en base 10. Une machine qui n'a qu'un nombre limité de cases mémoire ne peut pas tout écrire. Les documents de calcul scientifique le disent sans détour : il est impossible de représenter exactement tous les nombres réels.¹

La bonne nouvelle, c'est qu'on peut approcher n'importe quel réel d'aussi près qu'on le souhaite.¹ Cette idée est ancienne. Les nombres décimaux, c'est-à-dire les nombres qui s'écrivent avec un nombre fini de chiffres après la virgule, servent précisément à approcher n'importe quel réel et à calculer avec ces valeurs comme on le fait avec les entiers.³ Leur emploi s'est diffusé peu à peu : d'abord dans le monde arabe aux alentours du Xe siècle, puis en Europe jusqu'au XVIe siècle, où Viète et Stevin ont contribué à le populariser. Cette évolution a fini par déboucher sur le système métrique, adopté au moment de la Révolution française.³

Tout l'enjeu de ce cours est de savoir quelle approximation la machine choisit, avec combien de chiffres, et ce que cela change pour les calculs.

Une analogie utile : quand tu mesures une longueur avec une règle graduée en millimètres, tu ne peux pas annoncer une valeur plus fine que le millimètre. La règle impose une précision. L'ordinateur est dans la même situation, sauf que sa graduation est binaire et que son nombre de graduations est fixé à l'avance.

Virgule fixe et virgule flottante

Il existe deux grandes façons de ranger un nombre à virgule. La première est la virgule fixe : on décide une fois pour toutes combien de chiffres se trouvent après la virgule. La représentation en virgule fixe indique un nombre entier d'un sous-multiple de l'unité. Par exemple, $1234{,}567$ est une façon commode d'écrire $1234$ et $567$ millièmes, soit $1\,234\,567$ millièmes.²

La seconde est la virgule flottante. Il s'agit d'une méthode d'écriture très utilisée dans les ordinateurs, régie par la norme IEEE 754, qui équivaut à la notation scientifique en numération binaire.² La virgule « flotte » : sa position n'est pas fixée, c'est un exposant qui la décale.

Virgule fixe et virgule flottante
Critère	Virgule fixe	Virgule flottante
Principe	Nombre entier d'un sous-multiple de l'unité	Notation scientifique en binaire
Position de la virgule	Fixée à l'avance	Décalée par l'exposant
Intervalle de valeurs	Plus restreint	Plus étendu à nombre de bits égal
Chiffres significatifs	Variables selon la taille du nombre	Toujours le même nombre

Virgule fixe et virgule flottante

Signe, mantisse, exposant : la notation scientifique binaire

Rappelle-toi la notation scientifique en base 10 : le nombre $-5{,}2 \times 10^{3}$ se lit comme un signe ( $-$ ), des chiffres significatifs ( $5{,}2$ ) et une puissance de la base ( $10^3$ ). La virgule flottante fait exactement la même chose, mais en base 2.

Il reste une conséquence capitale : le nombre de bits réservés à la mantisse est limité. L'ensemble des flottants est un ensemble fini, dont le nombre d'éléments dépend de la base de représentation et du nombre de chiffres de la mantisse et de l'exposant.² On le note parfois $F(\beta, r, m, M)$ , où $\beta$ est la base et $r$ le nombre de chiffres de la mantisse, $m$ et $M$ bornant l'exposant.¹

Signe0 pour un nombre positif, 1 pour négatif
MantisseChiffres significatifs, de la forme 1,b1b2b3…
ExposantPuissance de 2 qui décale la virgule

Les trois éléments d'un flottant

Convertir une partie décimale en binaire

Pour la partie entière, tu connais déjà la méthode des divisions successives par 2. Pour la partie après la virgule, on fait l'inverse : on multiplie par 2 et on note la partie entière obtenue à chaque fois.

Multiplier par 2Calculer 2f, où f est la partie fractionnaire
Noter le chiffreLa partie entière de 2f vaut 0 ou 1
Garder le resteNouveau f : la partie fractionnaire de 2f
RecommencerArrêt si f = 0 ou si f déjà vu

Convertir une partie fractionnaire

ExempleCas d'une écriture finie : 0,625

Étape	$f$	$2f$	Chiffre
1	0,625	1,25	1
2	0,25	0,5	0
3	0,5	1,0	1

La partie fractionnaire devient 0 : on s'arrête. Donc $0{,}625 = 0{,}101_2$ . Vérification : $\frac{1}{2} + \frac{1}{8} = 0{,}625$ . Ce nombre sera représenté exactement en flottant, car il est une somme de puissances de 2 négatives.

Démonstration · Pourquoi 0,1 ne peut pas avoir d'écriture binaire finie

Supposons qu'on ait $0{,}1 = \frac{k}{2^p}$ avec $k$ entier et $p$ entier naturel (c'est ce que signifierait une écriture binaire finie). Alors $2^p = 10k$ , donc $2^p$ serait un multiple de $10$ , donc de $5$ . Or les seuls diviseurs premiers de $2^p$ sont 2. C'est contradictoire. Donc $0{,}1$ n'a pas d'écriture binaire finie.

Erreurs d'arrondi : ce qui se passe vraiment en Python

Que fait la machine quand l'écriture binaire est infinie ? Elle coupe le développement après le nombre de chiffres que sa mantisse peut contenir, puis arrondit. Dans le format binaire double précision de la norme IEEE 754, qui est le plus courant, le codage de $1{,}1$ coupe le développement à 52 chiffres binaires.³ L'erreur ainsi commise est une erreur d'arrondi.

Cette erreur est minuscule, mais elle existe, et elle peut produire des affichages inattendus, par exemple quand on calcule $3 \times 1{,}1$ en Python.³ Les langages de programmation acceptent et affichent les nombres sous forme décimale, mais la plupart du temps ils calculent avec des flottants binaires, qui sont des approximations.³ Ce que tu tapes (1.1) et ce que la machine stocke ne sont donc pas tout à fait le même nombre.

ExempleMesurer l'erreur dans un petit format inventé

Pour voir le mécanisme sans manipuler 52 bits, imaginons un format jouet où la mantisse garde 4 chiffres après la virgule, avec troncature. Représentons $0{,}1$ .

Écriture binaire : $0{,}1 = 0{,}0001100110011\ldots_2$ .
Normalisation : on décale de 4 rangs, donc $0{,}1 = 1{,}100110011\ldots_2 \times 2^{-4}$ .
Troncature à 4 chiffres : mantisse $1{,}1001_2 = \frac{25}{16} = 1{,}5625$ .
Valeur stockée : $\frac{25}{16} \times \frac{1}{16} = \frac{25}{256} = 0{,}09765625$ .

Le format jouet enregistre donc $0{,}09765625$ au lieu de $0{,}1$ , soit une erreur d'environ $0{,}0023$ . Avec 52 chiffres, la même démarche donne une erreur bien plus petite, mais jamais nulle.

MéthodeComparer deux flottants correctement

Choisis une tolérance $\varepsilon$ adaptée au problème, par exemple 1e-9.
Calcule l'écart abs(a - b).
Conclus que les nombres sont égaux « au sens de la machine » si abs(a - b) < eps.

def presque_egaux(a, b, eps=1e-9):
    return abs(a - b) < eps

Une autre conséquence concerne l'addition. Dans l'ensemble des réels, additionner $(a + b) + c$ ou $a + (b + c)$ donne le même résultat. Pour les flottants, ce n'est plus vrai : l'addition n'est pas associative, et l'ordre des calculs a donc de l'importance.²

Bilan : précision, intervalle et bonnes pratiques

Résumons ce que la représentation en flottants apporte et ce qu'elle coûte.

Flottants

Structure
- Signe
- Mantisse
- Exposant
Avantages
- Grand intervalle
- Précision constante
Limites
- Ensemble fini
- Arrondis
- Non associatif
Bonnes pratiques
- Tolérance
- Entiers exacts
- Ordre des calculs

Carte du chapitre

ExempleUne boucle qui ne s'arrête pas comme prévu

Considère ce programme :

x = 0.0
while x != 1.0:
    x = x + 0.1

On attend 10 tours. Mais comme $0{,}1$ est stocké de façon approchée, la somme de dix termes approchés n'a aucune raison de tomber exactement sur $1{,}0$ : la condition x != 1.0 reste vraie et la boucle peut ne jamais se terminer. La version correcte compte avec un entier (for i in range(10)) ou teste x < 1.0 - eps.

Exercices corrigés

Exercice 1 Lire un nombre binaire à virgule

★☆☆Environ 5 min

Donne la valeur décimale du nombre binaire $0{,}1101_2$ .

Indice 1

Chaque chiffre après la virgule a pour poids $\frac{1}{2}$ , $\frac{1}{4}$ , $\frac{1}{8}$ , $\frac{1}{16}$ , dans cet ordre.

Voir la correction pas à pas

On repère les poids : le premier chiffre vaut $\frac{1}{2}$ , le deuxième $\frac{1}{4}$ , le troisième $\frac{1}{8}$ , le quatrième $\frac{1}{16}$ .
Les chiffres de $0{,}1101_2$ sont 1, 1, 0, 1. On garde les poids des chiffres égaux à 1 : $\frac{1}{2}$ , $\frac{1}{4}$ et $\frac{1}{16}$ .
On additionne : $\frac{8}{16} + \frac{4}{16} + \frac{1}{16} = \frac{13}{16}$ .
On convertit : $\frac{13}{16} = 0{,}8125$ .

Le nombre $0{,}1101_2$ vaut $0{,}8125$ en décimal. Il est exactement représentable puisque son dénominateur est une puissance de 2.

Exercice 2 Trouver l'exposant d'un nombre

★★☆Environ 8 min

On écrit $6{,}5$ sous la forme $1{,}m \times 2^e$ (mantisse comprise entre 1 et 2). Quelle est la valeur de l'exposant $e$ ? Donne ensuite la mantisse.

Indice 1

Cherche la plus grande puissance de 2 qui ne dépasse pas $6{,}5$ .

Indice 2

La mantisse est $\frac{6{,}5}{2^e}$ .

Voir la correction pas à pas

On écrit les puissances de 2 : $2^1 = 2$ , $2^2 = 4$ , $2^3 = 8$ .
On encadre : $4 \leq 6{,}5 < 8$ , soit $2^2 \leq 6{,}5 < 2^3$ . La plus grande puissance de 2 inférieure à $6{,}5$ est $2^2$ , donc $e = 2$ .
On calcule la mantisse : $m = \frac{6{,}5}{4} = 1{,}625$ .
On convertit $1{,}625$ en binaire : $1 + \frac{1}{2} + \frac{1}{8}$ , donc $1{,}101_2$ . On retrouve l'écriture $6{,}5 = 1{,}101_2 \times 2^2$ .

L'exposant vaut $2$ et la mantisse vaut $1{,}625$ , soit $1{,}101_2$ en binaire.

Exercice 3 Mesurer une erreur d'arrondi

★★★Environ 15 min

On considère un format jouet qui garde, pour la mantisse $1,b_1b_2b_3b_4$ , 4 chiffres binaires après la virgule, les suivants étant supprimés (troncature). On y stocke le nombre $0{,}1$ , qui s'écrit $1{,}6 \times 2^{-4}$ avec une mantisse décimale de $1{,}6$ .

Calcule l'erreur $0{,}1 - x$ , où $x$ est la valeur réellement stockée.

Indice 1

Convertis $1{,}6$ en binaire avec la méthode des multiplications par 2 sur $0{,}6$ .

Indice 2

Une fois la mantisse tronquée convertie en fraction, multiplie-la par $2^{-4}$ .

Voir la correction pas à pas

On convertit $0{,}6$ : $0{,}6 \times 2 = 1{,}2$ (chiffre 1), $0{,}2 \times 2 = 0{,}4$ (chiffre 0), $0{,}4 \times 2 = 0{,}8$ (chiffre 0), $0{,}8 \times 2 = 1{,}6$ (chiffre 1). On retrouve ensuite $0{,}6$ et les chiffres se répètent : $1{,}6 = 1{,}1001\,1001\ldots_2$ .
On tronque à 4 chiffres après la virgule : la mantisse stockée est $1{,}1001_2 = 1 + \frac{1}{2} + \frac{1}{16} = \frac{25}{16}$ .
La valeur stockée est $x = \frac{25}{16} \times 2^{-4} = \frac{25}{256}$ .
L'erreur est $0{,}1 - \frac{25}{256} = \frac{256 - 250}{2560} = \frac{6}{2560} = 0{,}00234375$ .

Le format jouet stocke $0{,}09765625$ au lieu de $0{,}1$ , soit une erreur de $0{,}00234375$ par défaut. Avec plus de chiffres dans la mantisse, l'erreur diminue mais ne s'annule jamais, car l'écriture de $0{,}1$ est infinie.

Les questions qu'on se pose

Pourquoi 0,1 + 0,2 ne donne-t-il pas exactement 0,3 en Python ?

Parce que ni $0{,}1$ ni $0{,}2$ n'ont d'écriture binaire finie : la machine stocke deux approximations, chacune coupée après un nombre fixé de chiffres binaires.³ Leur somme porte la trace de ces deux arrondis, et le résultat peut différer très légèrement de la valeur stockée pour $0{,}3$ , qui est elle aussi une approximation. Ce n'est pas un bogue de Python, mais la conséquence du codage binaire des décimaux.

À quoi sert d'avoir un exposant ?

L'exposant décale la virgule, comme le fait $10^3$ en notation scientifique. Grâce à lui, avec le même nombre de bits, on peut écrire à la fois de très petits et de très grands nombres.² Sans exposant (virgule fixe), il faudrait choisir à l'avance une précision unique, donc sacrifier soit les petites valeurs, soit les grandes.

Comment savoir si un nombre décimal est exactement représentable en binaire ?

Écris-le sous forme de fraction irréductible. S'il peut s'écrire $\frac{k}{2^p}$ , c'est-à-dire si le dénominateur est une puissance de 2, son écriture binaire est finie, donc il est représentable exactement tant que sa mantisse tient dans les bits disponibles. Exemple : $0{,}375 = \frac{3}{8}$ est exact, alors que $0{,}1 = \frac{1}{10}$ ne l'est pas.

Faut-il toujours se méfier des flottants ?

Non. Pour la plupart des calculs scientifiques, l'erreur d'arrondi est très petite devant les incertitudes des données elles-mêmes, et les flottants sont efficaces. Il faut surtout éviter deux pièges : comparer avec == des résultats de calculs, et utiliser des flottants pour des quantités qui doivent être exactes (comptes en centimes, par exemple, qu'on range plutôt dans des entiers).

Est-ce que ce chapitre tombe au bac de NSI ?

La représentation des nombres en machine fait partie des notions de base de la spécialité. Des questions peuvent demander de convertir un nombre en binaire, de reconnaître qu'une écriture est infinie, ou d'expliquer pourquoi un test d'égalité entre flottants échoue. Savoir justifier par la forme $\frac{k}{2^p}$ est une réponse solide.

Sources

Arithmétique des ordinateurs - Représentation en virgule flottante, CNRS (Calcul). Consulté le 6 novembre 2026.
Virgule flottante, Wikipédia. Consulté le 6 novembre 2026.
Nombre décimal, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Les nombres réels en flottants : cours de Première NSI

L'essentiel

Introduction : un ordinateur ne connaît pas tous les réels

Pourquoi il faut approcher les nombres réels

Virgule fixe et virgule flottante

Signe, mantisse, exposant : la notation scientifique binaire

Convertir une partie décimale en binaire

Erreurs d'arrondi : ce qui se passe vraiment en Python

Bilan : précision, intervalle et bonnes pratiques

Exercices corrigés

Exercice 1 Lire un nombre binaire à virgule

Exercice 2 Trouver l'exposant d'un nombre

Exercice 3 Mesurer une erreur d'arrondi

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur

Étape	$f$	$2f$	Chiffre
1	0,1	0,2	0
2	0,2	0,4	0
3	0,4	0,8	0
4	0,8	1,6	1
5	0,6	1,2	1
6	0,2	0,4	0