Représentation des données : types et valeurs de base

En informatique, une donnée est une information élémentaire, brute, qui peut être traitée par une machine. C'est la matière première sur laquelle les ordinateurs opèrent.

Une donnée est une représentation codée d'une information.

• Information vs. Donnée :

  • Une information est le sens que l'on donne à des données. C'est la connaissance ou le renseignement obtenu après traitement et interprétation des données.
  • Une donnée est la forme codée et structurée de cette information, prête à être manipulée.

  Exemple :

  • L'information "Il fait 25 degrés Celsius"
  • Peut être représentée par la donnée numérique 25.0 (un nombre flottant) ou le texte "25°C" (une chaîne de caractères).

• Exemples de données :

  • Un nombre (entier, décimal) : 15, 3.14
  • Un caractère : 'A', 'z', '€'
  • Un texte : "Bonjour le monde"
  • Une image : une suite de pixels, chacun représenté par des valeurs numériques
  • Un son : une suite d'échantillons numériques
  • Une valeur booléenne : Vrai (True) ou Faux (False)

Les ordinateurs ne "comprennent" pas directement nos langues humaines ou nos concepts abstraits. Ils fonctionnent avec des signaux électriques qui sont interprétés comme des 0 et des 1 (système binaire). La représentation des données est donc essentielle pour plusieurs raisons :

• Traitement par machine : Pour qu'un ordinateur puisse stocker, manipuler et traiter une information, celle-ci doit être encodée sous une forme qu'il peut comprendre, c'est-à-dire une séquence de bits.
• Standardisation : Des conventions de représentation communes (comme ASCII, Unicode, IEEE 754) permettent à différents systèmes informatiques de communiquer et d'échanger des données de manière cohérente. Sans standard, un fichier créé sur un ordinateur pourrait être illisible sur un autre.
• Interprétation : La manière dont une suite de 0 et de 1 est interprétée dépend de son type. Par exemple, la suite binaire 01000001 peut représenter le nombre décimal 65, ou la lettre 'A' en code ASCII. Le programmeur doit spécifier le type de la donnée pour que l'ordinateur sache comment l'utiliser.

La représentation des données peut être vue à différents niveaux d'abstraction, du plus proche de la machine au plus proche de l'utilisateur :

• Niveau Physique : C'est le niveau le plus bas. Les données sont représentées par des phénomènes physiques (tensions électriques, états magnétiques, impulsions lumineuses). C'est là que l'on trouve les bits (0 ou 1). On ne manipule pas directement ce niveau en programmation.

  • Exemple : Un transistor ouvert ou fermé, une zone du disque magnétisée ou non.

• Niveau Logique : C'est le niveau où l'on regroupe les bits en unités plus grandes (octets, mots) et où on leur attribue une signification en fonction de leur type de données. C'est le niveau où le programmeur commence à interagir avec les données.

  • Exemple : La suite de bits 01000001 est interprétée comme le caractère 'A' (type caractère) ou le nombre 65 (type entier). Les entiers, flottants, caractères, booléens sont des types logiques.

• Niveau Conceptuel (ou sémantique) : C'est le niveau le plus abstrait, où les données sont vues en fonction de leur signification dans le monde réel et de la manière dont elles sont structurées pour représenter des concepts complexes.

  • Exemple : Un "client" est un concept, représenté par une structure de données contenant un nom (chaîne de caractères), un âge (entier), une adresse (chaîne de caractères), etc. C'est le niveau des bases de données et des modèles objet.

Les ordinateurs utilisent le système binaire, ou base 2, car il est facile à implémenter physiquement avec des composants électroniques qui peuvent être dans deux états (passant/bloquant, tension/pas de tension).

• Bits et octets :

  • Un bit (binary digit) est l'unité d'information la plus petite, représentant un 0 ou un 1.
  • Un octet (byte) est un groupe de 8 bits. C'est l'unité de base pour adresser la mémoire et stocker des caractères.
  • Autres unités :
    • 1 Ko (Kilo-octet) = $2^{10}$ octets = 1024 octets
    • 1 Mo (Méga-octet) = $2^{20}$ octets = 1024 Ko
    • 1 Go (Giga-octet) = $2^{30}$ octets = 1024 Mo
    • 1 To (Téra-octet) = $2^{40}$ octets = 1024 Go

