Cours Encodages NSI

Dans l’ordinateur, toutes les informations (données ou programmes) sont représentées à l’aide
de deux chiffres 0 et 1, appelés chiffres binaires, ou binary digits ou plus simplement bits.
Dans la mémoire de l’ordinateur, ces chiffres sont regroupés par paquets de 8 appelés octets
(bytes en anglais) puis organisés en mots machine de 2, 4 ou 8 octets (words en anglais). Par
exemple, une machine dite 64bits est une machine qui manipule directement des mots de 8
octets ( 8×8 bits=64 bits ) lorsqu’elle effectue des opérations en mémoire.
Ce regroupement des bits en octets ou mots machine permet de représenter et manipuler
d’autres données que des 0 ou des 1, comme par exemple des entiers, des approximations de
réels, des caractères alpha-numériques ou des textes. Pour cela, il est nécessaire d’inventer des
encodages, c’est-à-dire des manières de représenter l’information.

I – Entiers naturels ( ℕ )

On appelle binaire pur le codage dans lequel sont écrit les entiers naturels
Il s’agit simplement de stocker le code binaire dans un nombre donné d’octets.

1.1 Addition
La règle d’or pour additionner en binaire est de retenir que 1 + 1 = 10, ce qui génère une
retenue dans les additions posées :
010 1011
+ 000 1010

1.2 Bases 2, 10 et 16 en Python

Par défaut en Python, les nombres entiers sont en base 10.
Pour manipuler des séquences de bits, on utilise la notation 0b…
où il suffit de remplacer les points par des 0 et des 1.
Inversement, on peut convertir un nombre vers la base 2 à l’aide de la fonction bin
→ Cette fonction renvoie une chaine de caractère

Pour les nombres hexadécimaux, on utilise la notation 0x…

où les points désignent des chiffres de la base 16 (de 0 à F)

La fonction hex permet de convertir un entier vers la base 16

En Python, les entiers sont illimités : on pourra donc écrire n’importe quelle séquence de
chiffres, Python adaptera la taille mémoire nécessaire.

1
Cours Encodages NSI
1.3 Boutisme
La représentation en machine des entiers naturels sur des mots de 2, 4 ou 8 octets se heurte au
problème de l’ordre dans lequel ces octets sont organisés en mémoire. Ce problème est appelé
boutisme, et il existe deux types d’organisation mémoire que nous illustrerons avec le mot de 4
octets 4CB6072F :
• le gros-boutisme (big endian) qui consiste à placer l’octet de poids fort en premier, c’est-à-
dire à l’adresse mémoire la plus petite.

• le petit-boutisme (little endian) qui consiste à placer l’octet de poids faible en premier.

