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)
			print(b)
			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.

Quelques exemples de nombres relatifs 8 bits codés en 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.

Oui, parce que si on essaie de faire 127 + 1 (c’est-à-dire avoir 128), on se retrouve en dehors de l’intervalle possible pour les entiers relatifs sur 8 bits, c’est à dire l’intervalle [-128 ; 127]. Donc on revient au nombre le plus petit de l’intervalle, soit -128.

Mais ce codage présente un gros avantage :

			# 0000 0001  (+1)
			+ 1111 1111  (-1)
			–––––––––––
			1 0000 0000
		

			# 0000 0100  (+4)
			+ 1111 1100  (-4)
			–––––––––––
			1 0000 0000
		

• 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^–1 = 0,1), les centièmes (10^–2 = 0,01), les millièmes (10^–3 = 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^–9) :

		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
			

• Connaître les deux valeurs booléennes (True / False, 1 / 0) et le type bool.
• Dresser la table de vérité des opérateurs fondamentaux (not, and, or) et du OU exclusif (xor).
• Évaluer des expressions booléennes combinées et maîtriser les règles de priorité.
• Comprendre et exploiter le principe d’évaluation séquentielle (« paresseuse » ou court-circuit).

Qu’est-ce qu’un booléen ?

Les opérateurs logiques fondamentaux

Pour combiner des valeurs booléennes, on utilise des opérateurs logiques. Leurs règles sont synthétisées dans une table de vérité listant tous les cas possibles.

Générer des booléens : les comparateurs

En programmation, les booléens sont le plus souvent le résultat de comparaisons entre variables :

Évaluation des expressions composées et priorités

Comme pour les opérations arithmétiques (où la multiplication est prioritaire sur l’addition), les opérateurs logiques ont un ordre de priorité strict :

1. Les parenthèses ( ) (priorité absolue) ;
2. L’opérateur not ;
3. L’opérateur and ;
4. L’opérateur or.

L’évaluation séquentielle

En Python (et dans la plupart des langages modernes), les expressions logiques sont évaluées de gauche à droite avec un mécanisme d’évaluation séquentielle (dite « paresseuse » ou court-circuit) :

• Dans False and <expression> : comme le premier membre est faux, l’expression globale sera forcément fausse. Python n’évalue même pas la seconde expression.
• Dans True or <expression> : comme le premier membre est vrai, l’expression sera forcément vraie. Python ignore également la suite.

            n = 0
            # Si n == 0, (n != 0) vaut False : Python s’arrête et n’exécute pas (10 / n) !
            if n != 0 and (10 / n) > 2:
                print("Condition validée")
            else:
                print("Aucune erreur ZeroDivisionError n’a été levée !")
        

• Comprendre la notion d’encodage (associer un code numérique à chaque symbole ou caractère).
• Connaître les caractéristiques et limites des encodages ASCII et ISO-8859-1 (Latin-1).
• Comprendre le principe universel du standard Unicode et du codage UTF-8.
• Manipuler les fonctions Python de conversion de caractères (ord() et chr()).

Du binaire au caractère : l’encodage

Un ordinateur ne stocke que des 0 et des 1. Pour manipuler du texte (lettres, signes de ponctuation, espaces, émojis), il faut établir une convention qui associe chaque symbole à un nombre entier binaire : c’est ce qu’on appelle un encodage de caractères.

Une chaîne de caractères (type str en Python) est simplement une suite ordonnée de caractères stockés en mémoire selon un encodage donné.

1. L’ASCII : la norme historique (7 bits)

Créé en 1963 aux États-Unis, le standard ASCII (American Standard Code for Information Interchange) est la base historique de l’informatique moderne.

• Il utilise 7 bits par caractère, permettant de coder 2⁷ = 128 caractères (numérotés de 0 à 127).
• Il contient l’alphabet latin majuscule/minuscule non accentué (A-Z, a-z), les chiffres (0-9), les signes de ponctuation usuels et des caractères de contrôle non imprimables (comme \n pour le saut de ligne ou \t pour la tabulation).

2. Les extensions sur 8 bits : l’ISO-8859-1 (Latin-1)

Puisque la mémoire physique est organisée en octets (8 bits), un bit restait inutilisé avec l’ASCII. La norme ISO-8859-1 (aussi appelée Latin-1) a utilisé ce 8^e bit pour doubler le nombre de symboles possibles : 2⁸ = 256 caractères (de 0 à 255).

• Les 128 premiers caractères (0 à 127) sont strictement identiques à l’ASCII.
• Les 128 caractères supplémentaires (128 à 255) contiennent les caractères accentués d’Europe occidentale (é, à, ñ, ß…).

3. La solution universelle : Unicode et UTF-8

Pour unifier toutes les langues au sein d’un format unique, le consortium Unicode a été créé en 1991.

A. Le répertoire Unicode

Unicode n’est pas un format de fichier, mais un catalogue universel qui associe un numéro unique (appelé point de code, noté U+XXXX) à chaque caractère ou symbole existant (plus de 155 000 symboles couvrant tous les alphabets du monde – y compris ceux de l’antiquité, symboles mathématiques et émojis) avec un maximum théorique de plus d’un million !

B. L’encodage UTF-8 (longueur variable de 1 à 4 octets)

UTF-8 (Universal Character Set Transformation Format - 8-bit) est la méthode la plus intelligente et la plus répandue pour stocker les points de code Unicode en mémoire :

• Taille variable : Chaque caractère est codé sur 1, 2, 3 ou 4 octets selon sa rareté.
• 100 % rétrocompatible avec l’ASCII : Les 128 caractères ASCII sont codés sur 1 seul octet (avec un premier bit à 0), à l’identique de l’ASCII historique.
• Les caractères accentués courants (comme é) prennent 2 octets.
• Les écritures asiatiques prennent généralement 3 octets.
• Les émojis et symboles rares prennent 4 octets.

Manipulation des caractères en Python

Python fournit deux fonctions natives pour convertir un caractère en son point de code numérique et inversement :

        # ord() et chr() sont des opérations inverses :
        print(chr(ord("Z")))  # Affiche "Z"

        # L’ordre alphabétique respecte l’ordre des codes :
        print(ord("B") - ord("A"))  # 66 - 65 = 1

        # Parcourir les lettres de l’alphabet latin :
        alphabet = [chr(i) for i in range(ord("A"), ord("Z") + 1)]
        print("".join(alphabet))  # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    

            def decaler_majuscule(lettre, decalage):
                # On ramène le code entre 0 et 25, on ajoute le décalage modulo 26, puis on réaligne sur "A"
                code_relatif = ord(lettre) - ord("A")
                nouveau_code = (code_relatif + decalage) % 26
                return chr(ord("A") + nouveau_code)
        

					def coder_mot(mot, decalage):
						code = ""
						for lettre in mot:
							code += decaler_majuscule(lettre, decalage)
						return code