Représentation des entiers et des flottants

Vue d'ensemble

Une machine ne connaît que des 0 et des 1. Pour qu'un ordinateur manipule le nombre $13$ ou le nombre $0, 1$ , il faut d'abord le coder avec des bits. Ce chapitre explique comment : les entiers en base 2, les entiers négatifs par complément à deux, et pourquoi les nombres à virgule (les flottants) réservent des surprises — au point que 0.1 + 0.2 ne vaut pas 0.3 pour l'ordinateur.

Au programme (BO 2021, Sup) — Représentation binaire des entiers naturels ; représentation des entiers relatifs (complément à deux, taille fixe) ; notion de débordement ; représentation approchée des réels par des flottants ; conséquences sur la comparaison de flottants. Les entiers de Python sont de taille arbitraire : le complément à deux et le débordement concernent les entiers de taille fixe (processeur, langage C).

Prérequis

Variables, types et affectations (types int et float).
Boucles for et while.
Les puissances de 2 : $2^{0} = 1, 2^{1} = 2, 2^{2} = 4, 2^{3} = 8, \dots$

🎯 Accompagnement Majorant

La représentation des nombres piège tout le monde en début de prépa. Comprendre vraiment pourquoi 0.1+0.2 échoue vous évitera des heures de bugs incompréhensibles ; nos mentors alumni X · Centrale · Mines vous font manipuler ces notions jusqu'au réflexe.

Trouver un mentor →

Les entiers naturels en base 2

En base 10, l'écriture $13$ signifie $1 \times 10 + 3 \times 1$ . En base 2, on n'utilise que les chiffres 0 et 1, et chaque position vaut une puissance de 2. De droite à gauche, les poids sont $\dots, 8, 4, 2, 1$ .

Définition 1.1 — Bit et base 2

Un bit (binary digit) est un chiffre valant 0 ou 1. Un entier naturel écrit en base 2 sous la forme

b_{k} b_{k - 1} \dots b_{1} b_{0}

(avec chaque

b_{i} \in {0, 1}

) représente le nombre

i = 0 \sum k b_{i} 2^{i}

. Le bit

b_{0}

(à droite) est le bit de poids faible, le bit

b_{k}

(à gauche) le bit de poids fort.

Ainsi $110 1_{2} = 1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1 = 13$ .

Convertir un entier décimal en binaire

Méthode par les poids : on parcourt les poids du plus grand au plus petit ; à chaque poids, on regarde s'il « tient » dans ce qu'il reste. Traçons-la sur $13$ .

Conversion de 13 en binaire par soustraction des poids
Poids testé	Poids ≤ reste ?	Bit	Reste après
8	13 ≥ 8 → oui	1	13 − 8 = 5
4	5 ≥ 4 → oui	1	5 − 4 = 1
2	1 ≥ 2 → non	0	1
1	1 ≥ 1 → oui	1	0 → fini, 1101 ✓

En lisant la colonne « Bit » de haut en bas : $13 = 110 1_{2}$ .

📐 Méthode — Décimal vers binaire (poids décroissants)

Lister les poids $1, 2, 4, 8, 16, \dots$ jusqu'au plus grand $\leq$ nombre.
Du plus grand poids au plus petit : si le poids $\leq$ reste, écrire un 1 et soustraire ce poids ; sinon écrire un 0.
Le binaire est la suite des bits, du premier écrit (poids fort) au dernier (poids faible).

En Python : bin() et int()

Python fournit deux outils tout prêts pour passer d'une écriture à l'autre.

print(bin(13))        # decimal -> binaire
print(int("1101", 2)) # binaire (texte) -> decimal
print(bin(6))         # autre exemple

🔍 Décryptage ligne par ligne

bin(13)Renvoie la chaîne '0b1101'. Le préfixe 0b signale « ceci est écrit en base 2 » ; les chiffres utiles sont 1101. C'est bien notre

13