Cette représentation petit ou gros boutiste est en principe transparente à l’utilisateur puisque gérée
par le système d’exploitation (operating system ou OS). Elle prend de l’importance quand on
accède aux octets soit en mémoire, soit lors d’échanges sur un réseau.
Les deux modes de représentation sont très répandus et leurs avantages et inconvénients sont
multiples. Par exemple, la lisibilité pour un humain est meilleure en gros-boutiste tandis que les
opérations arithmétiques se font plus facilement en petit-boutiste.
Anecdote
Le terme Big-Endians et Little-Endians provient du conte « Les voyages de Gulliver » de
Jonathan Swift, dans lequel de nombreux habitants de Lilliput refusent d’obéir à un décret
obligeant à manger les œufs à la coque par le petit bout. La répression pousse les rebelles, dont
la cause est appelée Big-Endian, à se réfugier dans l’empire rival de Blefuscu, ce qui
provoquera une guerre longue et meurtrière entre les deux empires.
A la fin des années 70, la « guerre sur l’ordre des octets » entre les partisans des deux camps est
à son apogée au moment de la construction des protocoles réseau qui donneront naissance à
l’internet. En 1980, Dany Cohen publie sur le site de l’Internet Engineering Task Force
(https://www.ietf.org/rfc/ien/ien137.txt) une note très ironique « On Holy Wars and a plea for
peace » dans lequel il nomme chaque partie les Big-Endians et les Little-Endians en référence
au roman, soulignant qu’avoir raison importe peu à présent, mais il faut faire un choix unique
pour les protocoles réseau.
Les noms de Big-Endian et Little-Endian deviennent ainsi les noms officiels des deux parties,
et on finira par s’accorder sur le fait que l’ordre des octets lors des échanges réseau est
Big-Endian.

II - Entiers relatifs ( ℤ )
On appelle binaire signé le codage dans lequel sont écrit les entiers relatifs
Les nombres signés utilisent le bit de poids fort (ou MSB pour Most Significant Bit) comme bit
de signe. Et utilisent le postulat suivant :
- si le bit de poids fort est égal à 0 alors le nombre est positif ou nul
- si le bit de poids fort est égal à 1 alors le nombre est négatif.

2
Cours Encodages NSI
Exemple : calculons l’opération 10 + (-10) en binaire signé
10 ⟶0000 1010
-10 ⟶1000 1010

⟶
Conclusions :
1. Le binaire signé ne permet pas de faire directement des additions.
2. De plus, ce codage produit deux valeurs pour 0 → 0000 0000 et -0 → 1000 0000

2.1 Méthode du complément à 2

calcul du complément en décimal :

Le complément à 1000 de 239 est 760 + 1 = 761 (on met tous les rangs à 9 et on ajoute 1)
calcul du complément en binaire :
Le complément à 1000 de 011 est 100 + 1 = 101 (on met tous les rangs à 1 et on ajoute 1)
Principe
Représentation sur 1 octet :
- quand un nombre est positif ou nul, alors il représenté comme d’habitude avec un bit de poids
fort à 0.
- quand un nombre est négatif, il est représenté par le complément à 2 de sa valeur absolue :
Pour stocker −1010
◦ on écrit 1010 en binaire (ici sur 1 octet) → 0000 1010
◦ on prend le complément à 1 00000000 ² , c’est-à-dire :
▪ on remplace les 1 par des 0 et les 0 par des 1 → 1111 0101
▪ et on ajoute 1 au résultat : 1111 0101 + 1 → 1111 0110

Si on pose à nouveau l’opération 10 + (-10) avec le nouvel encodage, on obtient :1 1 1

0000 1010
+ 1111 0110
0 0 0 0 0 0 0 0 ⟶ Résultat exact cette fois-ci !!
Remarque : - Les 2 nombres doivent être codés sur le même nombre d’octets.
- On ignore toujours la retenue sur le bit de signe dans l’addition.
- Si on applique deux fois le complément à deux à une écriture binaire, on retrouve
le nombre initial.
Lecture d’un négatif
Les nombres négatifs ne sont pas directement lisibles. Pour les lire, il faut :
• Appliquer la technique du complément à deux
• Lire l’opposé ainsi obtenu
• En déduire le nombre négatif

Exemple : donner l’écriture décimale de l’entier signé 1 0 0 1 1 1 1 1

3
Cours Encodages NSI
2.2 Applications
- Déterminer l’écriture de -1, -127 et -128 puis compléter le tableau ci- Complément à 2
contre.
0111 1111 + 127

0000 0000 + 0 !!
-1
-2

- Pourquoi la valeur minimale est-elle de - 128 ?

-127
-128

2.3 Une autre approche

En observant l’écriture de -10 en complément à 2 1111 0110, on constate que l’on peut la lire
directement, à condition de considérer le bit de poids fort comme négatif :
-128 64 32 16 8 4 2 1
-2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰
1 1 1 1 0 1 1 0
En effet, -2⁷ + 2⁶ + 2⁵ + 2⁴ + 2² + 2¹ = -10

2.4 En python

Quand on souhaite qu’une variable soit entière on utilise la fonction int()

>>> int(3/2)
Ici, la console affiche la conversion entière du quotient de la division de 3 par 2, à savoir …..
La fonction type() donne le type dans lequel est encodé une variable. Si on tape :
>>> a = -3
>>> type(a)
on obtient :
<class ‘int’>

4
Cours Encodages NSI
III – Nombres flottants
Après les entiers relatifs, nous allons voir comment on représente une approximation des nombres
réels en machine, appelée nombres flottants.
3.1 Rappels
x
Un nombre décimal est un nombre s’écrivant sous forme de fraction décimale, c’est-à-dire n
10
où x est un entier relatifs (et n un entier naturel).
13
Exemple : =
4
Certains nombres réels ne sont pas décimaux, ils ont une forme décimale « approchée » :
1 333 314
≈ π≈
3 10³ 10²
3.2 Nombres dyadiques

Par analogie avec les nombres décimaux, on appelle nombres dyadiques les nombres qui
x
s’écrivent sous la forme n
où x ∈ℤ et n∈ℕ
2
13
Exemple : =
4
x
Pour obtenir le développement dyadique d’un nombre dyadique n
, on prend le binaire
2
correspondant à x et on insère une virgule avant le n-ième bit en partant de la fin.
10 2
Exemple : 13 =1101
13 2
Le développement dyadique de 2
est donc 11,01
2
13 1 0 −1 −2
Cela signifie que =1×2 +1×2 +0×2 +1×2
4
Il existe des nombres décimaux qui ne sont pas dyadiques et n’admettent donc pas de
développement dyadique fini.
10 2
Exemple : 0,1 =0,00011001100110011001100110011. ..

Par conséquent, leur représentation en machine sera nécessairement tronquée, et cela engendrera
des erreurs dans les opérations.
En python :

5
Cours Encodages NSI

3.3 Méthode « algorithmique »

Explication par l’exemple : Représentons 5,1875 en binaire

On sait représenter 5 →

Comment représenter le ",1875" ?

• on multiplie 0,1875 par 2 : 0,1875 x 2 = 0,375. On obtient 0,375 que l'on écrira 0 + 0,375
• on multiplie 0,375 par 2 : 0,375 x 2 = 0,75. On obtient 0,75 que l'on écrira 0 + 0,75
• on multiplie 0,75 par 2 : 0,75 x 2 = 1,5. On obtient 1,5 que l'on écrira 1 + 0,5
• on multiplie 0,5 par 2 : 0,5 x 2 = 1,0. On obtient 1,0 que l'on écrira 1 + 0,0
La partie décimale est à 0 on arrête le processus
• On reprend la liste des parties entières dans l’ordre d’obtention → 0011

Donc 5,1875 sera représenté par 100,0011 en binaire.

Exercice : 1/ Trouvez la représentation binaire du décimal 4,125

6
Cours Encodages NSI
3.4 binaire vers décimal
Comme toujours pour la conversion en décimal, on calcule les puissance de 2
Exemple : Donner la valeur décimale de 100,0101
Pour la partie entière, nous obtenons …………...
Pour la partie décimale 0 x 2-1 + 1 x 2-2 + 0 x 2-3 + 1 x 2-4 = 0,25 + 0,0625 = 0,3125.
100,0101 représente le nombre décimal 4,3125

Exercice : 1/ Trouvez la représentation décimale de 1001,101

3.5 Python
Quand on tape :
>>> type(1/3)
on obtient :
<class ‘float’>
Pour les raisons d’approximation que nous avons vues précédemment, il faudra éviter les tests
d’égalité entre deux flottants

Ce qui signifie que pour Python, la représentation binaire du résultat de 0,1 + 0,2 n’est pas identique
à celle du nombre 0,3

3.6 Puissances de 2
En base dix, il est possible d'écrire les très grands nombres et les très petits nombres grâce aux
"puissances de dix" :
23 −11
exemples : " 6,02.10 " ou " 6,67.10 "
Il est possible de faire exactement la même chose avec une représentation binaire, puisque nous
sommes en base 2, nous utiliserons des "puissances de deux" à la place des "puissances dix".
L’exposant sera noté en binaire.
10
exemple : " 101,1101.2 "
ici le 2 est à la puissance ………
Pour passer d'une écriture sans "puissance de deux" à une écriture avec "puissance de deux", il
11
suffit décaler la virgule : " 1101,1001=1,1011001.2 "
nous avons décalé la virgule de ….. rangs vers la gauche
…….
on multiplie donc par " 2 "
Si l'on désire décaler la virgule vers la droite, il va être nécessaire d'utiliser des "puissances de deux
négatives"
……….
exemple : " 0,0110=1,10.2 " l’exposant est ici donné avec son écriture
nous décalons la virgule de 2 rangs binaire précédé de son signe + / -
vers la droite, d'où l’exposant ….

7
Cours Encodages NSI

3.7 Représentation des flottants dans un ordinateur

La norme IEEE 754 est la norme la plus employée pour la représentation des nombres à virgule
flottante dans le domaine informatique. Elle est basée sur l’écriture scientifique d’un nombre en
base 2.
Nous allons étudier deux formats associés à cette norme : le format dit "simple précision" et le
format dit "double précision". Le format "simple précision" utilise 32 bits pour écrire un nombre
flottant alors que le format "double précision" utilise 64 bits. Dans la suite nous travaillerons
principalement sur le format 32 bits.
La norme IEEE754 utilise :
• 1 bit de signe (1 si le nombre est négatif et 0 si le nombre est positif)
• des bits consacrés à l'exposant (8 bits pour la simple précision et 11 bits pour la double
précision)
• des bits consacrés à la mantisse (23 bits pour la simple précision et 52 bits pour la double
précision)

