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**.
- **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
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.