• Conversion décimal-binaire : Pour convertir un nombre décimal en binaire, on utilise la méthode des divisions successives par 2, en notant les restes. Les bits du nombre binaire sont les restes, lus de bas en haut.

  Exemple : Convertir 13 en binaire

  13 / 2 = 6 reste 1
  6  / 2 = 3 reste 0
  3  / 2 = 1 reste 1
  1  / 2 = 0 reste 1
  

  On lit les restes de bas en haut : $13_{10} = 1101_2$.

• Conversion binaire-décimal : Pour convertir un nombre binaire en décimal, on multiplie chaque bit par une puissance de 2, en commençant par $2^0$ pour le bit le plus à droite, et en augmentant la puissance de 1 pour chaque bit vers la gauche.

  Exemple : Convertir $1101_2$ en décimal $1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0$ $= 1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1$ $= 8 + 4 + 0 + 1 = 13_{10}$

Les entiers positifs (ou naturels) sont représentés directement en binaire.

• Nombre de bits : Le nombre de bits utilisé pour stocker un entier détermine la plage de valeurs qu'il peut prendre.

  • Avec $n$ bits, on peut représenter $2^n$ valeurs différentes.
  • Pour les entiers positifs, la plage va de 0 à $2^n - 1$.

• Plage de valeurs :

  • Avec 1 octet (8 bits) : de $0$ à $2^8 - 1 = 255$.
  • Avec 2 octets (16 bits) : de $0$ à $2^{16} - 1 = 65535$.
  • Avec 4 octets (32 bits) : de $0$ à $2^{32} - 1 \approx 4 \times 10^9$.

• Débordement (overflow) : Si le résultat d'une opération dépasse la capacité de stockage allouée (le nombre maximum représentable avec $n$ bits), on parle de débordement. L'ordinateur ne peut pas représenter correctement le résultat.

  • Exemple : Avec 8 bits, si on ajoute $200 + 100 = 300$. Or $300 > 255$. L'ordinateur va tronquer le résultat, ce qui peut mener à des erreurs inattendues (souvent un nombre très petit ou négatif si le type gère les signes).

Pour représenter les nombres entiers qui peuvent être positifs ou négatifs, plusieurs méthodes existent, mais la plus couramment utilisée est le complément à deux.

• Bit de signe (méthode simple mais peu utilisée) : Le bit le plus à gauche (le bit de poids fort) est réservé pour le signe : 0 pour positif, 1 pour négatif. Les $n-1$ bits restants représentent la valeur absolue du nombre.

  • Problèmes : Deux représentations pour zéro (+0 et -0), arithmétique complexe.

• Complément à deux : C'est la méthode standard pour représenter les entiers relatifs.

  • Pour un nombre positif, la représentation est la même que pour un entier positif.
  • Pour un nombre négatif $-X$ sur $n$ bits :
    1. Représenter $X$ en binaire sur $n$ bits.
    2. Inverser tous les bits (les 0 deviennent 1, les 1 deviennent 0) : c'est le complément à un.
    3. Ajouter 1 au résultat.

  Exemple : Représenter $-5$ sur 8 bits

  1. $5_{10} = 00000101_2$
  2. Complément à un : $11111010_2$
  3. Ajouter 1 : $11111010_2 + 1_2 = 11111011_2$ Donc, $-5_{10} = 11111011_2$ en complément à deux sur 8 bits.

