Les types de données en Python

Les types d'expressions en Python

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

Les différents types d'expressions

Type int (integer)

Les expressions, comme $1 + 2$, dont la valeur est un nombre entier, comme $3$, sont de type int (integer : nombre entier). Une valeur de type int est exprimée sur un nombre de bits arbitraires.

Type float (floating point number)

Celles comme $1.5 + 3,14$, dont la valeur est un nombre à virgule, sont de type float (floating point number : nombre en notation scientifique). Les valeurs de type float sont exprimées sur $64 \text{ bits}$ : $1 \text{ bit}$ de signe, $11 \text{ bits}$ d'exposant, $52 \text{ bits}$ de mantisse.

Type boolean

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. 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$.

Type str (string)

Celles, comme $\text{"Bon" + "jour"}$, dont la valeur est une chaîne de caractères, comme $\text{"Bonjour"}$, sont de type str. Dans une valeur de type str, chaque caractère est exprimé en Unicode.

Avantages du typage

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.

Conversion de types

On peut changer le type d'une expression en la préfixant par le nom d'un type.

• 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$

Les types composites et les listes

Introduction aux types composites

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.

Utilisation des 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 :

Modification des éléments d'une liste

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'$.

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

Affichage des éléments d'une liste

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])}$

Constructions essentielles pour les listes

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]}$

Représentation d'une table à double entrée

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}$$

Structure de données

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.

Allocation de la liste

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

Affectation manuelle des éléments

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}$

Affectation avec boucles imbriquées

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

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

Les chaînes de caractères

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

Comparaison des chaînes

Pour comparer des chaînes de caractères, on utilise les fonctions $==$ et $\leq$ cette dernière relation comparant deux chaînes pour l'ordre alphabétique.

Concaténation

On concatène deux chaînes de caractères avec l'opération $+$.

Longueur d'une chaîne

La longueur d'une chaîne de caractères est obtenue avec la fonction $\rm len$.

Accès à un caractère

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$.

Extraction de sous-chaînes

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$.

Si $\rm ch = "Bonjour"$, alors $\rm print(ch[1:4])$ affiche la chaîne $\rm "onj"$.

Modification d'une chaîne

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.

Construction d'un langage de programmation complet

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

Composants du langage

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

Complétude du langage

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.