Retourner à : Python pour débutants
Dans ce nouveau chapitre, nous allons nous attaquer à un concept fondamental en Python : les listes. Au cours de cette vidéo, on va voir :
- ce que sont les listes
- comment créer des listes
- comment accéder à des éléments
- comment modifier, ajouter et supprimer des éléments
- et enfin, on vera quelques opérations utiles sur les listes
Définition
Alors, une liste, qu’est-ce que c’est ? En Python, une liste est un type de variable qui peut contenir aucune, une ou plusieurs valeurs, de n’importe quel type. Autrement dit, c’est une collection d’éléments, qu’on va pouvoir parcourir, modifier et manipuler facilement.
Création de listes
Pour créer une liste, il suffit d’utiliser des crochets, et de placer les éléments qu’on veut stocker dans notre liste entre ces crochets, séparés par une virgule. Regardons quelques exemples afin de mieux illustrer tout cela:
liste_vide = []
print(liste_vide)Ici, on a créé une variable qu’on appel liste_vide, et on lui a assigné des crochets vides, ce qui représente une liste vide. Et si on exécute ce code, la console nous affiche bien [].
On peut aussi créer une liste avec des éléments d’un même type. Par exemple si nous voulons créer une liste de nombres entiers, on peut faire la chose suivante:
liste_nombres = [1, 5, 10, 23, 27]
print(liste_nombres)Et cette fois, notre liste contient bien les cinq nombres qu’on vient d’entrer.
En Python, il n’y a aucune restriction sur le type des éléments d’une liste. On peut donc mélanger des nombres, du texte, et même d’autres listes à l’intérieur d’une seule et même liste :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
print(liste_heterogene)Et si on affiche cette liste, on voit bien tous les éléments qu’on vient de déclarer
Accéder à un élément d’une liste
Maintenant que nous avons déclarer des listes, regardons ce que nous devons faire pour accéder aux éléments de nos listes. Et bien, pour accéder à un élément précis d’une liste, on utilise son index. En Python, les index commencent toujours à 0.
Donc dans notre exemple de liste hétérogène [18, 34, 22.22, « bonjour », « ça va », [3, 2, 1], 120], si on souhaite accéder au nombre 22.22, on doit tout d’abord déterminer sa position dans la liste. Ici 22.22 est à la troisième position, ce qui correspond à l’index 2. Comme on le disait avant, les indexes commencent à 0, donc 18 est à l’index 0, 34 à l’index 1, et donc 22.22 se trouve bien à l’index 2.
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
print(liste_heterogene[2])Et si on lance ce code, on obtient la valeur 22.22.
Si on veut accéder à un élément à l’intérieur d’une liste imbriquée dans autre liste, on peut enchaîner les crochets. Donc si on veut accéder au au chiffre 2, qui se trouve à l’index 1, de la liste [3, 2, 1], qui se trouve elle même à l’index 5 de notre liste_heterogene, il suffit de faire la chose suivante :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
print(liste_heterogene[5][1])Le premier crochet nous permet d’accéder à la liste [3, 2, 1] qui se trouve à l’index 5, et une fois que nous avons cette liste, nous accédons à son élément à l’index 1, donc ici le 2 :
Modifier un élément
Maintenant que nous savons comment accéder à un élément d’une liste, il est temps de regarder comment assigner une nouvelle valeur à un index précis de celle-ci. Pour cela, il suffit d’utiliser l’opération d’assignation, de manière tout à fait semblable à une variable normale, à la différence près qu’on va pas assigner une valeur à la variable qui contient notre liste, mais qu’on va plutôt assigner la valeur à une position précise de celle-ci. Pour cela on va, ici aussi, renseigner l’index qu’on souhaite modifier entre crochets, lors de l’assignation.
Donc si on souhaite assigner le nombre 33.33 à l’index 2 de notre liste_heterogene, on doit faire la chose suivante :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
print(liste_heterogene)
liste_heterogene[2] = 33.33
print(liste_heterogene) Et si on relance notre programme, on voit que notre liste contient maintenant bien le nombre 33.33 à l’index 2 :
Ajouter des éléments
En plus d’accéder et de modifier des éléments d’une liste, on peut aussi ajouter des éléments à celle-ci en utilisant la méthode append, à laquelle on va passer un élément qu’on souhaite ajouter à la fin de notre liste. Si on souhaite ajouter le numéro 200, à la fin de notre liste_heterogene, on faire la chose suivante :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
liste_heterogene[2] = 33.33
print(liste_heterogene)
liste_heterogene.append(200)
print(liste_heterogene) Notre liste a maintenant un élément en plus en fin de liste :
Si, on souhaite ajouter un élément à un index précis d’une liste, au lieu de le rajouter à la fin, on peut utiliser la méthode insert. Cette méthode prend deux paramètres, le premier est l’index auquel on souhaite insérer la nouvelle valeur, et le deuxième est la valeur qu’on souhaite ajouter à la liste. Pour ajouter la valeur 453 à l’index 2 de liste_heterogene, on fait :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
liste_heterogene[2] = 33.33
liste_heterogene.append(200)
print(liste_heterogene)
liste_heterogene.insert(2, 453)
print(liste_heterogene) Si on relance notre code, on voit bien le nouvel élément à l’index 2 :
Supprimer des éléments
Pour supprimer un élément, il existe plusieurs façons de faire. La première consiste à utiliser le mot-clé del suivi de l’élément qu’on souhaite supprimer. Par exemple, si on souhaite supprimer l’élément 34, qui se situe donc à l’index 1, on va faire :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
liste_heterogene[2] = 33.33
liste_heterogene.append(200)
liste_heterogene.insert(2, 453)
print(liste_heterogene)
del liste_heterogene[1]
print(liste_heterogene) Ce qui nous donne:
Attention : si vous écrivez simplement del liste_heterogene sans préciser d’index, vous supprimerez la liste entière.
L’autre méthode pour supprimer un élément d’une liste, consiste à utiliser la méthode pop. Cette méthode supprime un élément, et le retourne :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
liste_heterogene[2] = 33.33
liste_heterogene.append(200)
liste_heterogene.insert(2, 453)
del liste_heterogene[1]
print(liste_heterogene)
dernier = liste_heterogene.pop()
print(dernier)
print(liste_heterogene)Ici pop supprime le dernier élément de la liste, donc 200, et on le stock dans la variable dernier :
On peut aussi utiliser la méthode pop afin de supprimer et récupérer un élément à un index précis d’une liste. Pour cela, on va lui passer en paramètre l’index en question :
liste_heterogene = [18, 34, 22.22, "bonjour", "ça va", [3, 2, 1], 120]
liste_heterogene[2] = 33.33
liste_heterogene.append(200)
liste_heterogene.insert(2, 453)
del liste_heterogene[1]
dernier = liste_heterogene.pop()
print(liste_heterogene)
element_efface = liste_heterogene.pop(1)
print(element_efface)
print(liste_heterogene)Ce qui nous donne le résultat suivant :
Autres opérations utiles
Avant de clôturer ce chapitre, il y a encore plein d’opérations utiles que nous pouvons utiliser avec nos listes, et que j’aimerai vous montrer.
Indexes négatifs
Tout d’abord, Python nous mets une manière très simple d’accéder aux derniers éléments d’une liste, sans connaître sa taille, à disposition. Pour cela, il suffit d’utiliser des indexes négatifs. En effet, l’index -1, permet d’accéder au dernier élément, -2 à l’avant dernier, etc…
print(liste_heterogene)
dernier_element = liste_heterogene[-1]
avant_dernier_element = liste_heterogene[-2]
print(dernier_element)
print(avant_dernier_element)Ce qui nous donne :
Longueur d’une liste
Si on souhaite déterminer le nombre d’éléments d’une liste (a.k.a. sa longueur), on peut utiliser la fonction len qui prend en paramètre une liste et retourne sa longueur :
print(liste_heterogene)
nombre_d_elements = len(liste_heterogene)
print(nombre_d_elements)Et quand on execute ce code, on retrouve bien la longueur de liste_heterogene :
Concaténer des listes
Il peut arriver qu’on aie besoin de joindre les éléments de deux listes en une seule. En Python cette opération de concaténation est très simple. Il suffit d’utiliser l’opérateur + qui peut être appliqué à deux listes et retourne une nouvelle liste contenant tous les éléments de la première, suivi des éléments de la deuxième liste :
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
liste_complete = liste1 + liste2
print(liste_complete)Ici si on execute notre code, on se retrouve avec une nouvelle liste content les éléments [1, 2, 3, 4, 5, 6] :
Si, au lieu de créer une nouvelle liste avec la concaténation de deux listes, on souhaite plutôt ajouter les éléments d’une liste à une autre, on peut utiliser la méthode extend. On appelle cette méthode sur la liste qu’on souhaite étendre et on lui passe la liste des éléments à jouter à celle-ci en paramètre :
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
liste_complete = liste1 + liste2
print(liste_complete)
liste_complete.extend([7, 8, 9])
print(liste_complete)Donc ici, si on étend la liste_complete avec la liste [7, 8, 9] on se retrouve avec le résultat [1, 2, 3, 4, 5, 6, 7, 8, 9] :
Extraire des sous-ensembles de listes
Pour finir, regardons encore comment extraire une sous-liste à partir d’une liste. On appelle cette extraction de sous-listes du slicing. En Python, on peut utiliser une notation basée sur les indexes pour effectuer ces slicings. Pour cela on va prendre notre liste et entre crochets, on va lui passer l’index à partir duquel on souhaite extraire notre sous-liste, suivi d’un double point et de l’index jusqu’auquel on souhaite extraire la liste. Attention ce dernier index est exclu !
liste_alpha = ['a', 'b', 'c', 'd', 'e', 'f']
sous_liste = liste_alpha[2:5]
print(sous_liste)Dans notre exemple ci-dessus, on fait un slice de l’index 2, qui correspond à la lettre c, jusqu’à l’index 5 exclu. On retourne donc le tableau [‘c’, ‘d’, ‘e’] :
Si on veut récupérer tous les éléments jusqu’à un index en particulier on peut omettre le premier index et taper simplement un double suivi de l’index avant lequel on souhaite s’arrêter :
liste_alpha = ['a', 'b', 'c', 'd', 'e', 'f']
sous_liste = liste_alpha[:5]
print(sous_liste)Ici on retourne donc [‘a’, ‘b’, ‘c’, ‘d’, ‘e’] :
Et de manière similaire, si on souhaite récupérer une sous-liste qui commence à un index précis et qui contient tous les autres éléments de la liste, on peut renseigner le premier index et omettre l’index de fin :
liste_alpha = ['a', 'b', 'c', 'd', 'e', 'f']
sous_liste = liste_alpha[2:]
print(sous_liste)Et donc, dans ce cas, notre sous_liste contient les éléments [‘c’, ‘d’, ‘e’, ‘f’] :
Et voilà, vous savez maintenant créer, manipuler et parcourir des listes en Python. C’est un concept de base que vous utiliserez tout le temps dans vos projets. Prenez donc bien le temps d’assimiler ce concept avant de passer à la suite du cours.
Ressources
Vous retrouvez ci-dessous un lien vers le code source utilisé dans ce chapitre. Ce lien est uniquement disponible pour les abonnés Standard et Premium.
Quiz
Répondez au quiz ci-dessous afin de vérifier que vous avez bien compris le contenu de cette leçon. Les quiz sont uniquement disponibles pour les abonnés Standard et Premium.