Types construits

Les séquences en Python

Il est possible de mémoriser plusieurs valeurs dans une même structure, que l'on nomme une séquence.

Définition d'une séquence

De façon plus précise, une séquence est un ensemble fini et ordonné d'éléments indicés de 0 à n - 1 (si cette séquence comporte n éléments).

Types de séquences en Python

En Python, il existe principalement 2 types de séquences : les tuples et les listes.

Les tuples en programmation

Définition et structure

Le tuple est délimité par des parenthèses et les différents éléments le constituant sont séparés par des virgules.

$\rm mon\_tuple = (2,4,8,16)$

Indexation des éléments

Chaque élément du tuple possède un indice qui commence à 0 :

• Le premier élément du $\rm tuple$ (l'entier $2$) possède l'indice $0$.
• Le deuxième élément du $\rm tuple$ (l'entier $4$) possède l'indice $1$.
• Le troisième élément du $\rm tuple$ (l'entier $8$) possède l'indice $2$.
• Le quatrième élément du $\rm tuple$ (l'entier $16$) possède l'indice $3$.

Accès aux éléments

Pour accéder à l'élément d'indice $1$ (ici l'entier $4$), on écrit : $\rm mon\_tuple[1]$.

L'instruction $\rm print(mon\_tuple[2])$ affichera $8$.

Propriété d'immutabilité

Il n'est pas possible de modifier un tuple après sa création (on parle d'objet "immutable").

Les listes en programmation

Les listes sont des séquences modifiables (on parle d'objets "mutables").

Définition et structure d'une liste

$\rm ma\_liste = ["noir","blanc","rouge","vert"]$.

Les listes sont délimitées par des crochets.

Modification d'éléments

On peut modifier un élément de la liste à partir de son indice :

$\rm ma\_liste[2] = "orange"$

L'instruction $\rm print(ma\_liste)$ affichera :

$\rm ["noir","blanc","orange","vert"]$.

Ajout d'éléments avec append()

On peut ajouter un élément en fin de liste avec la méthode append().

$\rm ma\_liste = ["noir","blanc","orange","vert"]$
$\rm ma\_liste.append("bleu")$.

L'instruction $\rm print(ma\_liste)$ affichera :

$\rm ["noir","blanc","orange","vert","bleu"]$.

Suppression d'éléments

Suppression par indice avec del

On peut supprimer un élément de la liste à partir de son indice avec la méthode del :

$\rm ma\_liste = ["noir","blanc","orange","vert","bleu"]$
$\rm del\ ma\_liste[0]$

L'instruction $\rm print(ma\_liste)$ affichera :

$\rm ["blanc","orange","vert","bleu"]$.

Suppression par valeur avec remove()

On peut aussi supprimer un élément de la liste à partir de sa valeur avec la déclaration remove().

$\rm ma\_liste = ["blanc","orange","vert","bleu"]$
$\rm ma\_liste.remove("vert")$

L'instruction $\rm print(ma\_liste)$ affichera :

$\rm ["blanc","orange","bleu"]$.

Si la liste contient plusieurs fois la même valeur, l'instruction remove() ne supprimera que le premier élément de la liste ayant la valeur passée en paramètre de la méthode remove().

Longueur d'une liste avec len()

Pour connaître la longueur d'une liste (c'est-à-dire son nombre d'éléments) on utilise la méthode len().

Si $\rm ma\_liste = ["blanc","orange","bleu"]$.
Alors $\rm print(len(ma\_liste))$ affichera $3$.

Parcourir les éléments d'une liste avec une boucle for

Pour parcourir les éléments d'une liste on peut utiliser une boucle for. On peut le faire de deux manières différentes.

1ère manière

Cette méthode utilise un compteur pour accéder aux éléments par leur index 

L'exécution de ce programme affichera 

0 noir
1 blanc
2 orange

2e manière de procéder

On peut de manière plus simple ne pas utiliser de compteur dans la boucle for. Cette approche permet d'accéder directement aux valeurs des éléments 

Affichera 

noir
blanc
orange

Création de listes en Python

Pour créer la liste des carrés des entiers de $1$ à $100$, on peut procéder de plusieurs manières :

Méthodes de création

1. À l'aide de la méthode append() décrite plus haut :
   $\text{liste_carres = []}$      # on crée une liste vide (sans élément)
   $\text{for i in range(101):}$
   $\text{liste_carres.append(i*i)}$
2. Création en une seule ligne de code :
   $\text{Liste_carres = [i*i for i in range(101)]}$
   Cette deuxième façon de procéder se nomme créer une liste par compréhension.

Listes de listes en Python

L'élément d'une liste peut lui-même être une liste.

$\rm ma\_matrice$ $\rm = [[1,False],[2,True],[3,True]$ $\rm ,[4,False],[5,False],[6,True],[7,True]]$

Le premier élément de cette liste $\rm ma\_matrice[0]$ est la liste $\rm [1,False]$.

Représentation matricielle

On peut représenter cette liste de listes sous la forme d'une matrice :

$\rm ma\_matrice =$
$\rm [[1,False],$
$\rm [2,True],$
$\rm [3,True],$
$\rm [4,False],$
$\rm [5,False],$
$\rm [6,True],$
$\rm [7,True]]$

Accès aux éléments

On accède à l'élément de la ligne $\rm l$ et de la colonne $\rm c$ ainsi : $\rm ma\_matrice[l][c]$.

Par exemple, $\rm print(ma\_matrice[2][0])$ affichera $3$.

Dans cet exemple, $\rm ma\_matrice$ contient la liste des entiers de $1$ à $7$ et le deuxième élément de chaque liste de ligne est un booléen qui indique si l'élément en première position est un entier premier ou non.

Les dictionnaires en Python

Les dictionnaires permettent de "stocker" des données à l'aide de paires "clé/valeur".

Structure d'un dictionnaire

Voici un exemple de dictionnaire :

$$\text{mon_film = \{"nom": "Star Wars",}$$ $$\text{"realisateur": "Georges Lucas",}$$ $$\text{"genre": "Science-fiction","annee": 1977\}}$$

Un dictionnaire est délimité par des accolades. Les paires clé/valeur sont saisies sous la forme clé:valeur. Et comme pour les listes, les différentes paires clé/valeur sont séparées par une virgule.

Création d'un dictionnaire vide

On peut aussi un créer un dictionnaire à partir de "rien" en saisissant les paires clé/valeur une par une.

$$\text{mon_film =\{\}}$$ $$\text{mon_film["nom"] = "Star Wars"}$$ $$\text{mon_film["realisateur"] = "Georges Lucas"}$$ $$\text{mon_film["genre"] = "Science fiction"}$$

Parcours d'un dictionnaire

Il est possible de parcourir un dictionnaire selon les clés ou les valeurs. Le parcours selon les clés se fait à l'aide de la méthode keys().

Parcours selon les clés

Le programme :

$$\text{mon_film = \{"nom": "Star Wars",}$$ $$\text{"realisateur": "Georges Lucas",}$$ $$\text{"genre": "Science-fiction","annee": 1977\}}$$ $$\text{for cle in mon_film.key():}$$ $$\qquad\text{print(cle)}$$

Affichera :
nom
realisateur
genre
annee

Parcours selon les valeurs

Le parcours selon les valeurs se fait avec la méthode values()

Le programme :

$$\text{mon_film = \{"nom": "Star Wars",}$$ $$\text{"realisateur": "Georges Lucas",}$$ $$\text{"genre": "Science-fiction","annee": 1977\}}$$ $$\text{for cle in mon_film.values():}$$ $$\qquad\text{print(cle)}$$

Affichera :
Star Wars
George Lucas
Science fiction
1977

Parcours des paires clé/valeur

Enfin, on peut aussi parcourir un dictionnaire en récupérant simultanément les paires clé/valeur à l'aide de la méthode items().

Le programme :

$$\text{mon_film = \{"nom": "Star Wars",}$$ $$\text{"realisateur": "Georges Lucas",}$$ $$\text{"genre": "Science-fiction","annee": 1977\}}$$ $$\text{for cle,val in mon_film.items():}$$ $$\qquad\text{print(cle,":",val)}$$

Affichera :
nom : Star Wars
realisateur : George Lucas
genre : Science fiction
annee : 1977