Représentation binaire des données : entiers, flottants, textes, booléens

Bit, octet, bases 2 et 16, les deux méthodes de conversion et laquelle utiliser. Entiers non signés, complément à deux, opérations bit à bit et débordement. Flottants IEEE 754 et pourquoi 0.1 + 0.2 ≠ 0.3. ASCII, Unicode et UTF-8, booléens et lois de De Morgan. Les cinq erreurs qui coûtent le plus, et ce qu'il faut savoir refaire en cinq minutes.

NSI · prérequis de première · fiche gratuite · 29 min de lecture

Une suite de bits ne « contient » pas un nombre : elle ne veut rien dire tant qu'on n'a pas dit comment la lire. Les deux autres chapitres de NSI en accès libre — fiche + QCM corrigé, sans compte, sans email : Réussir les deux épreuves de NSI et Recherche, tris et coût d'un algorithme. Ou reçois l'accès à tes chapitres gratuits par email.

Les notions à maîtriser

Bit : la plus petite information possible, 0 ou 1. Tout ce qui suit n'est qu'une convention d'interprétation d'une suite de bits. Une suite de bits ne « contient » pas un nombre : elle ne veut rien dire tant qu'on n'a pas dit comment la lire. C'est la phrase la plus rentable du chapitre.

Octet (byte) : 8 bits. 256 combinaisons possibles. Ne pas confondre avec le bit dans les débits réseau (Mb/s = mégabits, Mo/s = mégaoctets, rapport 8).

Base : le nombre de chiffres distincts d'un système de numération. Base 10 (0-9), base 2 (0-1), base 16 ou hexadécimal (0-9 puis A-F). L'hexadécimal n'apporte rien de nouveau : c'est du binaire écrit en plus court, un chiffre hexadécimal = exactement 4 bits.

Poids d'un bit : dans l'écriture binaire, le bit de rang i (à partir de la droite, rang 0) vaut 2^i. Le bit le plus à gauche est le bit de poids fort, celui de droite le bit de poids faible.

Entier non signé : tous les bits codent la valeur. Sur n bits, on représente les entiers de 0 à 2^n − 1.

Complément à deux : la convention universelle pour coder les entiers relatifs. Sur n bits, on représente −2^(n−1) à 2^(n−1) − 1. Le bit de poids fort vaut 1 pour un nombre négatif — c'est un indice, pas un « bit de signe » indépendant.

Débordement (overflow) : le résultat d'une opération ne tient plus dans le nombre de bits alloué. Le calcul ne s'arrête pas : il rend un résultat faux et silencieux.

Norme IEEE 754 : la convention de codage des nombres à virgule (flottants), en trois champs — signe, exposant, mantisse. Conséquence à connaître par cœur : la plupart des décimaux n'ont pas d'écriture binaire finie, donc sont stockés approchés.

