Types construits

Il est possible de mémoriser plusieurs valeurs dans une même structure, que l'on nomme 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). 

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

Exemple de tuple : $\rm mon$_$\rm tuple = (2,4,8,16)$

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

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

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

Exemple :

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

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

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

Exemple de liste :

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

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

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

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

L'instruction $\color{black}{\textbf{print(ma_liste)}}$ affichera :

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

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

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

L'instruction $\color{black}{\textbf{print(ma_liste)}}$ affichera :

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

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

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

L'instruction $\color{black}{\textbf{print(ma_liste)}}$ affichera :

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

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

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

L'instruction $\color{black}{\textbf{print(ma_liste)}}$ affichera :

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

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

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

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

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 :

$\color{blue}{\text{ma_liste : ["noir,"blanc","orange"]}\\
\text{for i in range(len(la_liste)):}\\
\qquad\text{print(i,ma_liste[i])}}$

L'exécution de ce programme affichera :
0 noir
1 blanc
2 orange

2$^e$ manière de procéder :

On peut de manière plus simple ne pas utiliser de compteur dans la boucle $\rm for$ :

$\color{blue}{\text{ma_liste : ["noir,"blanc","orange"]}\\
\text{for c in ma_liste:}\\
\qquad\text{print(c)}}$

Affichera :
noir
blanc
orange

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

1. A l'aide de la méthode $\rm 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. On peut aussi créer cette liste 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.

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

Exemple :

$\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$_$\rm matrice[0]$ est la liste $\rm [1,False]$.

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

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

Remarque : 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 permettent de "stocker" des données à l'aide de paires "clé/valeur". 

Voici un exemple de dictionnaire :

$\color{blue}{\text{mon_film = \{"nom": "Star Wars",}}$
$\color{blue}{\text{"realisateur": "Georges Lucas",}}$
$\color{blue}{\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.

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

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

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().

Exemple :

Le programme :

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

Affichera :
nom
realisateur
genre
annee

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

Exemple :

Le programme :

$\color{blue}{\text{mon_film = \{"nom": "Star Wars",}}$
$\color{blue}{\text{"realisateur": "Georges Lucas",}}$
$\color{blue}{\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

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

Exemple :

Le programme :

$\color{blue}{\text{mon_film = \{"nom": "Star Wars",}}$
$\color{blue}{\text{"realisateur": "Georges Lucas",}}$
$\color{blue}{\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