Nous pouvons vérifier que l'on a bien 1 + 8 + 23 = 32 bits pour la simple précision et 1 + 11 + 52 =
64 bits pour la double précision.

Méthode : stockage d’un flottant

e
1. Écrire le nombre sous la forme 1, XXXXX .2 (avec e l'exposant), il faut obligatoirement
qu'il y ait un seul chiffre à gauche de la virgule et il faut que ce chiffre soit un "1".
11
le nombre "1010,11001" devra être écrit " 1,01011001.2 "
−101
"0,00001001" devra être écrit " 1,001.2 ".
e
2. La partie "XXXXXX" de " 1, XXXXX .2 " constitue la mantisse (dans notre exemple
"1010,11001" la mantisse est "01011001"). Comme la mantisse comporte 23 bits en simple
précision, il faudra compléter avec le nombre de zéro nécessaire afin d'atteindre les 23 bits
si nous avons "01011001", il faudra ajouter 23 - 8 = 15 zéros à droite,
ce qui donnera en fin de compte "01011001000000000000000" )
3. Pour le format simple précision, 8 bits sont consacrés à l'exposant, il est donc possible de
représenter 256 valeurs. Nous allons pouvoir représenter des exposants compris entre -126
et +127 (les valeurs -127 et +128 sont des valeurs réservées)
La norme n’utilise pas le complément à 2 pour l’exposant, on procède à un décalage en
ajoutant systématiquement 127 à la valeur de l'exposant (pour -126, on stockera 1)
▪ "1010,11001" donne 1,01011001.23 (pour simplifier, la puissance est en
décimal)
130
▪ effectuons le décalage en ajoutant 127 à 3 : " 1,01011001.2 ",
10000010
▪ En passant l'exposant en base 2 : 1,01011001.2
▪ mantisse : "01011001000000000000000" (en ajoutant les zéros à droite)

