Ficha de revisão: Maîtrise des conversions numériques et représentations binaires

📋 Plan du Cours

1. Conversions de bases
2. Décimal vers binaire
3. Binaire vers décimal
4. Hexadécimal
5. Complément à 2
6. Nombres négatifs binaires
7. Flottants IEEE 754
8. Booléens
9. Représentation texte ASCII/Unicode
10. Outils Python

📖 1. Conversions de bases

🔑 Notions clés & Définitions

• Décimal : Système de numération en base 10, utilisant les chiffres de 0 à 9.
• Binaire : Système de numération en base 2, utilisant uniquement les chiffres 0 et 1. L’ordinateur ne comprend que cette base.
• Hexadécimal : Système de numération en base 16, utilisant les chiffres de 0 à 9 et les lettres A à F (A=10, F=15). Chaque chiffre hexadécimal correspond à 4 bits.
• Conversion décimal → binaire : Méthode officielle par division successive par 2, en notant les restes, puis lecture des restes de bas en haut.
• Conversion binaire → décimal : Chaque bit représente une puissance de 2 ; on additionne celles correspondant aux bits à 1.
• Conversion hexadécimal → binaire : Chaque chiffre hexadécimal se traduit par un groupe de 4 bits.
• Importance des conversions : Essentielles pour comprendre comment l’ordinateur stocke et manipule les données.

📝 Points essentiels

• L’ordinateur ne comprend que des 0 et 1, ce qui impose la nécessité de convertir d’un système à un autre pour interpréter ou manipuler des données.
• La conversion décimal → binaire se fait par division successive par 2. Il faut noter chaque reste et lire la série de bas en haut pour obtenir le nombre binaire.
• La conversion binaire → décimal consiste à multiplier chaque bit par la puissance de 2 correspondante (bit le plus à droite = $2^0$, puis $2^1$, etc.) et à faire la somme.
• La conversion hexadécimal → binaire repose sur le fait qu’un chiffre hexadécimal correspond à un groupe de 4 bits (exemple : A = 1010).
• Python facilite ces conversions avec des fonctions comme bin(), int() avec une base, et hex().

💡 À retenir

L’ordinateur fonctionne uniquement avec des données binaires, rendant indispensables les conversions entre bases pour comprendre, coder ou analyser ces données dans différents contextes. La méthode officielle pour convertir un nombre décimal en binaire est la division successive par 2, tandis que chaque bit en binaire représente une puissance de deux.

📖 2. Décimal vers binaire

🔑 Notions clés & Définitions

• Méthode officielle DS (division successive par 2) : technique pour convertir un nombre décimal en binaire en divisant le nombre par 2, en notant le reste à chaque étape, puis en lisant ces restes de bas en haut pour obtenir la représentation binaire.
• Reste : valeur obtenue lors de la division par 2, soit 0 ou 1, qui constitue chaque bit du nombre binaire.
• Lecture des restes : opération consistant à lire les restes obtenus lors des divisions successives de bas en haut pour former la représentation binaire correcte.
• Erreur fréquente : lire de haut en bas, oublier un reste ou ne pas finir la division lorsque le quotient devient 0.
• Astuce DS : toujours créer une colonne “reste” pour suivre facilement chaque étape.

📝 Points essentiels

• La conversion se fait par division répétée par 2 du nombre décimal.
• À chaque étape, on note le reste (0 ou 1).
• La division continue jusqu’à ce que le quotient atteigne 0.
• La représentation binaire est obtenue en lisant les restes de bas en haut (dernier reste en premier).
• Il faut faire attention aux erreurs classiques : ne pas inverser l’ordre des restes, ne pas oublier d’arrêter la division quand le quotient est zéro, et ne pas oublier que le dernier reste doit être pris en compte.

💡 À retenir

La méthode officielle DS pour convertir un nombre décimal en binaire consiste à diviser successivement par 2, noter les restes, puis lire ces restes de bas en haut pour obtenir la représentation binaire correcte. Toujours faire une colonne “reste” facilite cette opération et évite les erreurs.

📖 3. Binaire vers décimal

🔑 Notions clés & Définitions

