3-01. Représentation de l’information

• Comprendre le principe de la numération de position.
• Passer d’une base à une autre (bases 2, 10 et 16).
• Comprendre les notions de bit, d’octet et de quartet.
• Manipuler les différentes bases de numération en Python.

Pourquoi plusieurs bases de numération ?

Au quotidien, on compte en base 10 (système décimal). Pourquoi ? Tout simplement parce qu’on a 10 doigts ! On utilise donc 10 symboles (les chiffres de 0 à 9) et, dès qu’on dépasse 9, on crée une nouvelle « retenue » (les dizaines, les centaines, etc.).

Travailler uniquement avec des suites de 0 et de 1 (comme 110101101011) devient très vite illisible pour nous, humains. C’est pour ça que les informaticiens utilisent la base 16 (système hexadécimal) comme une écriture « condensée » et pratique du binaire.

Comprendre la numération de position

Avant d’étudier le binaire et l’hexadécimal, décomposons la manière dont nous écrivons les nombres en base 10. C’est ce qu’on appelle la numération de position : la valeur d’un chiffre dépend de sa position dans le nombre.

Prenons le nombre 2026 en base 10 :

Ce nombre vaut donc : 2×1000 + 0×100 + 2×10 + 6×1 = 2026.

La base 2 : le binaire

En base 2, on n’a que deux symboles : 0 et 1. Les poids des colonnes sont les puissances de 2 : 2⁰ = 1, 2¹ = 2, 2² = 4, 2³ = 8, 2⁴ = 16, 2⁵ = 32, 2⁶ = 64, 2⁷ = 128, etc.

A. Conversion du binaire vers le décimal

Pour connaître la valeur en décimal d’un nombre binaire, il suffit d’additionner les poids des colonnes qui contiennent un 1.

B. Conversion du décimal vers le binaire

Il existe deux méthodes pour effectuer cette conversion.

La base 16 : l’hexadécimal

En base 16, il nous faut 16 symboles. Les chiffres de 0 à 9 ne suffisent plus ! On utilise donc les lettres de A à F pour représenter les valeurs de 10 à 15 :

Le lien entre binaire et hexadécimal

Puisque 16 = 2⁴, un chiffre hexadécimal correspond exactement à un paquet de 4 bits.

A. Conversion binaire ↔ hexadécimal

Pour convertir un nombre binaire en hexadécimal :

1. On découpe le nombre binaire par paquets de 4 bits en partant de la droite.
2. On convertit chaque paquet de 4 bits en son chiffre hexadécimal correspondant.

Exemple : Convertir (11010110)₂ en hexadécimal.

• On découpe en 2 quartets : 1101 et 0110.
• (1101)₂ = 8 + 4 + 1 = 13 ⇒ en hexadécimal, c’est D.
• (0110)₂ = 4 + 2 = 6 ⇒ en hexadécimal, c’est 6.

Résultat : (11010110)₂ = (D6)₁₆.

B. Convertir de l’hexadécimal vers le décimal

Les poids des colonnes en hexadécimal sont les puissances de 16 : 16⁰ = 1, 16¹ = 16, 16² = 256, etc.

Exemple : Convertir (2F)₁₆ en décimal.

• Le chiffre 2 est au rang 1 (poids 16) : 2×16 = 32.
• Le chiffre F (qui vaut 15) est au rang 0 (poids 1) : 15×1 = 15.

Résultat : 32 + 15 = 47. Donc (2F)₁₆ = (47)₁₀.

Les bases de numération en Python

Python sait manipuler nativement les nombres écrits dans différentes bases. Par défaut, tous les nombres affichés par Python le sont en base 10, mais on peut lui spécifier la base lors de la saisie d’une valeur en utilisant un préfixe :

• Préfixe 0b pour le binaire (ex: 0b1011)
• Préfixe 0x pour l’hexadécimal (ex: 0xA3)

		a = 0b1011   # Saisie en binaire (vaut 11 en décimal)
		b = 0xA3     # Saisie en hexadécimal (vaut 163 en décimal)

		print(a)     # Affiche 11 (Python convertit automatiquement en décimal)
		print(b)     # Affiche 163
		print(a + b) # Affiche 174 (11 + 163)
	

Fonctions de conversion en Python

Python fournit des fonctions intégrées pour convertir un entier vers une chaîne de caractères représentée dans une autre base, ou vice-versa :

		# Passer du décimal vers le binaire/hexa :
		nombre = 42
		print(bin(nombre))  # "0b101010"
		print(hex(nombre))  # "0x2a"

		# Passer d’une chaîne binaire ou hexa vers un nombre entier :
		valeur_bin = int("1101", 2)   # 13
		valeur_hex = int("FF", 16)    # 255
		print(valeur_bin + valeur_hex) # 268
	

			a = 0b101
			b = 0x10
			print(a + b)
		

				print(hex(int("10110", 2)))   # Affiche ’0x16’
			