ASCII : 128 caractères codés sur 7 bits (l'alphabet anglais, les chiffres, la ponctuation). Aucun caractère accentué.

Unicode : une table qui associe à chaque caractère du monde un numéro appelé point de code (noté U+xxxx). Unicode n'est pas un codage : il dit quel numéro, pas comment l'écrire en octets.

UTF-8 : le codage le plus répandu des points de code Unicode. Longueur variable : 1 octet pour l'ASCII, 2 pour les lettres accentuées et le grec, 3 pour la plupart des idéogrammes, 4 pour les émojis. Il est rétro-compatible avec ASCII, ce qui explique sa domination.

Booléen : une valeur de vérité, True ou False. Les opérateurs and, or, not se décrivent entièrement par des tables de vérité.

Pourquoi ce chapitre de première est indispensable en terminale

C'est un chapitre du programme de première, et aucun sujet de terminale ne porte directement dessus. Il est pourtant celui qu'on mobilise le plus souvent sans le nommer, et l'écart se voit immédiatement à la correction :

• Réseaux et sécurisation : une adresse IPv4 est un entier de 32 bits, un masque de sous-réseau se lit en binaire, et le calcul d'une adresse de réseau est un ET bit à bit. Sans le binaire, l'exercice n'a littéralement pas d'énoncé.
• Architecture, système et processus : la taille d'un mot machine (32 ou 64 bits), les portes logiques, les registres, l'arithmétique de l'unité de calcul — tout est ici.
• Recherche, tris et coût d'un algorithme : la complexité en O(log n) d'une dichotomie, c'est log en base 2, parce qu'on divise par deux à chaque étape. Savoir que 2^10 ≈ 1000 rend les ordres de grandeur immédiats.
• Arbres binaires : un arbre de hauteur h contient au plus 2^(h+1) − 1 nœuds. Même puissance de deux, même raisonnement.
• Programmation objet, tests et mise au point : l'erreur d'arrondi des flottants est la cause n°1 des tests qui échouent sans raison apparente. On ne teste jamais deux flottants avec ==.
• Bases de données : le choix d'un type de colonne (entier, réel, texte) est un choix de représentation, avec les mêmes limites.

Autrement dit : ce chapitre ne rapporte pas de points tout seul, il en fait gagner dans cinq autres.

1. Compter en base 2 et en base 16

En base 10, 1907 se lit 1×10³ + 9×10² + 0×10¹ + 7×10⁰. En base 2, le mécanisme est identique avec des puissances de 2 :

1011 0110 = 1×128 + 0×64 + 1×32 + 1×16 + 0×8 + 1×4 + 1×2 + 0×1 = 182.

La table à connaître sans réfléchir, c'est celle des puissances de 2 :

Pourquoi grouper les bits par quatre. Un chiffre hexadécimal code exactement 4 bits, donc la conversion binaire ↔ hexadécimal se fait par paquets de 4, sans aucun calcul :

1011 0110 → B 6 → 0xB6. Et réciproquement : 0x2F → 0010 1111 → 47.

C'est pour cela que l'hexadécimal est partout : couleurs web (#FF8800), adresses mémoire, adresses MAC, IPv6. Il n'y a rien à comprendre de plus qu'en binaire, il y a juste quatre fois moins à écrire.

2. Les deux méthodes de conversion, et laquelle utiliser

Décimal → binaire, méthode des divisions successives. On divise par 2, on note le reste, on recommence avec le quotient ; on lit les restes de bas en haut.

Exemple avec 45 : 45 = 2×22 + 1 ; 22 = 2×11 + 0 ; 11 = 2×5 + 1 ; 5 = 2×2 + 1 ; 2 = 2×1 + 0 ; 1 = 2×0 + 1. Lecture de bas en haut : 101101. Vérification : 32 + 8 + 4 + 1 = 45. ✔

Décimal → binaire, méthode des puissances décroissantes. On prend la plus grande puissance de 2 inférieure au nombre et on soustrait. Pour 45 : 32 tient (reste 13), 16 ne tient pas (0), 8 tient (reste 5), 4 tient (reste 1), 2 ne tient pas (0), 1 tient. → 101101.

La seconde est plus rapide à l'oral et au brouillon ; la première ne se trompe jamais. Dans les deux cas, on vérifie en reconvertissant : c'est dix secondes, et cela transforme une réponse plausible en réponse sûre.

3. Entiers non signés : ce que « n bits » autorise

Sur n bits : 2^n valeurs distinctes, de 0 à 2^n − 1.

La question réciproque tombe tout aussi souvent : combien de bits pour coder N valeurs ? Il faut le plus petit n tel que 2^n ≥ N. Pour 1000 valeurs : 2⁹ = 512 < 1000 ≤ 1024 = 2¹⁰, donc 10 bits. Le réflexe consiste à monter la table des puissances, pas à sortir un logarithme.

Attention au décalage classique : 8 bits donnent 256 valeurs mais la plus grande vaut 255, pas 256. L'erreur « 2^n » au lieu de « 2^n − 1 » coûte un point à chaque fois.

4. Entiers relatifs : le complément à deux

On pourrait réserver un bit au signe (« signe et valeur absolue »), mais cette convention a deux défauts rédhibitoires : elle crée deux zéros (+0 et −0) et elle oblige le processeur à traiter la soustraction à part. Le complément à deux règle les deux : l'addition ordinaire, sans aucun cas particulier, donne le bon résultat pour les positifs comme pour les négatifs.

Méthode pour coder un nombre négatif sur 8 bits — trois gestes, dans cet ordre :

1. écrire la valeur absolue en binaire : 5 → 0000 0101 ;
2. inverser tous les bits : 1111 1010 ;
3. ajouter 1 : 1111 1011 = 0xFB. C'est −5.

Vérification par l'addition : 0000 0101 (+5) + 1111 1011 (−5) = 1 0000 0000. Le neuvième bit déborde et est abandonné, il reste 0000 0000 = 0. ✔

Pour décoder une suite de bits présentée comme un entier signé : si le bit de poids fort est 0, c'est un positif, on lit normalement. S'il vaut 1, on applique la même recette (inverser, +1) pour obtenir la valeur absolue, et on met un signe moins.

La plage est asymétrique : sur n bits, de −2^(n−1) à 2^(n−1) − 1. Sur 8 bits : −128 à +127. Il y a un négatif de plus que de positifs, parce que le zéro occupe une place du côté positif.

5. Opérations bit à bit et débordement

Les opérateurs sur les bits sont au programme et reviennent en terminale :

n << 3 vaut donc n * 8, et n >> 1 vaut n // 2. C'est exactement le geste qu'on fait dans une dichotomie ou dans un parcours d'arbre.

Le masque, mené jusqu'au bout : l'adresse de réseau d'une machine. C'est l'usage de & qui tombe en terminale, et il ne se comprend qu'en binaire. Énoncé type : une machine porte l'adresse 192.168.10.137 avec le masque 255.255.255.192, noté /26. Donner l'adresse de son réseau.

On pose les deux nombres octet par octet, et on applique & bit à bit :

Adresse de réseau : 192.168.10.128. Seul le dernier octet demande un vrai calcul : 137 & 192 = 10001001 & 11000000 = 10000000 = 128. Les trois premiers sont inchangés parce qu'un octet de masque à 255 (11111111) laisse tout passer. D'où la règle générale, qui est toute la notion de masque : là où le masque vaut 1, le bit est conservé ; là où il vaut 0, le bit est écrasé à 0.

Ce que « /26 » veut dire. Les 26 premiers bits du masque sont à 1, donc les 32 − 26 = 6 derniers sont à 0. Ces 6 bits libres donnent 2⁶ = 64 adresses dans ce réseau, dont deux ne sont pas attribuables (l'adresse de réseau .128 et l'adresse de diffusion .191) : il reste 62 machines, de 192.168.10.129 à 192.168.10.190.

L'adresse de diffusion se calcule par le raisonnement inverse — on remet à 1 tous les bits d'hôte, avec un OU : 128 | 63 = 10000000 | 00111111 = 10111111 = 191, soit 192.168.10.191.

La question qui suit presque toujours : ces machines sont-elles sur le même réseau ? On applique le même masque aux deux adresses et on compare les deux résultats.

• 192.168.10.190 & 255.255.255.192 → 192.168.10.128 : même réseau que la machine de départ.
• 192.168.10.200 & 255.255.255.192 → 192.168.10.192 : réseau différent, alors que les deux adresses ne diffèrent que de 10.

Le contre-exemple qui interdit de deviner. Avec un masque /24 (255.255.255.0), cette même machine 192.168.10.137 appartiendrait au réseau 192.168.10.0, et non plus à 192.168.10.128. C'est le masque, pas l'adresse, qui décide du découpage : l'écriture décimale ne permet aucune lecture à vue, il faut poser les bits.

En Python, le calcul tient en une ligne :

ip     = [192, 168, 10, 137]
masque = [255, 255, 255, 192]
reseau = [a & m for a, m in zip(ip, masque)]
print(reseau)   # [192, 168, 10, 128]

Le débordement est le piège de fond de ce chapitre. Sur 8 bits non signés, 255 + 1 donne 1 0000 0000 : le neuvième bit n'existe pas, le résultat stocké est 0. Rien n'a planté, rien n'a prévenu. Python, lui, gère des entiers de taille arbitraire et ne déborde jamais — ce confort est une exception, pas la règle : en C, en Java, dans un microcontrôleur ou dans une base de données, la limite existe.

6. Flottants : pourquoi 0.1 + 0.2 ≠ 0.3

Un flottant IEEE 754 s'écrit signe × mantisse × 2^exposant. Sur 64 bits (double précision) : 1 bit de signe, 11 d'exposant, 52 de mantisse.

Le point décisif : 0,1 n'a pas d'écriture binaire finie, pas plus que 1/3 n'a d'écriture décimale finie. Il est donc stocké approché. En Python :

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

Ce n'est pas un bug de Python : c'est le comportement de tout langage utilisant IEEE 754, et l'affirmation « c'est une erreur de l'interpréteur » est fausse.

La conséquence pratique, à appliquer systématiquement en terminale : on ne compare jamais deux flottants avec ==. On compare l'écart à une tolérance :

def presque_egal(x, y, eps=1e-9):
    return abs(x - y) < eps

Deuxième conséquence : les erreurs s'accumulent. Additionner 0,1 dix mille fois ne donne pas 1000. Pour des montants monétaires, on travaille en centimes entiers, pas en euros flottants — c'est la réponse attendue quand un sujet parle de comptabilité.

7. Textes : ASCII, Unicode, UTF-8

ASCII (1963) code 128 caractères sur 7 bits. A vaut 65, a vaut 97, 0 vaut 48. Les deux écarts utiles à retenir : a − A = 32 et '7' − '0' = 7, ce qui permet de convertir un chiffre-caractère en entier sans table.

ASCII ne contient aucun caractère accentué : impossible d'écrire « é » ou « ç ». D'où les jeux régionaux sur 8 bits (Latin-1), incompatibles entre eux — puis Unicode.

Unicode attribue un point de code à chaque caractère : A = U+0041, é = U+00E9, € = U+20AC, 😀 = U+1F600. Unicode ne dit pas comment stocker ces numéros : c'est le rôle d'un codage.

UTF-8 est un codage à longueur variable :

Deux conséquences qui tombent en exercice : le nombre de caractères d'une chaîne n'est pas le nombre d'octets de son fichier, et un texte ASCII pur est un fichier UTF-8 valide et identique octet pour octet (rétro-compatibilité). Les fameux « é » à l'écran sont un texte UTF-8 relu à tort comme du Latin-1 : un problème d'interprétation, jamais de contenu.

En Python : ord('é') → 233, chr(233) → 'é', et 'é'.encode('utf-8') → b'\xc3\xa9', deux octets.

8. Booléens et lois de De Morgan

Les lois de De Morgan servent à simplifier une condition, et une question de bac les demande sous la forme « écrire la négation de… » :

• not (a and b) ≡ (not a) or (not b)
• not (a or b) ≡ (not a) and (not b)

La négation échange and et or et nie chaque terme. L'erreur classique consiste à nier les termes en gardant le connecteur.

Sur une condition réelle — et c'est sous cette forme que la question tombe. Soit le test if age >= 18 and pays == "France":. Sa négation s'écrit :

not (age >= 18 and pays == "France") ≡ age < 18 or pays != "France"

Deux gestes, dans cet ordre : and devient or, puis chaque comparaison est niée (>= devient <, == devient !=). La réponse fausse la plus fréquente, age < 18 and pays != "France", décrit les personnes qui cumulent les deux manques, alors que la négation doit être vraie dès qu'une seule des deux conditions tombe.

Vérification exhaustive sur les quatre cas possibles :

La cinquième colonne reproduit exactement la quatrième : la négation est juste. ✔ La sixième en diffère sur deux lignes sur quatre : le piège est bien faux.

Deux compléments utiles : l'évaluation paresseuse (dans a and b, b n'est pas évalué si a est faux — d'où le fait que i < len(t) and t[i] == x ne lève jamais d'erreur d'indice) et le fait qu'en Python 0, "", [] et None sont équivalents à False dans un test.

9. Les cinq erreurs qui coûtent le plus

1. Écrire 2^n au lieu de 2^n − 1 pour la valeur maximale non signée.
2. Oublier le « +1 » dans le complément à deux : on obtient le complément à un, décalé de 1.
3. Lire une suite de bits sans savoir la convention. 1111 1011 vaut 251 en non signé et −5 en signé. La question « signé ou non ? » précède toute réponse.
4. Comparer des flottants avec ==.
5. Confondre Unicode et UTF-8 : l'un numérote, l'autre écrit en octets.

10. Ce qu'il faut savoir refaire en cinq minutes

• Convertir un octet dans les deux sens entre binaire, décimal et hexadécimal, et vérifier en reconvertissant.
• Donner la plage d'entiers représentables sur n bits, signés et non signés.
• Coder un entier négatif en complément à deux sur 8 bits, en trois gestes.
• Dire combien de bits sont nécessaires pour coder N valeurs distinctes.
• Expliquer en deux phrases pourquoi 0.1 + 0.2 != 0.3, et donner le test correct.
• Calculer l'adresse de réseau d'une machine par un ET bit à bit avec son masque, et dire si deux adresses sont sur le même réseau.
• Écrire la négation d'une condition composée avec De Morgan, et la vérifier par table de vérité.

Réserve de source, assumée : cette fiche suit le programme officiel de NSI de première (représentation des données : types et valeurs de base) tel qu'il est stabilisé depuis 2019. Le texte du BO n'a pas pu être relu à la source lors de la rédaction — education.gouv.fr répond 403 depuis ce conteneur. Aucun point ci-dessus n'est marginal ou disputé, mais la vérification à la source reste à faire.

Avant l'épreuve : Méthode des épreuves de spécialité NSI — l'écrit, l'heure sur machine et la banque de sujets, en détail.