Notion de listesCours

I

Génération d'une liste

A

Définition et notation

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.

Notation

Une liste peut être nommée comme on le souhaite.

Dans les exemples qui suivront, on les nommera liste1, liste2, etc.

Les éléments d'une liste se trouve entre des crochets : [\dots].

Les éléments sont séparés par des virgules.

Voici différents exemples de listes :

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~
B

Génération par extension, concaténation, duplication

On peut étendre une liste avec une autre liste en ajoutant les éléments d'une liste un par un au bout 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 le 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]!.

C

Génération par ajouts successifs

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 :

-
D

Génération en compréhension

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

Voici un autre exemple générer aléatoirement (on charge la bibliothèque \verb~random~ au préalable) :

\begin{lstlisting}

import random

liste1=[random.randint(0,1) for i in range(10)]

\end{lstlisting}

On obtient par exemple : \verb~[0, 1, 0, 0, 0, 1, 0, 1, 0, 1]~.

II

Manipuler des éléments d'une liste

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.

Voici donc des instructions à 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 dont voici 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 !~.

III

Itérer sur les éléments d'une liste, parcourir une liste

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]~.

Voici une autre version en utilisant 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.

Du coup, lui donner un nom est 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↦ 2x^2+3x+1.