Conversions entre décimal, binaire et hexadécimal

Convertir un nombre d'une base à une autre, c'est changer son écriture sans changer sa valeur : (156)₁₀ = (10011100)₂ = (9C)₁₆. Ce chapitre donne une méthode sûre pour chacun des six sens de conversion entre les bases 10, 2 et 16, avec des exemples détaillés, la façon de vérifier ton résultat, et les usages en réseau et en développement : adresses IP, adresses MAC, couleurs.

Vue d'ensemble des méthodes

Du binaire ou de l'hexadécimal vers le décimal

C'est la définition même de la numération de position (chapitre 1) : tu multiplies chaque chiffre par son poids et tu additionnes.

Exemple 1. (1101001)₂ : les bits à 1 sont aux positions 6, 5, 3 et 0.

(1101001)₂ = 64 + 32 + 8 + 1 = 105.

Exemple 2. (7EA)₁₆ : E vaut 14, A vaut 10.

(7EA)₁₆ = 7 × 256 + 14 × 16 + 10 × 1 = 1 792 + 224 + 10 = 2 026.

La méthode de Horner, plus rapide pour les longs nombres : tu lis les chiffres de gauche à droite, et à chaque chiffre tu multiplies le résultat courant par la base avant d'ajouter le chiffre.

(7EA)₁₆ :   7
            7 × 16 + 14 = 126
          126 × 16 + 10 = 2026

Elle évite de calculer les puissances, et c'est exactement ce que fait un programme qui lit un nombre chiffre par chiffre (chapitre 11).

Du décimal vers le binaire : les divisions successives

Pour écrire un entier N en base 2 :

1. divise N par 2 : note le quotient et le reste (0 ou 1) ;
2. recommence avec le quotient, jusqu'à obtenir un quotient égal à 0 ;
3. lis les restes de bas en haut : le dernier reste obtenu est le bit de poids fort.

Exemple : 156 en binaire.

En lisant les restes de bas en haut : 156 = (10011100)₂.

Vérification : 128 + 16 + 8 + 4 = 156. Prends l'habitude de vérifier chaque conversion dans l'autre sens : cela prend vingt secondes et rattrape la plupart des erreurs.

Pourquoi ça marche ? Chaque division par 2 est une division euclidienne : 156 = 2 × 78 + 0. Le reste dit si le nombre est pair ou impair, c'est-à-dire son bit de poids faible. Diviser par 2 décale ensuite tous les bits d'un rang vers la droite, et le reste suivant donne le bit suivant.

Du décimal vers le binaire : la soustraction des puissances de 2

Pour un nombre pas trop grand, cette méthode va plus vite et se fait de tête :

1. cherche la plus grande puissance de 2 inférieure ou égale au nombre, et écris 1 à sa position ;
2. retire-la, puis recommence avec le reste ;
3. mets 0 aux positions des puissances que tu n'as pas utilisées.

Exemple : 156.

• La plus grande puissance de 2 qui tient dans 156 est 128 : 156 − 128 = 28.
• 64 et 32 ne tiennent pas dans 28 : 0 et 0.
• 16 tient : 28 − 16 = 12.
• 8 tient : 12 − 8 = 4.
• 4 tient : 4 − 4 = 0.
• 2 et 1 : 0 et 0.

156 = (10011100)₂, comme avec les divisions.

C'est la méthode qu'utilisent les administrateurs réseau pour convertir un octet d'adresse IP : avec le tableau 128, 64, 32, 16, 8, 4, 2, 1 écrit en haut de la feuille, un octet se convertit en quelques secondes.

Du décimal vers l'hexadécimal

La méthode des divisions successives marche dans toutes les bases : il suffit de diviser par 16 au lieu de 2. Les restes vont alors de 0 à 15, et tu écris les restes de 10 à 15 avec les lettres A à F.

Exemple : 2 026 en hexadécimal.

En lisant de bas en haut : 2 026 = (7EA)₁₆.

Pour faire la division euclidienne par 16 à la calculatrice : 2 026 ÷ 16 = 126,625. Le quotient est la partie entière, 126, et le reste vaut 2 026 − 16 × 126 = 2 026 − 2 016 = 10. Ne prends jamais la partie décimale (625) pour le reste. Sur certaines calculatrices, une touche ou une fonction donne directement quotient et reste ; en Python, divmod(2026, 16) renvoie (126, 10).