• Évaluer le nombre de bits nécessaires à l’écriture en binaire d’un entier, d'une somme et d'un produit.
• Comprendre le codage des entiers relatifs avec le complément à 2.
• Connaître les tailles courantes d'entiers (8, 16, 32 et 64 bits) et la spécificité de Python.

Taille des entiers en mémoire (champs de bits fixes)

Dans la section précédente, nous avons écrit des nombres binaires avec autant de bits que nécessaire. Mais dans un ordinateur réel, la mémoire physique est organisée en « cases » de tailles fixes. Les tailles les plus fréquentes sont :

• 8 bits (1 octet) ;
• 16 bits (2 octets) ;
• 32 bits (4 octets) ;
• 64 bits (8 octets).

Quand on réserve un emplacement mémoire de $*n*$ bits pour un entier non signé (positif ou nul), on dispose de 2^$*n*$ combinaisons possibles, permettant de coder tous les entiers de 0 à 2^$*n*$ − 1.

Évaluer le nombre de bits nécessaires

A. Pour un entier $*N*$

Pour coder un entier positif $*N*$ en binaire, il faut trouver le plus petit nombre de bits $*k*$ tel que $*N*$ < 2^$*k*$. En d’autres termes, le nombre de bits $*k*$ est tel que 2^$*k*$-1 ≤ $*N*$ < 2^$*k*$.

Exemple : Pour coder $*N*$ = 200 :

• 2⁷ = 128 (trop petit)
• 2⁸ = 256 (suffisant car 200 < 256)

Il faut donc 8 bits pour représenter 200.

B. Pour une somme ($*A*$ + $*B*$)

Si un entier $*A*$ nécessite $*k*$ bits et un entier $*B*$ nécessite $*p*$ bits (avec $*k*$ ≥ $*p*$), la somme $*A*$ + $*B*$ nécessite au plus $*k*$ + 1 bits (un bit de plus pour gérer la retenue finale).

Exemple : $*A*$ = 200 (8 bits) et $*B*$ = 150 (8 bits). $*A*$ + $*B*$ = 350. Comme 350 < 2⁹ = 512, il faut 9 bits.

C. Pour un produit ($*A*$ × $*B*$)

Si un entier $*A*$ s'écrit sur $*k*$ bits et $*B*$ sur $*p*$ bits, leur produit $*A*$ × $*B*$ nécessite au plus $*k*$ + $*p*$ bits.

Exemple : $*A*$ = 15 (1111₂ → 4 bits) et $*B*$ = 12 (1100₂ → 4 bits). $*A*$ × $*B*$ = 180. Comme 180 < 2⁸ = 256, il faut 4 + 4 = 8 bits.

Le cas particulier de Python : entiers de taille arbitraire

Dans la plupart des langages de programmation traditionnels (C, C++, Java), les variables ont une taille fixe dans la mémoire (32 ou 64 bits). Si le résultat d'un calcul dépasse cette taille, le nombre recommence à zéro ou provoque une erreur.

Python est différent ! Il gère automatiquement les entiers de taille arbitraire. Tant que votre ordinateur a de la mémoire RAM disponible, Python agrandit la taille mémoire du nombre au fur et à mesure qu'il grandit. On peut donc calculer 2¹⁰⁰⁰ sans aucun problème de dépassement !

Représentation des entiers négatifs : le complément à 2

Un ordinateur ne dispose ni d'un signe « − », ni d'un signe « + ». Il ne connaît que des 0 et des 1. Comment représenter un nombre négatif comme −5 dans une case mémoire de $*n*$ bits ?

Pourquoi la méthode « naïve » ne marche pas

L'idée la plus simple consisterait à réserver le premier bit (celui tout à gauche) pour le signe (0 pour +, 1 pour −). Mais cette méthode pose deux gros problèmes :

• Elle crée deux représentations pour zéro : un « +0 » et un « −0 », ce qui fait gaspiller une combinaison.
• Les opérations mathématiques de base ne fonctionnent plus ! Additionner +5 et −5 ne donnerait pas 0.

La solution universelle : le complément à 2

En informatique, les entiers signés (positifs ou négatifs) sont codés selon la méthode du complément à 2.

Exemple pas à pas : Coder le nombre −5 sur 8 bits (1 octet).

1. On écrit +5 sur 8 bits : 0000 0101
2. On inverse tous les bits : 1111 1010
3. On ajoute 1 : 1111 1010 + 1 = 1111 1011

Ainsi, en complément à 2 sur 8 bits, −5 s'écrit 1111 1011.

Comprendre le poids du premier bit

Dans un codage en complément à 2 sur $*n*$ bits, le premier bit à gauche (bit de poids fort) a un rôle particulier :

• S'il vaut 0, le nombre est positif ou nul.
• S'il vaut 1, le nombre est négatif. Son poids n'est pas +2^$*n*$-1, mais −2^$*n*$-1 !

Vérifions notre exemple 1111 1011 sur 8 bits :

Calcul : −128 + 64 + 32 + 16 + 8 + 0 + 2 + 1 = −5.

Intervalle de valeurs pour $*n*$ bits signés

Sur $*n*$ bits signés en complément à 2, les valeurs représentables vont de −2^$*n*$-1 à +2^$*n*$-1 − 1.