• Avantages du complément à deux :

  • Une seule représentation pour le zéro.
  • Les opérations arithmétiques (notamment l'addition) fonctionnent de la même manière pour les nombres positifs et négatifs, ce qui simplifie la conception des circuits.
  • Avec $n$ bits, la plage de valeurs est de $-2^{n-1}$ à $2^{n-1} - 1$.
    • Sur 8 bits : de $-128$ à $127$.
    • Sur 16 bits : de $-32768$ à $32767$.

Les opérations arithmétiques en binaire suivent des règles similaires à celles du décimal.

• Addition binaire : Les règles de base :

  • $0 + 0 = 0$
  • $0 + 1 = 1$
  • $1 + 0 = 1$
  • $1 + 1 = 0$ (avec une retenue de 1)
  • $1 + 1 + 1 = 1$ (avec une retenue de 1)

  Exemple : $5 + 3 = 8$

    0101  (5)
  + 0011  (3)
  ------
    1000  (8)
  

• Soustraction binaire : La soustraction est généralement implémentée en utilisant l'addition avec le complément à deux du nombre à soustraire. $A - B = A + (-B)$ où $-B$ est la représentation en complément à deux de $B$.

  Exemple : $5 - 3 = 2$ sur 8 bits

  1. $5 = 00000101_2$
  2. $-3$ en complément à deux : $3 = 00000011_2$. Complément à un : $11111100_2$. Ajouter 1 : $11111101_2$.
  3. Addition :

       00000101  (5)
     + 11111101  (-3)
     ----------
     1 00000010  (report ignoré)
     

     Le résultat est $00000010_2 = 2_{10}$. Le 1 en position la plus à gauche est un report qui est ignoré pour cet exemple (indique que le résultat est positif et qu'il n'y a pas eu de débordement).

• Multiplication binaire : Similaire à la multiplication décimale, mais avec des additions binaires.

  Exemple : $5 \times 3 = 15$

    0101  (5)
  x 0011  (3)
  ------
    0101  (0101 x 1)
   01010  (0101 x 1 décalé)
  ------
   01111  (15)
  

Les nombres flottants (ou nombres à virgule flottante) sont utilisés pour représenter des nombres réels, c'est-à-dire des nombres qui peuvent avoir une partie décimale.

• Nombres à virgule : Contrairement aux entiers, qui sont des nombres discrets, les nombres réels sont continus. Les ordinateurs ne peuvent pas représenter tous les nombres réels de manière exacte.
• Limites de la représentation exacte : Comme pour $\pi$ ou $\frac{1}{3}$, certains nombres réels ont une infinité de chiffres après la virgule. Un ordinateur n'a qu'un espace mémoire limité, il ne peut donc stocker qu'une approximation de ces nombres.
• Précision : La précision d'un nombre flottant indique le nombre de chiffres significatifs qu'il peut représenter. Plus de bits sont alloués, plus la précision est grande.

Pour gérer la grande plage de valeurs possibles des nombres réels (très petits ou très grands), les nombres flottants sont représentés en interne par une forme de notation scientifique binaire.

Un nombre $N$ est représenté sous la forme : $N = \text{signe} \times \text{mantisse} \times \text{base}^{\text{exposant}}$

• Signe : Un bit pour indiquer si le nombre est positif (0) ou négatif (1).
• Mantisse (ou significande) : Représente les chiffres significatifs du nombre. C'est une fraction binaire.
• Exposant : Indique la position de la virgule (ou point binaire). Il est souvent décalé (biaisé) pour permettre de représenter aussi bien de très petits que de très grands nombres.
• Base : En informatique, la base est généralement 2.

Exemple décimal : $123.45 = 1.2345 \times 10^2$

• Signe : positif
• Mantisse : $1.2345$
• Exposant : $2$
• Base : $10$

Le standard IEEE 754 est la norme la plus répandue pour la représentation des nombres flottants dans les ordinateurs. Il définit précisément comment les bits sont alloués au signe, à l'exposant et à la mantisse. Cela assure la portabilité des calculs flottants entre différentes machines.

Deux formats principaux :

• Simple précision (32 bits) :

  • 1 bit pour le signe.
  • 8 bits pour l'exposant (décalé).
  • 23 bits pour la mantisse (mais représente 24 bits significatifs grâce à un bit implicite).
  • Plage de valeurs : environ $\pm 1.18 \times 10^{-38}$ à $\pm 3.4 \times 10^{38}$.
  • Précision : environ 6-7 chiffres décimaux significatifs.

• Double précision (64 bits) :

  • 1 bit pour le signe.
  • 11 bits pour l'exposant (décalé).
  • 52 bits pour la mantisse (représente 53 bits significatifs).
  • Plage de valeurs : environ $\pm 2.23 \times 10^{-308}$ à $\pm 1.8 \times 10^{308}$.
  • Précision : environ 15-17 chiffres décimaux significatifs.

• Erreurs d'arrondi : En raison de la représentation limitée en bits, les nombres flottants ne sont que des approximations. Cela peut entraîner des erreurs d'arrondi lors des calculs.

  • Exemple : $0.1 + 0.2$ n'est pas toujours exactement $0.3$ en flottant. C'est une source fréquente de bugs en programmation.
  • Il ne faut jamais comparer des nombres flottants pour l'égalité exacte ($</mark>$)==, mais plutôt vérifier si leur différence est inférieure à une petite tolérance ($\epsilon$).

Le type booléen est l'un des types de données les plus fondamentaux en informatique. Il représente une valeur logique qui peut être soit vraie, soit fausse.

• Vrai (True) et Faux (False) : Ces deux valeurs sont les seules possibles pour un booléen. En interne, True est souvent représenté par 1 et False par 0.

• Opérateurs logiques : Les booléens sont manipulés par des opérateurs logiques :

  • ET (AND) : Vrai si les deux opérandes sont Vrai. (Ex: A AND B)
  • OU (OR) : Vrai si au moins un des opérandes est Vrai. (Ex: A OR B)
  • NON (NOT) : Inverse la valeur de l'opérande. (Ex: NOT A)
  • D'autres opérateurs comme XOR (OU Exclusif) existent.

  Table de vérité (exemple avec ET) :

  A	B	A ET B
  Faux	Faux	Faux
  Faux	Vrai	Faux
  Vrai	Faux	Faux
  Vrai	Vrai	Vrai

• Applications en programmation : Les booléens sont utilisés partout en programmation pour contrôler le flux d'exécution :

  • Conditions (if, else if, else) : if (age >= 18) { ... }
  • Boucles (while, for) : while (condition_est_vraie) { ... }
  • Indicateurs d'état : est_connecte = True, fichier_ouvert = False

Les caractères (lettres, chiffres, symboles) sont également stockés sous forme numérique dans un ordinateur. Chaque caractère est associé à un code numérique.

• Code ASCII (American Standard Code for Information Interchange) :

  • C'est le premier standard largement adopté.
  • Il utilise 7 bits pour représenter 128 caractères (de 0 à 127).
  • Il inclut les lettres majuscules et minuscules de l'alphabet latin, les chiffres, les symboles de ponctuation et des caractères de contrôle (retour chariot, tabulation, etc.).
  • Exemple : Le caractère 'A' a le code ASCII $65_{10}$ ($01000001_2$), 'a' a $97_{10}$, '0' a $48_{10}$.

• Table de caractères (ou jeu de caractères) : C'est l'ensemble des caractères qu'un système peut représenter, avec leur code numérique associé. ASCII est une table de caractères.

• Unicode et UTF-8 :

  • ASCII était insuffisant pour représenter toutes les langues du monde (alphabets cyrillique, arabe, chinois, etc.).
  • Unicode est un standard qui vise à attribuer un numéro unique à chaque caractère de chaque langue. Il peut représenter plus d'un million de caractères. Les codes Unicode sont appelés "points de code".
  • UTF-8 (Unicode Transformation Format - 8-bit) est l'encodage le plus courant pour Unicode. C'est un encodage à largeur variable :
    • Les caractères ASCII sont encodés sur 1 octet (compatible avec ASCII).
    • Les autres caractères sont encodés sur 2, 3 ou 4 octets.
  • UTF-8 est omniprésent sur le web et dans les systèmes d'exploitation modernes car il est efficace et gère toutes les langues.

Une chaîne de caractères (string) est une séquence ordonnée de caractères. C'est un type de données très courant pour représenter du texte.

• Séquence de caractères : Une chaîne est comme une liste de caractères.
  • Exemple : La chaîne "Hello" est une séquence des caractères 'H', 'e', 'l', 'l', 'o'.
• Terminaison de chaîne (en C/C++) : Historiquement, dans certains langages comme le C, les chaînes sont terminées par un caractère spécial appelé le "caractère nul" (\0), dont la valeur ASCII est 0. Cela permet de savoir où la chaîne se termine en mémoire. Dans des langages plus modernes (Python, Java), la longueur de la chaîne est stockée séparément, ce qui évite ce caractère de terminaison.
• Opérations sur les chaînes :
  • Concaténation : Joindre deux chaînes bout à bout. (Ex: "Hello" + " World" donne "Hello World")
  • Longueur : Obtenir le nombre de caractères dans la chaîne.
  • Accès par index : Accéder à un caractère spécifique par sa position (index). (Ex: "Hello"[0] donne 'H')
  • Extraction de sous-chaîne : Obtenir une partie de la chaîne.
  • Recherche : Trouver l'occurrence d'un caractère ou d'une autre chaîne.
  • Comparaison : Vérifier si deux chaînes sont identiques.

Jusqu'à présent, nous avons vu des types de données de base (entiers, flottants, booléens, caractères) qui représentent des informations élémentaires. Cependant, pour modéliser des entités plus complexes du monde réel, nous avons besoin de regrouper ces types de base.

Les types composés (ou types structurés) permettent d'agréger plusieurs données de types différents ou identiques pour former une entité plus complexe et cohérente.

• Agrégation de types simples : Ils combinent des données qui sont logiquement liées.
  • Exemple : Pour représenter une personne, on agrège un nom (chaîne), un âge (entier), une taille (flottant), etc.
• Structure de données : Un type composé est une forme simple de structure de données, qui est une manière d'organiser les données en mémoire pour un accès et une manipulation efficaces.
• Exemples : Les tableaux (listes), les n-uplets (tuples), les enregistrements (structures, objets), les dictionnaires, etc.

Un tableau (ou liste dans certains langages comme Python) est une collection ordonnée d'éléments.

• Collection ordonnée : Les éléments sont stockés dans un ordre spécifique et conservent cet ordre.
• Indexation : Chaque élément du tableau est accessible via un index (un nombre entier) qui représente sa position dans la collection. L'index du premier élément est généralement 0.
  • Exemple : tableau[0] accède au premier élément.
• Homogénéité des éléments (dans certains langages) : Traditionnellement, dans des langages comme C, C++, Java, tous les éléments d'un tableau doivent être du même type (par exemple, un tableau d'entiers, un tableau de caractères).
  • Exemple : int notes[5] déclare un tableau de 5 entiers.