8
Cours Encodages NSI
Remarques :
• On complète la mantisse avec des zéros à droite car il s’agit d’une partie fractionnaire pour
laquelle les zéros à droite sont des zéros inutiles (on complète pour arriver à 23 bits en
simple précision)
• On complète l’exposant qui est un entier avec des zéros à gauche (pour arriver à 8 bits en
simple précision)
• Pour le format double précision le décalage est de 1023 (il faut systématiquement ajouter
1023 à l'exposant afin d'obtenir uniquement des valeurs positives)

Exemple : Représentez le nombre "-10,125" au format simple précision :

−3
10 vaut 1010 en binaire et 0,125 s’écrit 0,001 ( 2 ).
10,125 s’écrit donc 1010,001
3
Décalons la virgule : 1010,001 = 1,010001.2 , soit avec le décalage de l'exposant de 127,
1,010001.2130 . En écrivant l'exposant en base 2, nous obtenons 1,010001.210000010
Nous avons donc :
• notre bit de signe = 1 (nombre négatif)
• nos 8 bits d'exposant = 10000010
• nos 23 bits de mantisse = 01000100000000000000000
Soit en "collant" tous les "morceaux" : 1 10000010 01000100000000000000000
Cette écriture étant peu lisible, il est possible d'écrire ce nombre en hexadécimal : C1220000

Exercice: 1/ Déterminer la représentation au format simple précision du décimal 5,25

2/ Donner la valeur décimale du nombre suivant encodé avec la norme IEEE 754
1 10000110 10101000000000000000000

9
Cours Encodages NSI

3.8 Connaitre le type que l’on manipule