• Puissance de 2 : chaque position d’un chiffre binaire représente une puissance de 2, selon sa position (ex : 128, 64, 32, 16, 8, 4, 2, 1).
• Table des puissances : tableau listant ces valeurs pour faciliter la conversion.
• Additionner les puissances : opération consistant à faire la somme des valeurs correspondant aux bits à 1 pour obtenir le nombre décimal.
• Erreurs fréquentes : oublier une puissance ou mal aligner les bits lors de la conversion.

📝 Points essentiels

• La conversion binaire → décimal consiste à additionner les puissances de 2 correspondant aux bits qui valent 1.
• La table des puissances à connaître est : 128, 64, 32, 16, 8, 4, 2, 1.
• Lors de la conversion, il faut faire attention à l’ordre des bits : le bit le plus à gauche correspond à la puissance la plus élevée (128), et celui de droite à la plus faible (1).
• Les erreurs courantes incluent l’oubli d’une puissance ou un mauvais alignement des bits, ce qui fausse le résultat final.

💡 À retenir

La conversion binaire en décimal repose sur l’addition des puissances de deux associées aux bits à 1. La maîtrise de cette opération repose sur la connaissance précise de la table des puissances et une attention particulière lors du traitement des bits.

📖 4. Hexadécimal

🔑 Notions clés & Définitions

• Chiffre hexadécimal : Un chiffre en base 16, correspondant à 4 bits. Il peut prendre les valeurs de 0 à 9 et de A à F, où A=10, B=11, C=12, D=13, E=14, F=15.
• Valeurs hexadécimales à connaître par cœur : A=10, F=15, FF=255.
• Conversion hexadécimal → binaire : Chaque chiffre hexadécimal se traduit par 4 bits binaires. Par exemple, F = 1111.
• Notation hexadécimale en Python : La valeur hexadécimale s’écrit avec le préfixe 0x, par exemple 0xFF qui correspond à 255 en décimal.
• Piège fréquent : Confondre la notation hexadécimale (ex: 0xFF) avec une valeur décimale (ex: 255), notamment dans les questions ou exercices.

📝 Points essentiels

• Un chiffre hexadécimal correspond toujours à 4 bits. Cela permet une conversion directe et simple entre ces deux bases.
• Les valeurs hexadécimales sont souvent utilisées pour représenter des données binaires de façon plus compacte et lisible.
• En Python, la conversion d’un nombre décimal en hexadécimal se fait via la fonction hex(), qui retourne une chaîne commençant par '0x'.
• La conversion inverse (hexadécimal → décimal) s’effectue avec la fonction int() en précisant la base : int('ff',16) donne 255.
• Lors de l’écriture ou de la lecture de valeurs hexadécimales dans du code ou des exercices, il faut faire attention aux préfixes '0x' ou '0b' pour binaire.

💡 À retenir

Un chiffre hexadécimal est une représentation compacte d’un groupe de 4 bits. La maîtrise des conversions entre hexadécimal et décimal ou binaire est essentielle pour éviter les confusions lors des exercices ou en programmation. La notation Python avec '0x' facilite cette manipulation mais doit être utilisée avec vigilance pour ne pas confondre valeurs et notations.

📖 5. Complément à 2

🔑 Notions clés & Définitions

• Complément à 2 : méthode de codage des nombres négatifs en binaire, permettant de représenter à la fois les nombres positifs et négatifs dans un même système.
• Premier bit (bit de signe) : le bit le plus à gauche dans une représentation binaire sur 8 bits ; sa valeur indique si le nombre est positif (0) ou négatif (1).
• Plage de valeurs sur 8 bits : de -128 à 127, correspondant aux nombres représentés par le complément à 2.
• Inversion des bits : opération consistant à changer chaque 0 en 1 et chaque 1 en 0.
• Méthode pour obtenir le complément à 2 d’un nombre négatif : inversion de tous les bits du nombre positif correspondant, puis ajout de 1.

📝 Points essentiels

• La représentation en complément à 2 permet d’interpréter correctement le signe d’un nombre binaire : si le premier bit est 1, le nombre est négatif ; si c’est 0, il est positif.
• Pour coder un nombre négatif (-42 par exemple) :
  • On commence par coder la valeur absolue (+42) en binaire sur 8 bits : 00101010.
  • On inverse tous les bits : 11010101.
  • On ajoute 1 au résultat inversé : 11010101 + 1 = 11010110.
  • Le résultat final, 11010110, représente -42 en complément à 2.
• La méthode générale pour obtenir le complément à 2 d’un nombre négatif :