Autre méthode : passer par le binaire. 2 026 = 1 024 + 512 + 256 + 128 + 64 + 32 + 8 + 2, soit (11111101010)₂. Regroupé par 4 bits depuis la droite : 0111 1110 1010, soit 7, E, A. On retrouve (7EA)₁₆.

Binaire et hexadécimal par paquets de 4 bits

Comme 16 = 2⁴, chaque chiffre hexadécimal correspond à un paquet de 4 bits, et inversement. La conversion se fait sans aucun calcul sur le nombre entier.

Du binaire vers l'hexadécimal :

1. découpe le nombre en paquets de 4 bits en partant de la droite ;
2. complète le paquet de gauche avec des 0 si besoin ;
3. remplace chaque paquet par son chiffre hexadécimal (tableau du chapitre 1).

(1011101011)₂ → 0010 1110 1011 → 2, E, B → (2EB)₁₆.

Vérification par le décimal : (2EB)₁₆ = 2 × 256 + 14 × 16 + 11 = 512 + 224 + 11 = 747, et (1011101011)₂ = 512 + 128 + 64 + 32 + 8 + 2 + 1 = 747. Les deux écritures représentent bien le même nombre.

De l'hexadécimal vers le binaire : remplace chaque chiffre par ses 4 bits, sans oublier les 0 de tête à l'intérieur du nombre.

(3B7)₁₆ → 3 = 0011, B = 1011, 7 = 0111 → (0011 1011 0111)₂, soit (1110110111)₂ sans les zéros de tête.

Écrire un nombre sur un nombre fixe de bits

En informatique, un nombre est presque toujours stocké sur un nombre fixe de bits : 8, 16, 32 ou 64. On complète alors à gauche avec des 0, qui ne changent pas la valeur.

• 10 sur 8 bits : 0000 1010.
• 1 sur 8 bits : 0000 0001.
• 156 sur 16 bits : 0000 0000 1001 1100, soit (009C)₁₆.

Un octet s'écrit toujours avec 8 bits et deux chiffres hexadécimaux : on écrit (0A)₁₆ et non (A)₁₆ dans une adresse MAC ou une couleur.

Application : une adresse IPv4 en binaire

Une adresse IPv4 est un nombre de 32 bits, écrit en notation décimale pointée : quatre octets en décimal, séparés par des points. Chaque octet se convertit séparément, sur 8 bits.

192.168.1.10 = 11000000.10101000.00000001.00001010.

Le masque /24 s'écrit avec 24 bits à 1 suivis de 8 bits à 0 : 11111111.11111111.11111111.00000000, soit 255.255.255.0. Les valeurs possibles d'un octet de masque sont celles où les 1 sont tous à gauche :

Le calcul de l'adresse de réseau à partir de l'adresse et du masque utilise le ET logique bit à bit (chapitre 4). Le cours réseaux détaille le calcul du réseau, de la diffusion et du nombre d'hôtes.

Application : adresses MAC, IPv6 et couleurs

Adresse MAC. Une adresse MAC compte 48 bits, écrits en 6 octets hexadécimaux : 3C:52:82:1A:F0:7E. Les trois premiers octets identifient le fabricant de la carte réseau (OUI). Le dernier octet, (7E)₁₆, vaut 7 × 16 + 14 = 126, soit (01111110)₂.

Adresse IPv6. Une adresse IPv6 compte 128 bits, écrits en 8 groupes de 4 chiffres hexadécimaux (16 bits chacun) séparés par « : ». Le groupe 0db8 vaut (0000 1101 1011 1000)₂. Les zéros de tête d'un groupe peuvent être omis (db8), et une suite de groupes nuls peut être remplacée une fois par « :: ».

Couleur web. En CSS, #1E90FF désigne une couleur par ses trois composantes rouge, vert, bleu, chacune sur un octet :

#1E90FF et rgb(30, 144, 255) désignent la même couleur. Avec 256 valeurs par composante, on obtient 256³ = 2²⁴ = 16 777 216 couleurs. Le cours HTML et CSS détaille les autres notations de couleurs.

Les conversions en Python

Python fait toutes ces conversions. Elles te servent à vérifier tes calculs, pas à les remplacer à l'écrit.

bin(156)          # '0b10011100'
hex(2026)         # '0x7ea'
int('10011100', 2)   # 156
int('7EA', 16)       # 2026
format(10, '08b')    # '00001010' : 8 bits, complété par des 0
format(255, '02X')   # 'FF' : 2 chiffres hexadécimaux en majuscules

Le chapitre 11 programme les mêmes conversions à la main, avec les divisions successives, comme un sujet peut te le demander.

Exercices