• Hétérogénéité des éléments (dans d'autres langages) : En Python, une liste peut contenir des éléments de types différents (un entier, une chaîne, un flottant, etc.).
  • Exemple (Python) : ma_liste = [10, "Bonjour", 3.14, True]
• Taille fixe ou dynamique : Certains tableaux ont une taille fixe définie à la déclaration, d'autres (comme les listes Python) peuvent changer de taille dynamiquement.

Un n-uplet (ou tuple) est une collection ordonnée et immuable d'éléments.

• Collection ordonnée et immuable :

  • Comme les tableaux, les éléments sont ordonnés et accessibles par index.
  • La différence fondamentale est que, une fois créé, un n-uplet ne peut pas être modifié. On ne peut pas ajouter, supprimer ou changer ses éléments.
  • L'immuabilité garantit que le contenu du n-uplet reste constant, ce qui peut être utile pour des données qui ne devraient pas changer (coordonnées, dates, etc.) ou pour des clés dans certaines structures de données.

• Hétérogénéité des éléments : Les n-uplets peuvent contenir des éléments de types différents. C'est même leur usage courant, pour regrouper des données hétérogènes qui forment une seule entité logique.

  • Exemple (Python) : point = (10, 20) représente un point 2D. personne = ("Alice", 30, 1.75) représente les attributs d'une personne.

• Dépaquetage (unpacking) : On peut facilement assigner les éléments d'un n-uplet à des variables individuelles.

  • Exemple (Python) : x, y = point assignera 10 à x et 20 à y.

• Applications :

  • Retourner plusieurs valeurs d'une fonction.
  • Définir des coordonnées géographiques.
  • Utiliser comme clé dans des dictionnaires (car ils sont immuables).