int("1101", 2)L'inverse : on donne une chaîne de bits et la base (2), Python renvoie l'entier décimal 13. Le deuxième argument est indispensable : sans lui, int("1101") lirait treize-cent-un en base 10.

bin(6)Affiche '0b110', car

6 = 4 + 2 = 11 0_{2}

. Remarquez que le bit de poids faible est 0 : 6 est pair.

Sortie exacte de ce programme :

0b1101
13
0b110

📝 Lire la parité sur le dernier bit. Un entier est pair si et seulement si son bit de poids faible (le plus à droite) vaut 0. C'est l'analogue binaire du « se termine par 0, 2, 4, 6, 8 » en base 10.

Les entiers relatifs : le complément à deux

Les bits ne « connaissent » pas le signe moins. Sur une machine à taille fixe (un registre de $n$ bits), on adopte donc une convention : le complément à deux. Elle a un immense avantage : l'addition des négatifs se fait avec le même circuit que celle des positifs.

Définition 2.1 — Complément à deux sur n bits

Sur

n

bits, un entier

x

positif est codé par son écriture binaire habituelle. Un entier négatif

- x

(avec

0 &lt; x \le 2^{n-1}

) est codé par le motif binaire du nombre

2^{n} - x

. Le bit de poids fort joue alors le rôle de bit de signe : 0 pour un nombre

\geq 0

, 1 pour un nombre

&lt; 0

Exemple sur 8 bits : coder $- 5$ . On calcule $2^{8} - 5 = 256 - 5 = 251$ , puis on écrit $251$ en binaire sur 8 bits.

n = 8
x = 5
code = (2**n - x) % (2**n)   # 256 - 5 = 251
print(format(code, "08b"))   # ecrit 251 sur 8 bits

🔍 Décryptage ligne par ligne

n = 8 ; x = 5On travaille sur 8 bits et on veut coder

- 5

, donc

x = 5

(2**n - x) % (2**n)Le cœur du complément à deux :

256 - 5 = 251

. Le % (2**n) ramène le résultat dans

[0, 255]

