Les séquences en Python

Il est possible de "stocker" plusieurs grandeurs dans une même structure, ce type de structure est appelé une séquence. De façon plus précise, nous définirons une séquence comme un ensemble fini et ordonné d'éléments indicés de 0 à n-1 (si cette séquence comporte n éléments). Rassurez-vous, nous reviendrons ci-dessous sur cette définition. Nous allons étudier plus particulièrement 2 types de séquences : les tuples et les listes (il en existe d'autres que nous n'évoquerons pas ici).

Les tuples en Python

Comme déjà dit ci-dessus, un tuple est une séquence. Voici un exemple très simple :


mon_tuple = (5, 8, 6, 9)
		

Dans le code ci-dessus, la variable "mon_tuple" référence un tuple, ce tuple est constitué des entiers 5, 8, 6 et 9. Comme indiqué dans la définition, chaque élément du tuple est indicé (il possède un indice):

Comment accéder à l'élément d'indice i dans un tuple ?

Simplement en utilisant la "notation entre crochets" :

À faire vous-même 1

Testez le code suivant :


mon_tuple = (5, 8, 6, 9)
a = mon_tuple[2]
		

Quelle est la valeur référencée par la variable "a" (utilisez la console pour répondre à cette question)?

La variable "mon_tuple" référence le tuple (5, 8, 6, 9), la variable "a" référence l'entier 6 car cet entier 6 est bien le troisième élément du tuple, il possède donc l'indice 2


ATTENTION : dans les séquences les indices commencent toujours à 0 (le premier élément de la séquence a pour indice 0), oublier cette particularité est une source d'erreur "classique".

À faire vous-même 2

Complétez le code ci-dessous (en remplaçant les ..) afin qu'après l'exécution de ce programme la variable "a" référence l'entier 8.


mon_tuple = (5, 8, 6, 9)
a = mon_tuple[..]
		

Un tuple ne contient pas forcément des nombres entiers, il peut aussi contenir des nombres décimaux, des chaînes de caractères, des booléens...

À faire vous-même 3

Quel est le résultat attendu après l'exécution de ce programme ?

Vérifiez votre hypothèse en testant ce programme


mon_tuple = ("le", "monde", "bonjour")
print(mon_tuple[2] + " " + mon_tuple[0] + " " + mon_tuple[1] + "!")
		

Grâce au tuple, une fonction peut renvoyer plusieurs valeurs :

À faire vous-même 4

Analysez puis testez le code suivant :


def add(a, b):
	c = a + b
	return (a, b, c)
mon_tuple = add(5, 8)
print(f"{mon_tuple[0]} + {mon_tuple[1]} = {mon_tuplee[2]}")
		

Il faut bien comprendre dans l'exemple ci-dessus que la variable "mon_tuple" référence un tuple (puisque la fonction "add" renvoie un tuple), d'où la "notation entre crochets" utilisée avec "mon_tuple" (mon_tuple[1]...)


La console permet d'afficher les éléments présents dans un tuple simplement en :

À faire vous-même 5

Après avoir exécuté le programme ci-dessous, saisissez "mon_tuple" dans la console.


mon_tuple = (5, 8, 6, 9)
		

Les listes en Python

Il n'est pas possible de modifier un tuple après sa création (on parle d'objet "immutable"), si vous essayez de modifier un tuple existant, l'interpréteur Python vous renverra une erreur. Les listes sont,comme les tuples, des séquences, mais à la différence des tuples, elles sont modifiables (on parle d'objets "mutables").

Pour créer une liste, il existe différentes méthodes : une de ces méthodes ressemble beaucoup à la création d'un tuple :


ma_liste = [5, 8, 6, 9]
		

Notez la présence des crochets à la place des parenthèses.

Une liste est une séquence, il est donc possible de "récupérer" un élément d'une liste à l'aide de son indice (de la même manière que pour un tuple)

À faire vous-même 6

Quelle est la valeur référencée par la variable "ma_variable" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [5, 8, 6, 9]
ma_variable = ma_liste[2]
		

N.B. Il est possible de saisir directement "ma_liste[2]" dans la console sans passer par l'intermédiaire de la variable "ma_variable"


Il est possible de modifier une liste à l'aide de la "notation entre crochets" :

À faire vous-même 7

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [5, 8, 6, 9]
ma_liste[2] = 15
		

Comme vous pouvez le constater avec l'exemple ci-dessus, l'élément d'indice 2 (le nombre entier 6) a bien été remplacé par le nombre entier 15


Il est aussi possible d'ajouter un élément en fin de liste à l'aide de la méthode "append" :

À faire vous-même 8

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [5, 8, 6, 9]
ma_liste.append(15)
		

L'instruction "del" permet de supprimer un élément d'une liste en utilisant son index :

À faire vous-même 9

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [5, 8, 6, 9]
del ma_liste[1]
		