1. Prendre la valeur absolue du nombre en binaire (sur la même taille).
2. Inverser tous les bits.
3. Ajouter 1 au résultat inversé.

• Lorsqu’on lit un nombre codé en complément à 2 :

- Si le premier bit = 0 → nombre positif, valeur directe.
- Si le premier bit = 1 → nombre négatif ; interpréter comme (- (complément à deux du reste)).

• La plage de valeurs possibles sur un octet (8 bits) est de -128 (10000000) à [phone]).

💡 À retenir

Le complément à 2 est une méthode efficace pour coder les nombres négatifs en binaire, où le premier bit indique le signe et la conversion se fait par inversion des bits + ajout de un. La lecture correcte du signe est essentielle pour éviter des erreurs d’interprétation lors des opérations ou des conversions.

📖 6. Nombres négatifs binaires

🔑 Notions clés & Définitions

Interprétation du premier bit comme bit de signe :
Dans une représentation binaire signée sur 8 bits, le premier bit (bit de poids fort) indique le signe du nombre. Si ce bit est 0, le nombre est positif ou nul ; s'il est 1, le nombre est négatif.

Représentation des nombres négatifs avec complément à 2 :
Méthode standard pour coder les nombres négatifs en binaire. Elle consiste à inverser tous les bits du nombre positif correspondant (inversion des bits) puis à ajouter 1. Cela permet d'utiliser la même opération d'addition pour gérer aussi bien les nombres positifs que négatifs.

Plage des nombres négatifs en binaire sur 8 bits :
Avec une représentation en complément à 2 sur 8 bits, la plage va de -128 à 127. Le plus petit nombre (-128) est représenté par 10000000, et le plus grand (127) par 01111111.

Différence entre représentation signée et non signée :

• Signée : utilise le premier bit pour indiquer le signe, permettant de coder des valeurs négatives. La plage va de -128 à 127 en 8 bits.
• Non signée : tous les bits représentent la valeur positive, allant de 0 à 255 en 8 bits.

📝 Points essentiels

• Pour coder un nombre négatif en complément à 2 :
  • On commence par écrire sa valeur absolue en binaire.
  • On inverse tous les bits (complément à un).
  • On ajoute 1 au résultat.
• Le premier bit (bit de signe) dans une représentation signée indique si le nombre est positif (0) ou négatif (1).
• La plage des valeurs possibles dépend du mode de représentation :
  • Signée (complément à 2) sur 8 bits : -128 à +127.
• Lorsqu’on lit un nombre binaire signé, si le premier bit est 1, il faut l’interpréter comme un nombre négatif en utilisant la méthode du complément à 2.

💡 À retenir

Le codage en complément à 2 permet d'utiliser une seule opération d'addition pour gérer aussi bien les nombres positifs que négatifs, avec une plage allant de -128 à 127 sur 8 bits. La lecture correcte d’un nombre signé nécessite d’interpréter le premier bit comme indicateur de signe et d’appliquer la méthode du complément à deux pour obtenir sa valeur réelle si ce bit est égal à 1.

📖 7. Flottants IEEE 754

🔑 Notions clés & Définitions

• Représentation approximative des nombres à virgule flottante : stockage en binaire d’un nombre réel qui ne peut pas être représenté exactement, mais seulement approché.
• Exemple classique : 0.1 + 0.2 != 0.3 en float, car la somme ne donne pas exactement 0.3 à cause de l’approximation binaire.
• Bonne méthode pour comparer flottants : utiliser une tolérance, par exemple abs(a - b) < 1e-9, plutôt que l’opérateur ==.
• Piège DS : ne jamais utiliser == pour comparer deux nombres flottants, car cela peut conduire à des erreurs d’interprétation dues à l’approximation.

📝 Points essentiels

• La représentation en virgule flottante est approximative à cause du stockage en binaire.
• La comparaison directe avec == est à éviter ; il faut privilégier la comparaison avec une tolérance (abs(a-b)<1e-9) pour vérifier si deux flottants sont proches.
• La raison principale de l’imprécision est que certains nombres décimaux comme 0.1 ne peuvent pas être codés exactement en binaire, ce qui entraîne des erreurs lors des opérations arithmétiques.
• La méthode officielle pour la conversion et le stockage est basée sur le standard IEEE 754, qui définit la représentation en mémoire (mais cette méthode n’est pas explicitement détaillée ici).
• Lorsqu’on manipule des flottants, il faut toujours garder en tête leur nature approximative et éviter les comparaisons directes.

