La génération d'une liste
La liste est une structure de données en Python. Elle peut être générée de plusieurs manières : par extension, concaténation, duplication, ajouts successifs et la génération en compréhension.
Définition et notation
Regrouper plusieurs informations dans une même structure de donnée est très utile en programmation. On introduit une première structure de données en Python, celle de liste.
Liste
Une liste est un objet algorithmique servant à stocker plusieurs variables au cours d'un programme. Les variables stockées peuvent être de différents types : variables numériques, chaînes de caractères, booléens, listes, etc. Les différents types de variables peuvent être mélangés au sein d'une même liste.
| Instruction Python | Rôle de l'instruction |
| \verb!liste1=[]! | définit la liste \verb~liste1~ comme la liste vide |
| \verb!liste2=[3, 4.5, x]! | définit la liste \verb~liste2~ comme la liste contenant l'entier 3, le flottant 4.5 et la variable x |
| \verb!liste3=['Bonjour', -5, t]! | définit la liste \verb~liste3~ comme la liste contenant la chaîne de caractères 'Bonjour', l'entier -5 et la variable t |
| \verb!liste4=[0, [1, 2], "essai", True]! | définit la liste \verb~liste4~ comme la liste contenant l'entier 0, la liste \verb~[1, 2]~, la chaîne de caractères \verb~essai~ et le booléen \verb~True~ |
Une liste peut être nommée comme on le souhaite. Les éléments d'une liste se trouvent entre des crochets : [\dots]. Les éléments sont séparés par des virgules.
| \verb!liste1=[]! |
| \verb!liste2=[3, 4.5, x]! |
| \verb!liste3=['Bonjour', -5, t]! |
| \verb!liste4=[0, [1, 2], "essai", True]! |
Les cinq modes de génération d'une liste
Il existe 5 mode de génération d'une liste : la génération d'une liste par extension, concaténation, duplication, ajouts successifs et en compréhension. Avec la méthode de génération en compréhension, on génère une liste en explicitant la relation mathématique qui existe entre chacun des termes.
On peut étendre une liste avec une autre liste en ajoutant les éléments d'une deuxième liste à la fin d'une première liste. En Python, on utilise la méthode \verb~.extend()~.
Le programme Python suivant crée deux listes \verb~liste1~ et \verb~liste2~, puis étend la liste \verb~liste1~ avec les éléments de la liste \verb~liste2~ :
On obtient : \verb~[1, 2, 3, 10, 20, 30]~.
Un mode de génération de listes proche de l'extension est celui de la concaténation. Il a exactement le même effet que le précédent. La différence réside dans le fait de ne pas utiliser de méthode mais une "opération".
Le programme suivant donne le même résultat que le précédent mais en utilisant la concaténation :
Un troisième mode de génération permettant le « recopiage » d'une liste au bout d'elle-même est la duplication. On peut concaténer la liste avec elle-même plusieurs fois de suite.
Le programme Python suivant duplique 5 fois \verb~liste1~ pour n'en faire qu'une liste :
On obtient : \verb![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]!.
On peut également générer une liste par ajouts successifs d'éléments. En Python, on utilise la méthode \verb~.append()~. Elle sert à ajouter un élément à la fin d'une liste.
Le programme Python suivant crée une liste \verb~liste1~ vide, puis ajoute les carrés des entiers de 0 à 10 :
On obtient l'affichage suivant :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100].
Une autre façon de générer une liste est celle dite en compréhension. Elle est plus courte et plus explicite que les précédentes. Certains langages de programmation, comme Python, permettent de définir une liste en indiquant la façon dont sont générés les éléments de la liste.
Le programme Python suivant crée la liste des carrés des entiers de 0 à 10 d'une autre façon :
On obtient l'affichage suivant :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100].
On peut ajouter des conditions dans une liste créée en compréhension.
Le programme suivant crée la liste des carrés des entiers de 0 à 10 mais ne conserve que les résultats strictement supérieurs à 50 :
On obtient : \verb~[64, 81, 100]~.
Si on utilise juste l'instruction \verb~range(11)~, Python ne crée pas une liste. Pour générer la liste des entiers de 0 à 10 (inclus), on doit utiliser l'instruction \verb~list~ comme suit :
\verb~list(range(11))~.
La manipulation des éléments d'une liste
Il y a différentes manipulations possibles sur une liste : la suppression, l'insertion, le rangement des valeurs, le renversement, etc.
Rang d'un élément
On appelle rang d'un élément dans une liste sa position dans la liste.
En Python, le premier élément d'une liste est de rang 0. La numérotation des éléments démarre donc à 0.
Dans la liste Python \verb~[5, 10, 15]~, on a :
- le nombre 5 est l'élément de rang 0,
- le nombre 10 est l'élément de rang 1,
- le nombre 15 est l'élément de rang 2.
Longueur d'une liste
On appelle longueur d'une liste le nombre d'éléments d'une liste.
En Python, la longueur de la liste \verb~liste1~ s'obtient avec l'instruction :
\verb!len(liste1)!.
La liste \verb~[5, 10, 15]~ a pour longueur 3.
Manipuler les éléments d'une liste nécessite souvent d'être capable de prendre un élément de rang donné dans une liste. Les instructions suivante sont à connaître lorsque l'on écrit un programme Python :
| Instruction Python | Rôle de l'instruction |
| \verb!liste1[i]! | affiche l'élément de rang \verb~i~ de la liste \verb~liste1~ |
| \verb!liste1[2:5]! | affiche les éléments de la liste \verb~liste1~ du rang 2 au rang 5 (non compris) |
| \verb!liste1[-1]! | affiche dernier élément de la liste \verb~liste1~ |
| \verb!liste1[-4:]! | affiche les 4 derniers éléments de la liste \verb~liste1~ |
| \verb!liste1[::3]! | renvoie une liste formée des termes de la liste \verb~liste1~ de rangs multiples de 3 |
| \verb!liste1.index(x)! | retrouve le rang de l'élément \verb~x~ dans la liste \verb~liste1~ |
| \verb!liste1.count(a)! | compte le nombre d'occurrences de \verb~a~ dans la liste \verb~liste1~ |
| \verb~a in liste1~ | teste si l'élément \verb~a~ est dans la liste \verb~liste1~ et renvoie \verb~True~ si c'est le cas et \verb~False~ sinon |
On peut manipuler les éléments d'une liste d'un grand nombre de façons.
Le tableau suivant montre quelques exemples en Python :
| Instruction Python | Rôle de l'instruction |
| \verb!liste1[i]=a! | remplace l'élément de rang \verb~i~ par \verb~a~ |
| \verb!liste1.insert(i,x)! | insère l'élément \verb~x~ dans la liste \verb~liste1~ au rang \verb~i~ |
| \verb!liste1.remove(x)! | supprime la première occurrence de \verb~x~ dans la liste \verb~liste1~ |
| \verb!liste1.pop(i)! ou \verb!del(liste1[i])! | supprime l'élément d'indice \verb~i~ dans la liste \verb~liste1~ |
| \verb!liste1.sort()! | modifie la liste \verb~liste1~ en triant les éléments dans l'ordre croissant |
| \verb!liste2=sorted(liste1)! | trie la liste \verb~liste1~ et stocke le résultat dans \verb!liste2!. La liste \verb~liste1~ n'est pas modifiée. |
| \verb!liste1.reverse()! | inverse les éléments de la liste \verb~liste1~ (ainsi que les autres listes qui lui sont égales) |
| \verb~liste2=liste1[::-1]~ | définit la liste \verb~liste2~ comme étant la liste \verb~liste1~ dans l'ordre inverse mais ne modifie pas \verb~liste1~ |
On peut également effectuer des transformations entre chaînes de caractères et listes.
Le programme suivant transforme la chaîne \verb~chaine~ en une liste de chaînes de caractères en utilisant l'espace comme séparateur pour couper la chaîne :
On obtient : \verb~['Bonjour', 'à', 'tous']~.
Le programme suivant transforme la liste \verb~liste1~ en une chaîne de caractères en ajoutant un espace entre chaque élément de la liste \verb~liste1~:
On obtient : \verb~Bonjour à tous !~.
Les itérations sur les éléments d'une liste et le parcours d'une liste
Une fois une liste créée, il est souvent utile de pouvoir retrouver un de ses éléments. Pour cela, on a besoin de parcourir la liste. Ce parcours peut se faire en utilisant les indices des éléments de la liste ou « en compréhension ».
On peut parcourir les éléments d'une liste en utilisant leurs rangs.
Le programme en Python suivant affiche les éléments de la liste \verb~liste1~ un par un :
On peut également parcourir une liste sans avoir recours aux rangs.
Le programme suivant affiche également les éléments de la liste \verb~liste1~ un par un :
On peut également appliquer une fonction à tous les éléments d'une liste.
Le programme en Python suivant applique la fonction f:x\mapsto 2x^2+3x+1 à tous les éléments de la liste \verb~liste1~ :
On obtient : \verb~[1, 6, 15, 28, 45, 66, 91, 120, 153, 190, 231]~.
Une autre façon d'appliquer une fonction à tous les éléments d'une liste utilise une fonction anonyme avec l'instruction \verb~lambda~ :
L'instruction \verb~lambda~ est utilisée ici pour créer une fonction qui n'est pas destinée à être réutilisée, lui donner un nom est alors inutile. La syntaxe est la suivante :
\verb~lambda nom_variable:expression_image_par_la_fonction~.
Dans l'exemple précédent, la fonction anonyme utilisée est la fonction x\mapsto 2x^2+3x+1.