L'instruction "len" permet de connaitre le nombre d'éléments présent dans une liste (l'instruction "len" peut aussi être utilisée avec un tuple)

À faire vous-même 10

Quelle est la valeur référencée par la variable "nb_len" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [5, 8, 6, 9]
nb_ele = len(ma_liste)
		

Une petite parenthèse : on pourrait s'interroger sur l'intérêt d'utiliser un tuple puisque la liste permet plus de choses ! La réponse est simple : les opérations sur les tuples sont plus "rapides". Quand vous savez que votre liste ne sera pas modifiée, il est préférable d'utiliser un tuple à la place d'une liste.

la boucle "for" : parcourir les éléments d'une liste

La boucle "for...in" permet de parcourir l'ensemble des éléments d'une liste (ou d'un tuple) :

À faire vous-même 11

Analysez puis testez le code suivant :


ma_liste = [5, 8, 6, 9]
for element in ma_liste:
	print(element)
		

Quelques explications : comme son nom l'indique, la boucle "for" est une boucle ! Nous "sortirons" de la boucle une fois que tous les éléments de la liste "ma_liste" auront été parcourus. "element" est une variable qui va :

Une chose importante à bien comprendre : le choix du nom de la variable qui va référencer les éléments de la liste les uns après les autres ("element") est totalement arbitraire, il est possible de choisir un autre nom sans aucun problème, le code suivant aurait donné exactement le même résultat :


ma_liste = [5, 8, 6, 9]
for toto in ma_liste:
	print (toto)
		

Dans la boucle "for..in" il est possible d'utiliser la méthode "range" à la place d'une liste :

À faire vous-même 12

Analysez puis testez le code suivant :


for element in range(0, 5):
	print (element)
		

Comme vous pouvez le constater, "range(0,5)" est, au niveau de la boucle "for..in", équivalent à la liste [0,1,2,3,4], le code ci-dessous donnerait le même résultat que le programme vu dans le "À faire vous-même 12" :


ma_liste = [0, 1, 2, 3, 4]
for element in ma_liste:
	print (element)
		

ATTENTION : si vous avez dans un programme "range(a,b)", a est la borne inférieure et b a borne supérieure. Vous ne devez surtout pas perdre de vu que la borne inférieure est incluse, mais que la borne supérieure est exclue.

Il est possible d'utiliser la méthode "range" pour "remplir" une liste :

À faire vous-même 13

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = []
for element in range(0, 5):
	ma_liste.append(element)
		

Créer une liste par compréhension

Nous avons vu qu'il était possible de "remplir" une liste en renseignant les éléments de la liste les uns après les autres :


ma_liste = [5, 8, 6, 9]
		

ou encore à l'aide de la méthode "append" (voir "À faire vous-même 13").

Il est aussi possible d'obtenir exactement le même résultat qu'au "À faire vous-même 13" en une seule ligne grâce à la compréhension de liste :

À faire vous-même 14

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


ma_liste = [p for p in range(0, 5)]
		

Les compréhensions de liste permettent de rajouter une condition (if) :

À faire vous-même 15

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


l = [1, 7, 9, 15, 5, 20, 10, 8]
ma_liste = [p for p in l if p > 10]
		

autre possibilité, utiliser des composants "arithmétiques" :

À faire vous-même 16

Quel est le contenu de la liste référencée par la variable "ma_liste" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


l = [1, 7, 9, 15, 5, 20, 10, 8]
ma_liste = [p**2 for p in l if p < 10]
		

Rappel : "p**2" permet d'élever la variable "p" au carré

Comme vous pouvez le remarquer, nous obtenons une liste ("ma_liste") qui contient tous les éléments de la liste "l" élevés au carré à condition que ces éléments de "l" soient inférieurs à 10. Comme vous pouvez le constater, la compréhension de liste permet d'obtenir des combinaisons relativement complexes.


Travailler sur des "listes de listes"

Chaque élément d'une liste peut être une liste, on parle de liste de liste.

Voici un exemple de liste de liste :


m = [[1, 3, 4], [5 ,6 ,8], [2, 1, 3], [7, 8, 15]]
		

Le premier élément de la liste ci-dessus est bien une liste ([1, 3, 4]), le deuxième élément est aussi une liste ([5, 6, 8])...

Il est souvent plus pratique de présenter ces "listes de listes" comme suit :


m = [[1, 3, 4],
     [5, 6, 8],
     [2, 1, 3],
     [7, 8, 15]]
		

Nous obtenons ainsi quelque chose qui ressemble beaucoup à un "objet mathématique" très utilisé : une matrice

Il est évidemment possible d'utiliser les indices de position avec ces "listes de listes". Pour cela nous allons considérer notre liste de listes comme une matrice, c'est à dire en utilisant les notions de "ligne" et de "colonne". Dans la matrice ci-dessus :

En ce qui concerne les lignes :

En ce qui concerne les colonnes :

Pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : m[ligne][colonne] (sans perdre de vu que la première ligne et la première colonne ont pour indice 0)

À faire vous-même 17

Quelle est la valeur référencée par la variable "a" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


m = [[1, 3, 4],
     [5, 6, 8],
     [2, 1, 3],
     [7, 8, 15]]
a = m[1][2]
		

Comme vous pouvez le constater, la variable "a" référence bien l'entier situé à la 2e ligne (indice 1) et à la 3e colonne (indice 2), c'est-à-dire 8.


À faire vous-même 18

Quel est le contenu de la liste référencée par la variable "mm" après l'exécution du programme ci-dessous ? (utilisez la console pour vérifier votre réponse)


m = [1, 2, 3]
mm = [m, m, m]
m[0] = 100
		

Comme vous pouvez le constater, la modification de la liste référencée par la variable "m" entraine la modification de la liste référencée par la variable "mm" (alors que nous n'avons pas directement modifié la liste référencée par "mm"). Il faut donc être très prudent lors de ce genre de manipulation afin d'éviter des modifications non désirées.


Il est possible de parcourir l'ensemble des éléments d'une matrice à l'aide d'une "double boucle for" :

À faire vous-même 19

Analysez puis testez le code suivant :


m = [[1, 3, 4],
     [5, 6, 8],
     [2, 1, 3],
     [7, 8, 15]]
nb_colonne = 3
nb_ligne = 4
for i in range(0, nb_ligne):
	for j in range(0, nb_colonne):
		a = m[i][j]
		print(a)