Langages et programmation 3 / Les types de données en Python

En Python, comme dans la plupart des langages de programmation, les expressions sont classées en fonction de leur type :

• Les expressions, comme $1 + 2$, dont la valeur est un nombre entier, comme $3$, sont de type int (integer : nombre entier),
  
• Celles comme $1.5 + 3,14$, dont la valeur est un nombre à virgule, sont de type float, (floating point number : nombre en notation scientifique),
  
• Celles comme $0 < 1$, dont la valeur est un booléen, False (faux) ou True (vrai), sont de type boolean, dans les langages de programmation, on écrit en général les booléens False et True et non 0 et 1 pour éviter les confusions avec les nombres,
• Celles, comme $\text{"Bon" + "jour"}$, dont la valeur est une chaîne de caractères, comme $\text{"Bonjour"}$, sont de type $\text{str}$.
  

Une valeur de type int est exprimée sur un nombre de bits arbitraires. 

Les valeurs de type float sont exprimées sur $\text{64 bits}$ : $\text{1 bit}$ de signe, $\text{11 bits}$ d’exposant, $\text{52 bits}$ de mantisse.

Un booléen est simplement exprimé avec un bit : True est une autre notation pour le bit $1$, et False une autre notation pour le bit $0$. 

Dans une valeur de type str, chaque caractère est exprimé en Unicode.

Donner un type à chaque expression a plusieurs avantages : d’une part, cela permet de préciser la manière dont les données doivent être exprimées, puisque le nombre entier $1$ et le nombre à virgule $1,0$ sont exprimés d’une manière très différente.

D’autre part, les types permettent d’éviter un certain nombre d’erreurs : par exemple l’expression $\text{"Bonjour" + 1}$ contient une erreur puisqu'il est impossible d’ajouter une chaîne de caractères et un nombre entier. 

On peut changer le type d’une expression en la préfixant par le nom d’un type, par exemple, si la valeur de l’expression e est le nombre entier $64$, alors celle de l’expression str(e) est la chaîne de caractères $"64"$. Si la valeur de l’expression e est le nombre à virgule $3,14$, alors celle de l’expression int(e) est le nombre entier $3$.

Nous avons écrit des programmes qui utilisent les types $\text{int}$, $\text{float}$, et $\text{boolean}$.

Dans de nombreuses situations, on a besoin d’utiliser des valeurs qui, comme les textes, les images ou les sons, sont formées de plusieurs nombres ou de plusieurs booléens. 

Ces valeurs sont dites de type composite. 

Le type $\text{str}$ est un type composite puisqu'une chaîne est formée de plusieurs caractères. Il existe d'autres types composites : les listes.

Si on veut utiliser une boîte qui contient les dix premiers nombres entiers, par on utilise une variable $\rm t$ que l’on affectera avec une liste.

Toutefois le fait d’utiliser une telle variable crée dans l’état non une grande boîte à dix cases comme celle-ci, mais une petite boîte, qui a une unique case.

Par exemple l’affectation : $\text{t = [i for i in range(0,10)]}$ produit l’état :

Pour la liste $\rm t$ à $10$ cases, si e est une expression dont la valeur est un nombre entier $\rm p$ compris entre $0$ et $9$ et $\text{e'}$ une expression, alors l’exécution de l’instruction $\text{t[e] = e'}$ a pour effet de remplir la case numéro $\rm p$ de cette liste avec la valeur de l’expression $\rm e'$.

Exemple : exécuter l’instruction $\text{t[1] = 14}$ pour la liste précédente produit l’état :

Pour afficher les $10$ éléments de la liste $\rm t$, on peut utiliser la boucle for suivante :

$\textit{for i in range(10):}\\
\qquad \textit{print(t[i])}$

Les trois constructions qu’il est nécessaire de maîtriser pour utiliser les listes sont donc :

• Allocation d’une liste $\text{[e for i in range(0,e')]}$, par exemple $\text{[0 for i in range(0,10)]}$,
  
• L’affectation d’une case d’une liste $\text{t[e] = e'}$, par exemple $\text{t[2] = 5}$,
  
• L’accès à une case d’une liste $\text{t[e]}$, par exemple $\text{t[2]}$.
  

Pour représenter une table à double entrée, par exemple la table suivante :

\[\begin{array}{|c|c|c|}
\hline
1 & 3 & 5\\
\hline
7 & 9 & 11\\
\hline
13 & 15 & 17\\
\hline
\end{array}\]

On peut utiliser une liste de trois éléments dont chaque élément est la représentation d’une colonne, c’est-à-dire elle-même une liste de trois nombres.

On peut allouer cette liste comme cela : $\rm t = [[0\text{ for j in range(0,3)] for i in range(0,3)]}$.

Puis affecter, chaque élément comme suit :

$\text{t[0][0] = 1}$
$\text{t[0][1] = 3}$
$\text{t[0][2] = 5}$
$\text{t[1][0] = 7}$
$\text{t[1][1] = 9}$
$\text{t[1][2] = 11}$
$\text{t[2][0] = 13}$
$\text{t[2][1] = 15}$
$\text{t[2][2] = 17}$

On aurait pu également affecter les éléments de la liste, a l'aide de deux boucles imbriquées comme ceci :

$\textit{valeur = 1}\\
\textit{for in in range(3):}\\
\qquad \textit{for j range (3):}\\
\qquad \qquad \textit{t[i][j] = valeur}\\
\qquad \qquad \textit{valeur = valeur + 2}$

Une chaîne de caractères est formée de plusieurs valeurs simples que sont ses différents caractères : c'est donc un type composite.

Calculer avec des chaînes de caractères :

• Pour comparer des chaînes de caractères, on utilise les fonctions $==$ et $<=$ cette dernière relation comparant deux chaînes pour l’ordre alphabétique.
  
• On concatène deux chaînes de caractères avec l’opération $+$.
  
• La longueur d’une chaîne de caractères est obtenue avec la fonction $\rm len$.
  
• Si $\rm e$ est une expression dont la valeur est une chaîne de caractères $\rm s$ de longueur $\rm n$ et $\rm e'$ est une expression dont la valeur est un entier $\rm p$ compris entre $0$ et $\rm n - 1$, alors la valeur de l’expression $\rm e[e']$ est une chaîne de caractères formée d’un unique caractère qui est le $\rm p-ième$ élément de la chaîne $\rm s$.
  
• Pour extraire une sous-chaine d'une chaine de caractère ch, il suffit d'utiliser l'instruction $\rm ch[ind1:ind2]$.
  Si $\rm ind1 > ind2$, on extrait $\rm (ind2 – ind1)$ caractères de la chaine ch à partir du caractère en position $\rm ind1$.
  Exemple : Si $\rm ch = "Bonjour"$, alors $\rm print(ch[1:4])$ affiche la chaîne $\rm "onj"$.
  
• Pour modifier une chaîne existante, on en extrait les parties appropriées, et on reconstitue une nouvelle chaîne à l’aide de l’opération de concaténation.
  

Maintenant que nous avons introduit la notion de déclaration, nous pouvons construire un petit de langage de programmation qui contient :

• La déclaration de variables,
  
• L’affectation,
  
• La séquence,
  
• Le test,
  
• Les boucles for et while.

Ce langage de programmation, bien qu’il soit très petit, est complet, ce qui signifie que tous les programmes que l’on peut imaginer peuvent être exprimés dans ce langage.