💡 À retenir

Les nombres à virgule flottante sont approximatifs en raison de leur stockage binaire, et il est crucial d’utiliser une tolérance pour les comparaisons afin d’éviter des erreurs dans les exercices et applications.

📖 8. Booléens

🔑 Notions clés & Définitions

• Opérateur logique AND (ET) : Opération qui renvoie vrai si et seulement si toutes les conditions sont vraies.
• Opérateur logique OR (OU) : Opération qui renvoie vrai si au moins une condition est vraie.
• Opérateur logique XOR (OU exclusif) : Opération qui renvoie vrai si une seule condition est vraie, mais pas les deux.
• Opérateur logique NOT (Inverse) : Opération qui inverse la valeur d’une condition, vrai devient faux, faux devient vrai.
• Exemples simples d’opérations booléennes : Utilisation des opérateurs pour combiner ou inverser des conditions dans des expressions logiques.

📝 Points essentiels

• La confusion fréquente en DS concerne le piège entre AND et OR : ils ont des comportements très différents dans les opérations booléennes.
• Les booléens sont utilisés pour définir des conditions et contrôles dans la programmation ou la logique informatique, permettant de faire des choix selon que des conditions soient vraies ou fausses.
• Les opérations booléennes permettent de construire des expressions complexes en combinant plusieurs conditions simples.
• La valeur d’un booléen est soit VRAI soit FAUX. En informatique, généralement, VRAI correspond à 1 et FAUX à 0.

💡 À retenir

Les opérateurs logiques permettent de contrôler le flux du programme ou de la logique en combinant ou inversant des conditions, avec une importance particulière à ne pas confondre AND et OR lors de leur utilisation.

📖 9. Représentation texte ASCII/Unicode

🔑 Notions clés & Définitions

• ASCII : Code standard de caractères utilisant 7 bits pour représenter des lettres, chiffres, ponctuations et symboles courants. Par exemple, 'A' = 65, 'a' = 97, '0' = 48. La valeur ASCII est codée en décimal et peut être convertie en binaire (ex : 'A' = 65 → 01000001).
• Unicode : Standard de codage permettant de représenter tous les caractères du monde entier, y compris caractères spéciaux (é, è). La différence principale avec ASCII est la capacité à coder un plus grand nombre de caractères. La valeur Unicode pour 'é' ou 'è' doit être utilisée pour éviter des erreurs de représentation.
• Valeurs ASCII à connaître par cœur : A=65, a=97, 0=48.
• Exemple : La lettre 'A' codée en binaire est 01000001 (valeur ASCII 65).
• Piège DS : Oublier d'utiliser Unicode pour caractères spéciaux comme é ou è peut entraîner des erreurs dans la représentation ou le traitement du texte.

📝 Points essentiels

• La conversion lettres → nombres → binaire est la base pour représenter du texte en informatique.
• L’ASCII utilise une table de correspondance entre caractères et valeurs numériques (décimales).
• La valeur ASCII d’un caractère doit être mémorisée par cœur pour faciliter les conversions rapides.
• La différence entre ASCII et Unicode réside dans leur étendue : ASCII couvre seulement 128 caractères (7 bits), Unicode couvre une gamme beaucoup plus large (plusieurs milliers), permettant d’intégrer des caractères spéciaux comme é ou è.
• Lorsqu’on code un caractère spécial en Unicode, il faut utiliser la valeur Unicode appropriée plutôt que la valeur ASCII standard pour éviter les erreurs.
• Exemple pratique : La lettre 'A' est codée en binaire par 01000001 ; pour un caractère spécial comme 'é', il faut utiliser sa valeur Unicode spécifique.

💡 À retenir

La représentation texte en informatique repose sur la conversion des caractères en valeurs numériques selon des standards comme ASCII ou Unicode ; il est crucial de connaître ces valeurs par cœur et de ne pas oublier Unicode pour les caractères spéciaux afin d’éviter toute erreur dans le traitement du texte.

📖 10. Outils Python

🔑 Notions clés & Définitions

• bin() : Fonction Python qui convertit un nombre décimal en une chaîne de caractères représentant sa valeur binaire, en incluant le préfixe '0b'.
  Exemple : bin(42) renvoie '0b101010'.

