Aller au contenu

Fiche de révision - Représentation des données : types et valeurs de base

1. Entiers positifs et bases de numération

  • Un nombre peut s'écrire en base 2 (binaire), base 10 (décimal) ou base 16 (hexadécimal)
  • Binaire : chiffres 0 et 1. Chaque position est une puissance de 2
  • Hexadécimal : chiffres 0-9 et A-F (A=10, B=11, ..., F=15)

Conversions :

De → Vers Méthode
Décimal → Binaire Divisions successives par 2 (restes lus de bas en haut)
Binaire → Décimal Additionner les puissances de 2 correspondant aux bits à 1
Binaire ↔ Hexadécimal Grouper les bits par paquets de 4
Décimal → Hexadécimal Divisions successives par 16

Nombre de bits : avec n bits, on représente 2ⁿ valeurs (de 0 à 2ⁿ - 1).

Python : bin(42) → '0b101010', hex(255) → '0xff', int('1010', 2) → 10

2. Entiers relatifs (complément à 2)

Le complément à 2 est la méthode standard pour coder les entiers négatifs.

Coder un négatif sur n bits :

  1. Écrire la valeur absolue en binaire sur n bits
  2. Inverser tous les bits (0↔1)
  3. Ajouter 1

Décoder un nombre en complément à 2 :

  • Bit de poids fort = 0 → positif (lire normalement)
  • Bit de poids fort = 1 → négatif (inverser les bits, ajouter 1, mettre un signe -)

Intervalle sur n bits : de -2ⁿ⁻¹ à +2ⁿ⁻¹ - 1

Bits Minimum Maximum
8 -128 +127
16 -32 768 +32 767
32 -2 147 483 648 +2 147 483 647

Attention

Dépassement de capacité (overflow) : quand le résultat d'un calcul sort de l'intervalle, la valeur obtenue est fausse (le signe change).

3. Nombres flottants (virgule flottante)

  • Un flottant est stocké sous la forme : signe × mantisse × 2^exposant^
  • Analogie : la notation scientifique (3,14 × 10²)

Les pièges :

Problème Exemple
Représentation inexacte 0.1 + 0.2 → 0.30000000000000004
Accumulation d'erreurs Additionner 0,1 dix fois ≠ 1,0
Comparaison dangereuse 0.1 + 0.2 == 0.3 → False

Trois règles d'or :

  1. Ne jamais tester l'égalité entre flottants → utiliser abs(a - b) < epsilon
  2. Utiliser des entiers quand c'est possible (centimes au lieu d'euros)
  3. Les puissances de 2 sont exactes : 0,5, 0,25, 0,125, 0,75...

4. Booléens et expressions booléennes

Un booléen ne prend que deux valeurs : True (1) ou False (0).

Opérateurs et tables de vérité :

a b not a a and b a or b a ^ b (XOR)
0 0 1 0 0 0
0 1 1 0 1 1
1 0 0 0 1 1
1 1 0 1 1 0

Lois de De Morgan :

  • not (a and b) = (not a) or (not b)
  • not (a or b) = (not a) and (not b)

Évaluation paresseuse (court-circuit) :

  • False and X → False sans évaluer X
  • True or X → True sans évaluer X

Addition binaire :

  • Somme = A XOR B
  • Retenue = A AND B

5. Encodage des textes

Encodage Date Taille Nb de caractères Couverture
ASCII 1963 7 bits 128 Anglais (pas d'accents)
ISO-8859-1 (Latin-1) 1986 8 bits 256 Europe de l'Ouest
Unicode (UTF-8) 1991 1 à 4 octets 150 000+ Toutes les langues
  • UTF-8 : taille variable, compatible ASCII, standard du Web (98 % des sites)
  • Un caractère ASCII = 1 octet en UTF-8
  • Un caractère accentué = 2 octets en UTF-8
  • Un emoji = 4 octets en UTF-8

Python : ord('A') → 65, chr(233) → 'é'

L'écart entre majuscule et minuscule est toujours 32 : ord('a') - ord('A') = 32.

Bonne pratique

Toujours utiliser UTF-8 et préciser encoding="utf-8" à l'ouverture d'un fichier en Python.

Vocabulaire essentiel

Terme Définition rapide
Bit Plus petite unité d'information (0 ou 1)
Octet Groupe de 8 bits
Binaire Base 2 (chiffres 0 et 1)
Hexadécimal Base 16 (chiffres 0-9 et A-F)
Complément à 2 Méthode de codage des entiers négatifs
Overflow Dépassement de capacité (le résultat sort de l'intervalle)
Flottant Nombre à virgule codé en signe + mantisse + exposant
Booléen Type à deux valeurs : True / False
Table de vérité Tableau listant toutes les combinaisons d'une expression
Évaluation paresseuse Python s'arrête dès que le résultat est déterminé
XOR Ou exclusif (vrai si exactement un des deux est vrai)
ASCII Encodage 7 bits, 128 caractères, anglais uniquement
UTF-8 Encodage Unicode à taille variable, standard mondial
Point de code Numéro Unicode d'un caractère (ex. U+00E9 pour é)