(utile quand

x = 0

, où l'on veut 0 et non 256).

format(code, "08b")Convertit 251 en binaire sur exactement 8 caractères (le 08 complète avec des zéros à gauche). Résultat : 11111011.

Sortie : 11111011. Le bit de poids fort vaut 1 : c'est bien un nombre négatif. Vérification : $1111101 1_{2} = 251$ , et $251 - 256 = - 5$ .

💡 Les bornes sur $n$ bits. Avec

n

bits en complément à deux, on représente exactement les entiers de l'intervalle

[- 2^{n - 1}, 2^{n - 1} - 1]

. Sur 8 bits :

[- 128, 127]

. Sur 4 bits :

[- 8, 7]

. Un côté a un de plus (il n'y a qu'un seul zéro, du côté positif).

Le débordement (overflow)

Sur taille fixe, dépasser la borne haute fait « repartir » du bas : c'est le débordement. Sur 8 bits, ajouter 1 à $127$ (soit $01111111$ ) donne $10000000$ , qui vaut $- 128$ en complément à deux — un positif est devenu négatif ! C'est un bug classique en langage C.

⚠ En Python, pas de débordement natif. Les entiers Python (int) sont de taille arbitraire : ils grandissent tant qu'il reste de la mémoire. 2**100 se calcule sans problème. Le complément à deux et le débordement décrits ici concernent les entiers de taille fixe du processeur (et des langages comme C, Java). Connaître ces notions reste au programme, car elles expliquent le comportement du matériel.

Les nombres à virgule : les flottants

Pour représenter $3, 14$ ou $0, 1$ , l'ordinateur utilise des flottants (type float), codés selon la norme IEEE 754. Idée (présentation simplifiée) : un flottant s'écrit

$signe \times mantisse \times 2^{exposant}$

un peu comme la notation scientifique $\pm m \times 1 0^{e}$ , mais en base 2. La mantisse a un nombre fini de bits : c'est là que naissent tous les problèmes.

Définition 3.1 — Flottant (présentation simplifiée)

Un flottant est une approximation d'un réel de la forme

\pm m \times 2^{e}

, où la mantisse

m

est codée sur un nombre fixe de bits et l'exposant

e

est un entier. Comme les bits de mantisse sont en nombre fini, seuls certains réels sont représentables exactement ; les autres sont arrondis au flottant le plus proche.

📝 Pourquoi $0, 1$ n'est pas exact. En base 10,

1/3 = 0, 333 \dots

n'a pas d'écriture décimale finie. En base 2, c'est le nombre

0, 1

(un dixième) qui n'a pas d'écriture binaire finie :

0, 1 = 0, 0001100110011 \dots_{2}

, périodique à l'infini. La machine le coupe → elle stocke une valeur très proche mais pas égale.

Le piège central : 0.1 + 0.2

print(0.1 + 0.2)          # la somme affichee
print(0.1 + 0.2 == 0.3)   # le test d'egalite

🔍 Décryptage ligne par ligne

0.1 + 0.20.1 et 0.2 sont déjà stockés arrondis. Leur somme cumule les petites erreurs et donne 0.30000000000000004 — pas tout à fait

0, 3

0.1 + 0.2 == 0.3À gauche, 0.30000000000000004 ; à droite, le flottant stocké pour 0.3, qui est encore une autre approximation. Les deux motifs de bits diffèrent → le test renvoie False.

Sortie exacte :

0.30000000000000004
False

⚠ Ne JAMAIS comparer deux flottants avec ==. Le résultat dépend d'erreurs d'arrondi invisibles. C'est la règle d'or du calcul flottant.

La bonne façon de comparer

On teste si les deux nombres sont suffisamment proches, à une tolérance $ε$ (epsilon) près.

a = 0.1 + 0.2
b = 0.3
epsilon = 1e-9
print(abs(a - b) < epsilon)   # comparaison correcte

🔍 Décryptage ligne par ligne

epsilon = 1e-9Une petite tolérance, ici

1 0^{- 9}

. Deux flottants dont l'écart est inférieur à

ε

sont considérés « égaux ».

abs(a - b) < epsilonabs(a - b) est la distance entre les deux nombres. Si elle est plus petite que

ε

, on renvoie True. Ici l'écart vaut

\approx 5, 5 \times 1 0^{- 17}

, largement sous

1 0^{- 9}

→ True.

Sortie : True. C'est la comparaison qu'il faut écrire systématiquement pour des flottants.

📐 Méthode — Comparer deux flottants a et b

Choisir une tolérance $ε$ adaptée (souvent $1 0^{- 9}$ à $1 0^{- 12}$ ).
Calculer l'écart absolu abs(a - b).
Conclure « égaux » si abs(a - b) < epsilon, jamais avec a == b.

🎯 Accompagnement Majorant

Le réflexe epsilon se travaille sur des TP réels. En colle comme aux concours, savoir quand un flottant trahit fait la différence ; nos mentors alumni X · Centrale · Mines vous entraînent sur les vrais pièges d'énoncés.

Trouver un mentor →

Exercices corrigés

Exo 1Aller-retour décimal / binaireFacile

1) Convertir $22$ en binaire à la main (méthode des poids). 2) Que renvoient bin(22) et int("10110", 2) ?

Voir la correction détaillée

1) Poids décroissants. Poids ≤ 22 : 16.

22 \geq 16

→ bit 1, reste

6

6 \geq 8

? non → 0.

6 \geq 4

→ 1, reste

2

2 \geq 2

→ 1, reste

0

0 \geq 1

? non → 0. On lit

10110

, donc

22 = 1011 0_{2}

. Vérif :

16 + 4 + 2 = 22

. ✓

2) En Python. bin(22) renvoie la chaîne '0b10110' ; int("10110", 2) renvoie l'entier 22. Les deux opérations sont inverses l'une de l'autre.

