NSI (Spé) — Représentation des données
Types et valeurs de base
Entiers, flottants, booléens : représentation binaire et limites
Résumé synthétiqueFiche en 4 sectionsQuiz de 10 questionsGratuit, sans pub
Résumé
Dans une machine, tout est binaire : des suites de 0 et de 1 appelés bits. Un entier naturel se convertit en base 2 par divisions successives par 2 ($13$ s'écrit 1101 en binaire). Pour coder les négatifs, on utilise le complément à deux, qui rend l'addition uniforme entre positifs et négatifs. Les flottants (nombres à virgule) suivent la norme IEEE 754 et ne sont que des approximations : en Python, $0{,}1 + 0{,}2$ ne donne pas exactement $0{,}3$. Les booléens ne valent que True ou False et fondent toute la logique avec ET, OU, NON. Retiens le réflexe central : sur $n$ bits on code $2^n$ valeurs distinctes, soit $0$ à $2^n - 1$ en non signé.
Un ordinateur ne connaît que deux états : 0 et 1. Pour représenter un nombre, on l'écrit en base 2 au lieu de la base 10. Chaque position vaut une puissance de 2 : de droite à gauche, $2^0, 2^1, 2^2, \dots$ Savoir convertir dans les deux sens est la première compétence du chapitre.
- Bit et octet : un bit vaut 0 ou 1 ; un octet = 8 bits et code $2^8 = 256$ valeurs (de 0 à 255).
- Décimal vers binaire : diviser par 2 en boucle et lire les restes de bas en haut. Ex : 13 donne 1101.
- Binaire vers décimal : additionner les puissances de 2 des bits à 1. Ex : 1101 = $8+4+0+1 = 13$.
- Capacité : sur $n$ bits, on code les entiers de $0$ à $2^n - 1$ (8 bits donnent 0 à 255).
- Hexadécimal (base 16) : un raccourci où chaque chiffre vaut 4 bits. Ex : 0xFF = 1111 1111 = 255.
Exemple
Convertissons 13. Divisions par 2 : $13 = 6\times2 + 1$, $6 = 3\times2 + 0$, $3 = 1\times2 + 1$, $1 = 0\times2 + 1$. Restes lus de bas en haut : 1101. Vérification : $1101_2 = 8 + 4 + 0 + 1 = 13$.
Piège à éviter
Le bit de poids fort est celui de gauche : dans 1101 il vaut $2^3 = 8$, pas 1. Si on lit les restes des divisions dans le mauvais sens, on obtient le nombre à l'envers.
Pour stocker des entiers relatifs sur un nombre fixe de bits, on ne peut pas juste ajouter un signe « − ». La technique retenue est le complément à deux : elle réserve le bit de poids fort au signe et permet d'additionner positifs et négatifs avec le même circuit.
- Plage : sur $n$ bits, on code de $-2^{\,n-1}$ à $2^{\,n-1} - 1$. Sur 8 bits : de $-128$ à $+127$.
- Bit de signe : le bit de poids fort vaut 0 pour un positif, 1 pour un négatif.
- Opposé d'un nombre : inverser tous les bits, puis ajouter 1. Ex : 5 = 00000101 donne $-5$ = 11111011.
- Avantage : l'addition fonctionne à l'identique pour les positifs et les négatifs, sans cas particulier.
- Asymétrie : il y a un négatif de plus que de positifs ($-128$ existe, mais pas $+128$ sur 8 bits).
Exemple
Codons $-5$ sur 8 bits : $5 = 00000101$, on inverse $\to 11111010$, on ajoute 1 $\to 11111011$. Contrôle : $00000101 + 11111011 = 1\,00000000$, soit 0 sur 8 bits une fois la retenue débordée.
Piège à éviter
Le dépassement de capacité (overflow) est sournois : sur 8 bits signés, $127 + 1$ ne donne pas 128 (hors plage) mais $-128$. Vérifie toujours que le résultat tient dans $-2^{\,n-1}$ à $2^{\,n-1}-1$.
Les nombres à virgule sont stockés selon la norme IEEE 754, sous la forme signe × mantisse × $2^{\text{exposant}}$. Comme la mémoire est finie, la plupart des décimaux n'ont pas de représentation binaire exacte : un flottant est presque toujours une approximation.
- Trois parties : un bit de signe, un exposant et une mantisse.
- Précisions : simple sur 32 bits (1 + 8 + 23), double sur 64 bits (1 + 11 + 52).
- Approximation : en Python, 0.1 + 0.2 vaut 0.30000000000000004, pas exactement 0.3.
- Exactitude partielle : $0{,}5$ et $0{,}25$ sont exacts (puissances de 2), mais pas $0{,}1$ ni $0{,}3$.
Exemple
Pour tester si deux flottants sont égaux, on compare leur écart à un petit seuil : abs((0.1 + 0.2) - 0.3) < 1e-9 renvoie True, alors que (0.1 + 0.2) == 0.3 renvoie False.
Piège à éviter
Ne compare jamais deux flottants avec == : l'arrondi binaire fausse le test. Utilise toujours abs(a - b) < epsilon avec un petit epsilon.
Un booléen ne prend que deux valeurs, True (vrai) ou False (faux). C'est la brique de toute décision en informatique : conditions, tests, circuits logiques. Trois opérateurs suffisent à tout construire : ET, OU et NON.
A ET B n'est vrai que si A et B le sont ; A OU B est vrai dès qu'au moins un des deux l'est.
- Deux valeurs : True (associé à 1) et False (associé à 0).
- ET (and) : vrai seulement si les deux opérandes sont vrais.
- OU (or) : vrai dès qu'au moins un opérande est vrai (ce ou n'est pas exclusif).
- NON (not) : inverse la valeur : not True vaut False.
- Lois de De Morgan : not(A and B) = (not A) or (not B) ; not(A or B) = (not A) and (not B).
Exemple
if (age >= 18) and (pays == 'France'): n'est exécuté que si les deux conditions sont vraies. En Python : True and False donne False, True or False donne True, not True donne False.
Piège à éviter
Le OU logique n'est pas exclusif : True or True vaut bien True, pas False. Et ne confonds pas l'égalité == avec l'affectation = dans une condition.
Quiz - Types et valeurs de base
10 questions
S'entraîner
Articles utiles
Questions fréquentes
Les points clés à retenir sur Types et valeurs de base, extraits du quiz de révision.
Quelle est la valeur décimale du nombre binaire $1010_2$ ?
Réponse :
10
$1010_2 = 1\times8 + 0\times4 + 1\times2 + 0\times1 = 8 + 2 = 10$. On additionne les puissances de 2 des bits à 1.
Combien de valeurs différentes peut-on représenter sur 8 bits ?
Réponse :
256
Sur $n$ bits on code $2^n$ valeurs. Sur 8 bits : $2^8 = 256$ valeurs (de 0 à 255 en non signé).
En complément à deux sur 8 bits, quelle est la plage de valeurs représentables ?
Réponse :
-128 à 127
Sur 8 bits en complément à deux : de $-2^7 = -128$ à $2^7 - 1 = 127$. Il y a un négatif de plus que de positifs.
Pourquoi 0.1 + 0.2 ne donne pas exactement 0.3 en Python ?
Réponse :
Les flottants sont des approximations en binaire
Les flottants (IEEE 754) sont stockés en binaire et $0{,}1$ n'a pas de représentation binaire exacte : il en résulte une petite erreur d'arrondi.