Il est important de toujours connaître le type des données que l’on manipule en Python. Pour cela,
on peut utiliser la fonction native type()
Exemple :
• Les types int (entier) et float (approximation de réels)
de Python indiquent comment est encodé un nombre. On
peut forcer l’encodage flottant en ajoutant un point (la
virgule française)

• les opérations suivantes entre deux entiers (<class ‘int’>) + – * // %

renvoient pour résultat un entier (<class ‘int’>)

• La division décimale / entre deux entiers renvoie toujours un flottant, et ce

même si mathématiquement, le résultat est entier !

10
Cours Encodages NSI
IV – Codage des caractères
Nous savons qu'un ordinateur est uniquement capable de traiter des données binaires.
C’est donc aussi sous ce format que seront codés les textes (ou caractères)
4.1 ASCII
Avant 1960 de nombreux systèmes de codage de caractères existaient, ils étaient souvent
incompatibles entre eux. En 1960, l'organisation internationale de normalisation (ISO) créé la
norme ASCII (American Standard Code for Information Interchange). À chaque caractère est
associé un nombre binaire sur 8 bits (1 octet). En fait, seuls 7 bits sont utilisés pour coder un
caractère, le 8e bit n'est pas utilisé pour le codage des caractères. Avec 7 bits, il est possible de coder
jusqu'à 128 caractères ce qui est largement suffisant pour un texte écrit en langue anglaise (pas
d'accents et autres lettres particulières).
La page Wikipedia contient la liste des codes ASCII : Comme vous pouvez le constater dans ce
tableau, le caractère "A" majuscule correspond au code binaire 1000001, ou 65 en décimal ou 41 en
hexadécimal

Tableau de conversion
Le tableau ci-dessous permet de :
• trouver le code binaire,
décimal et hexadécimal
d’un caractère ASCII.
• Trouver le caractère ASCII
correspondant à un code
sur 7 bits.
• Convertir en base 2, 10 ou
16 les nombres compris
entre 0 et 127.

NB : b0 est le bit de poids faible et

b6, le bit de poids fort (codage 7
bit)

exemples :
10
« G » sera codé 71
16
(64+7) en décimal, 47 en
2
hexadécimal et 1000111 en
binaire

10
le nombre 99 (96+3)
16 2
s’écrit 63 ou 1100011 .
En ASCII, il code le « c »

11
Cours Encodages NSI
Exercice : Quel est le code binaire du "a" minuscule en ASCII ?
Et le code hexadécimal du point d’exclamation ?

NB : certains codes ne correspondent pas à des caractères (de 0 à 31 et 127)

Bit de parité
7 bits sont suffisants pour représenter les 128 caractères du code ASCII, mais en pratique, chaque
caractère occupe 1 octet, soit 8 bits en mémoire. Le bit de poids fort restant est utilisé comme
somme de contrôle afin de détecter d’éventuelles erreurs de transmission. L’idée consiste
simplement à fixer la valeur de ce bit de manière à ce que le nombre de bits à 1 dans l’octet soit
toujours pair. C’est la raison pour laquelle on appelle ce bit le bit de parité.
Cependant, de nos jours, le standard « de facto » qui est implémenté dans une grande part des
spécification ne respecte plus ce schéma d’encodage et force le 8ème bit à 0 pour être entièrement
compatible avec l’encodage UTF-8.

4.2 ASCII et Python

La fonction ord() renvoie le code ASCII (plus généralement le point de code de la

norme Unicode) correspondant à un caractère. L’entier renvoyé est en base 10, qui
peut être converti avec hex() par exemple pour avoir de l’hexadécimal.
Inversement, la fonction chr() renvoie le caractère correspondant à un entier
Les caractères peuvent également être saisis par leur code
ASCII en utilisant la notation \xhh ou hh est le code
hexadécimal du caractère.
Cette technique de saisie à l’aide de l’anti-slash \ est appelée caractère échappé, et le caractère \ est
appelé caractère d’échappement. Voici quelques caractères spéciaux accessibles par échappement :

Exemple : Le caractère \b a pour effet

de supprimer le caractère
a, \n passe à la ligne et \t
affiche une tabulation

12
Cours Encodages NSI
4.3 ISO-8859-1