Exo 2Complément à deux sur 8 bitsIntermédiaire

1) Coder $- 6$ sur 8 bits en complément à deux. 2) Quel entier relatif le motif 11111111 représente-t-il sur 8 bits ? 3) Rappeler l'intervalle représentable sur 8 bits.

Voir la correction détaillée

1) On calcule

2^{8} - 6 = 256 - 6 = 250

, puis

250

en binaire sur 8 bits :

250 = 128 + 64 + 32 + 16 + 8 + 2 = 1111101 0_{2}

. Donc

- 6

est codé 11111010. Le bit de poids fort vaut 1 (négatif). ✓

2) 11111111 vaut

255

en non-signé ; en complément à deux,

255 - 256 = - 1

. C'est le codage de

- 1

(un motif « tout à 1 » vaut toujours

- 1

3) Intervalle :

[- 2^{7}, 2^{7} - 1] = [- 128, 127]

Exo 3Débogage flottantDifficile

Un étudiant écrit une boucle qui doit s'arrêter quand un compteur flottant atteint $1, 0$ :

x = 0.0
while x != 1.0:
    x = x + 0.1
    print(x)

1) Pourquoi cette boucle risque-t-elle de ne jamais s'arrêter ? 2) Corriger le code proprement.

Voir la correction détaillée

1) 0.1 n'est pas représentable exactement. En l'additionnant 10 fois, on obtient une valeur très proche de

1, 0

mais différente (

0, 9999 \dots

1, 0000 \dots 04

). Le test x != 1.0 reste alors toujours vrai → boucle infinie. On ne compare jamais des flottants avec == ou !=.

2a) Solution robuste — compter en entiers.

for i in range(10):
    x = (i + 1) * 0.1
    print(x)

On pilote la boucle avec un entier i (exact) et on calcule x à part. Le nombre d'itérations est garanti.

2b) Variante avec tolérance si l'on doit vraiment tester une valeur : remplacer x != 1.0 par abs(x - 1.0) >= 1e-9 comme condition de continuation.

Récap final — Ce qu'il faut absolument retenir

Coche mentalement chaque point : si tu bloques, retourne à la section correspondante avant le quiz.

Sais-tu convertir un entier décimal en binaire par la méthode des poids ( $\dots 8, 4, 2, 1$ ) et l'inverse ?
Sais-tu que bin(n) renvoie une chaîne '0b...' et que int("...", 2) fait l'inverse ?
Sais-tu reconnaître un nombre pair sur son bit de poids faible (dernier bit = 0) ?
Sais-tu coder un négatif en complément à deux sur $n$ bits via $2^{n} - x$ , et lire le signe sur le bit de poids fort ?
Connais-tu l'intervalle représentable sur $n$ bits : $[- 2^{n - 1}, 2^{n - 1} - 1]$ (donc $[- 128, 127]$ sur 8 bits) ?
Sais-tu ce qu'est le débordement, et qu'en Python les entiers sont de taille arbitraire (pas de débordement natif) ?
Sais-tu expliquer pourquoi 0.1 + 0.2 == 0.3 renvoie False ?
As-tu le réflexe de comparer deux flottants par abs(a - b) < epsilon et jamais par == ?

Vue d'ensemble

Prérequis

Les entiers naturels en base 2

Convertir un entier décimal en binaire

En Python : bin() et int()

Les entiers relatifs : le complément à deux

Le débordement (overflow)

Les nombres à virgule : les flottants

Le piège central : 0.1 + 0.2

La bonne façon de comparer

Exercices corrigés

Récap final — Ce qu'il faut absolument retenir

Débloque la fiche complète

Quiz — Représentation des nombres

Fiches associées

Recherche par dichotomie

Variables, types et affectations

Conditions et booléens

Boucles for et while

Fonctions : paramètres et valeurs de retour

Listes et chaînes de caractères

Tu veux aller plus loin sur ce chapitre ?