• int() : Fonction Python permettant de convertir une chaîne de caractères représentant un nombre dans une base spécifique en un entier décimal. La syntaxe est int(chaîne, base).
  Exemple : int('1010', 2) convertit la chaîne binaire '1010' en décimal 10.

• hex() : Fonction Python qui convertit un nombre décimal en une chaîne de caractères représentant sa valeur hexadécimale, avec le préfixe '0x'.
  Exemple : hex(255) renvoie '0xff'.

📝 Points essentiels

• La fonction bin() retourne une chaîne avec le préfixe '0b', indiquant que la représentation est binaire.
• La fonction hex() retourne une chaîne avec le préfixe '0x', indiquant que la représentation est hexadécimale.
• La conversion binaire → décimal se fait via int() en précisant la base 2 (int('chaîne_binaire', 2)).
• La conversion hexadécimal → décimal se fait aussi via int() en précisant la base 16 (int('chaîne_hex', 16)).
• Ces outils permettent de vérifier rapidement des conversions et de manipuler différentes bases dans des exercices ou programmes.

💡 À retenir

Les fonctions bin(), int() (avec base), et hex() sont essentielles pour convertir entre bases dans Python, notamment pour vérifier ou manipuler des représentations binaires et hexadécimales, tout en étant attentif aux préfixes '0b' et '0x'.

📊 Tableaux de Synthèse

Système de numération	Base	Caractéristiques principales	Représentation	Conversion principale	Auteur / Référence
Décimal	10	Chiffres 0-9, système naturel humain	Nombre en chiffres	Division successive par 2 pour binaire, addition pour décimal → binaire	-
Binaire	2	Utilisé par ordinateur, 0 et 1	Bits (0 ou 1)	Multiplication par puissances de 2, lecture directe	-
Hexadécimal	16	Chiffres 0-9 + A-F, chaque chiffre = 4 bits	Chiffres et lettres (A-F)	Chaque chiffre = 4 bits, conversion via hex() et int() en Python	-
Complément à 2	-	Représentation des négatifs en binaire sur 8 bits (ou autre taille)	Bit de signe + valeur absolue inversée + +1 pour négatif	Inversion des bits + ajout de 1 pour négatif	-

⚠️ Pièges & Confusions Fréquentes

1. Confondre la lecture des restes lors de la conversion décimal → binaire : lire de haut en bas au lieu de bas en haut.
2. Oublier d’arrêter la division lorsque le quotient devient zéro lors de la conversion décimal → binaire.
3. Inverser l’ordre des bits lors de la conversion binaire → décimal, ce qui fausse le résultat.
4. Confondre notation hexadécimale (0x) avec une valeur décimale ou binaire dans un exercice.
5. Ne pas connaître ou maîtriser la table des puissances de 2 (128, 64, 32, etc.) pour convertir binaire → décimal.
6. Mal appliquer la méthode du complément à 2 : oublier d’inverser tous les bits ou d’ajouter +1.
7. Confondre le bit de signe avec la valeur absolue dans le complément à 2.

✅ Checklist Examen

1. Connaître la définition et l’usage du système décimal (Auteurs : Perroux sur la croissance).
2. Maîtriser la méthode officielle DS pour convertir un nombre décimal en binaire par division successive.
3. Savoir comment convertir un nombre binaire en décimal en utilisant la table des puissances de 2.
4. Être capable d’effectuer une conversion hexadécimale vers binaire et vice versa, en utilisant la correspondance 1 chiffre hexadécimal = 4 bits.
5. Comprendre le principe du complément à 2 pour représenter les nombres négatifs en binaire.
6. Connaître la plage de valeurs représentables en complément à 2 sur 8 bits (-128 à 127).
7. Savoir comment inverser tous les bits d’un nombre binaire et ajouter +1 pour obtenir le complément à 2 négatif.
8. Maîtriser la représentation des nombres négatifs binaires via le complément à 2.
9. Connaître les bases du codage ASCII/Unicode pour la représentation texte.
10. Savoir utiliser les outils Python (bin(), hex(), int()) pour effectuer ces conversions.
11. Être capable d’identifier et éviter les erreurs classiques lors des conversions (ordre des restes, inversion des bits, notation hexadécimale).
12. Vérifier que chaque étape est correcte avant de passer à la suivante dans une conversion complexe.