Par exemple, sur 8 bits signés :

• Le plus grand positif est 0111 1111 = +127
• Le plus petit négatif est 1000 0000 = −128

			0000 0101  (+5)
			+  1111 1011  (-5)
			------------------
			1 0000 0000  (= 0 sur 8 bits, le 9e bit de retenue tout à gauche est ignoré !)
		

• Comprendre le principe de la représentation binaire des réels (puissances négatives de 2).
• Calculer la représentation binaire de réels simples (0,5 ; 0,25 ; 0,75…).
• Comprendre pourquoi certains nombres réels comme 0,1 n'ont pas d’écriture binaire exacte.
• Comprendre les conséquences pratiques en programmation (erreurs d'arrondi et comparaison de flottants).

L'infini dans une mémoire finie

Pour les entiers, les choses sont simples : entre 0 et 10, il n'y a qu'un nombre fini d'entiers (11 exactement). Mais pour les nombres réels (les nombres à virgule), c'est une autre histoire : entre 0 et 1, il existe une infinité de nombres réels (0,1 ; 0,15 ; 0,0001 ;…)

Un ordinateur possédant une mémoire finie, il est physiquement impossible de stocker toutes les valeurs réelles possibles. L'ordinateur va donc devoir stocker la plupart de ces nombres sous forme approximative. On appelle ces nombres des flottants (floats en anglais).

La virgule en binaire (puissances négatives de 2)

En décimal, les chiffres situés après la virgule représentent les dixièmes (10⁻¹ = 0,1), les centièmes (10⁻² = 0,01), les millièmes (10⁻³ = 0,001), etc.

En binaire, c'est le même principe ! Les chiffres après la virgule correspondent aux puissances négatives de 2 :

Pour trouver la valeur d'un nombre binaire à virgule, on additionne simplement ses poids :

• (0,1)₂ = 1 × 0,5 = 0,5
• (0,01)₂ = 0 × 0,5 + 1 × 0,25 = 0,25
• (0,11)₂ = 0,5 + 0,25 = 0,75
• (10,101)₂ = 2 + 0,5 + 0,125 = 2,625

Les nombres « infinis »

En base 10, nous savons tous que la fraction 1/3 ne « tombe pas juste » : 1/3 = 0,333333… avec une infinité de 3. On ne peut pas l'écrire exactement avec un nombre fini de chiffres décimaux.

En binaire, c'est exactement la même chose pour certaines fractions. Un nombre décimal ne possède une écriture binaire exacte que s'il s'exprime comme une somme finie de puissances négatives de 2.

Prenons le nombre 0,1 (c'est-à-dire 1/10). Si on essaie de le convertir en binaire :

(0,1)₁₀ = (0,00011001100110011…)₂ (la suite 0011 se répète à l'infini !)

Comment la mémoire stocke-t-elle un « flottant » ?

C’est vrai ! Dans la mémoire de l'ordinateur, il n'existe pas de caractère « point » ou « virgule », ni de signe « − ». Il n'y a que des 0 et des 1. Pour stocker un nombre réel sur 64 bits (norme courante des ordinateurs), la mémoire utilise la notation scientifique binaire (par exemple 1,101^-10) et découpe la case mémoire en 3 zones fixes :

L'ordinateur n'a donc pas besoin de stocker le symbole de la virgule : la position de la virgule est calculée dynamiquement grâce à l'exposant (elle « flotte », d'où le nom de flottant). Et si la suite de bits est infinie (comme pour 0,1), la mantisse se remplit jusqu'au 52^e bit et coupe sauvagement le reste, créant une infime erreur d'arrondi.

Les conséquences concrètes en Python

Cette légère imprécision a des conséquences directes très célèbres en programmation. Ouvrez une console Python et tapez :

		>>> 0.1 + 0.2
		0.30000000000000004

		>>> 0.1 + 0.2 == 0.3
		False
	

Puisque 0,1 et 0,2 sont stockés avec de minuscules erreurs d'arrondi en binaire, leur somme donne 0.30000000000000004 et non pas exactement 0.3 !

Comment comparer correctement deux flottants en Python ?

Pour vérifier si deux flottants a et b sont "égaux", on teste si la valeur absolue de leur différence est extrêmement petite (inférieure à un seuil de tolérance $*\epsilon*$, par exemple 10⁻⁹) :

		a = 0.1 + 0.2
		b = 0.3

		# ❌ Mauvaise méthode :
		if a == b:
			print("Égaux")  # Ne s'exécutera PAS !

		# ✅ Bonne méthode (test de tolérance) :
		if abs(a - b) < 1e-9:
			print("Les nombres sont égaux à la tolérance près !")

		# ✅ Variante avec le module math de Python :
		import math
		if math.isclose(a, b):
			print("Les nombres sont très proches !")
	

			x = 0.0
			while x != 1.0:
				print(x)
				x = x + 0.1
		

				x = 0.0
				while x < 1.0:  # Se termine dès que x dépasse 1.0
					print(x)
					x = x + 0.1