La norme ASCII convient bien à la langue anglaise, mais pose des problèmes dans d'autres langues,
par exemple le français. En effet l'ASCII ne prévoit pas d'encoder les lettres accentuées. C'est pour
répondre à ce problème qu'est née la norme ISO-8859-1. Cette norme reprend les mêmes principes
que l'ASCII, mais les nombres binaires associés à chaque caractère sont codés sur 8 bits, ce qui
permet d'encoder jusqu'à 256 caractères. Cette norme va être principalement utilisée dans les pays
européens puisqu'elle permet d'encoder les caractères utilisés dans les principales langues
européennes (la norme ISO-8859-1 est aussi appelée "latin1" car elle permet d'encoder les
caractères de l'alphabet dit "latin")
Malheureusement, il existe beaucoup d'autres langues dans le monde qui n'utilisent pas l'alphabet
dit "latin", par exemple le chinois ou le japonnais ! D'autres normes ont donc dû voir le jour, par
exemple la norme "GB2312" pour le chinois simplifié ou encore la norme "JIS_X_0208" pour le
japonais.
Cette multiplication des normes a très rapidement posé problème. Imaginons un français qui parle le
japonais. Son traitement de texte est configuré pour reconnaître les caractères de l'alphabet "latin"
(norme ISO-8859-1). Un ami japonais lui envoie un fichier texte écrit en japonais. Le français devra
modifier la configuration de son traitement afin que ce dernier puisse afficher correctement
l'alphabet japonais. S'il n'effectue pas ce changement de configuration, il verra s'afficher des
caractères ésotériques.

4.4 Unicode

Pour éviter ce genre de problème, en 1991 une nouvelle norme a vu le jour : Unicode ou UCS en
anglais.
Unicode a pour ambition de rassembler tous les caractères existant afin qu'une personne utilisant
Unicode puisse, sans changer la configuration de son traitement de texte, à la fois lire des textes en
français ou en japonais.
Unicode est une table associant un caractère (lettre, nombre, idéogramme etc.), un nom unique (sa
description), et un numéro appelé point de code.
On utilise la notation U+xxxx pour désigner les points de code, où chaque x est un chiffre
hexadécimal. Par exemple, U+006F désigne la caractère o (111 en décimal).
Il existe plusieurs formats pour encoder les caractères Unicode en machine : UTF-8, UTF-16 et
UTF-32. Le plus utilisé, notamment sur Linux, les protocoles réseaux et le Web, est UTF-8.
Pour encoder les caractères Unicode, UTF-8 utilise un nombre variable d'octets : les caractères
simples (présents dans la norme ASCII) sont codés sur un octet, alors que des caractères "moins
classiques" sont codés sur un nombre d'octets plus important, jusqu'à 4 octets. Un des avantages
d'UTF-8 c'est qu'il est totalement compatible avec la norme ASCII : Les caractères Unicode codés
avec UTF-8 ont exactement le même encodage que les mêmes caractères en ASCII.

Exercice : Quel est l’encodage du "b" minuscule en UTF-8 ?

13
Cours Encodages NSI
4.5 Unicode et Python
Les chaînes de caractères en Python sont des séquences de caractères au format UTF-8. Ces
caractères peuvent être saisis avec à l’aide d’une séquence d’échappement \u suivi du point de code
en hexadécimal.

Il est possible de connaître l’encodage UTF-8 d’une chaîne de caractères Unicode à

l’aide de la méthode encode()
Le résultat est une chaîne d’octets (type différent du type string), elle est de la forme
b’...’. Les valeurs entre les apostrophes sont des octets en notation hexadécimale \x.. Le point
de code \U+0A9C est donc encodé en les 3 octets E0 AA 9C en UTF-8

De manière générale, seuls les caractères non ASCII sont donnés en hexadécimal, les autres étant
simplement affichés comme des caractères.
A noter ci-contre :
1. les lettres o, n et u sont affichés comme des caractères dans la
chaîne d’octets m
2. la méthode encode() s’applique à un type chaine de caractère
<class ‘str’> et renvoie une chaîne d’octet
<class ‘bytes’> alors que la méthode decode()
s’applique à un type chaîne d’octet et renvoie une chaîne de
caractères.
3. len(l) renvoie la longueur de la chaîne de caractère l, soit 7
4. len(m) renvoie la longueur de la chaîne d’octets m, soit 10
Il faut donc 10 octets pour encoder la chaine l en UTF-8

14