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.
Le tuple est délimité par des parenthèses et les différents éléments le constituant sont séparés par des virgules.
Exemple de tuple$\rm mon\_tuple = (2,4,8,16)$
Chaque élément du tuple possède un indice qui commence à 0 :
Pour accéder à l'élément d'indice $1$ (ici l'entier $4$), on écrit : $\rm mon\_tuple[1]$.
ExempleL'instruction $\rm print(mon\_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").
$\rm ma\_liste = ["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 $\rm print(ma\_liste)$ affichera :
$\rm ["noir","blanc","orange","vert"]$.
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"]$.
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"]$.
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"]$.
RemarqueSi 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().
Pour connaître la longueur d'une liste (c'est-à-dire son nombre d'éléments) on utilise la méthode len().
ExempleSi $\rm ma\_liste = ["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.
Cette méthode utilise un compteur pour accéder aux éléments par leur index
$$\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
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
$$\text{ma_liste : ["noir","blanc","orange"]}\\ \text{for c in ma_liste:}\\ \qquad\text{print(c)}$$Affichera
noir
blanc
orange
Pour créer la liste des carrés des entiers de $1$ à $100$, on peut procéder de plusieurs manières :
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\_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$.
RemarqueDans 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 :
$$\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.
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"}$$
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().
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
Le parcours selon les valeurs se fait avec la méthode values()
ExempleLe 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
Enfin, on peut aussi parcourir un dictionnaire en récupérant simultanément les paires clé/valeur à l'aide de la méthode items().
ExempleLe 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
Représentation des données : types construits 1Représentation des données : types construits 2Représentation des données : types construits 3Représentation des données : types construits 4
