Quand on souhaite manipuler des données, il est nécessaire d'utiliser des structures pour stocker plusieurs valeurs. Python ne fait pas exception à la règle et possède plusieurs structures de données. Dans cet article, nous allons aborder les listes, une structure simple qui existe également dans de nombreux autres langages. Une liste permet de stocker plusieurs valeurs, éventuellement des valeurs de différents types (on peut donc avoir une liste avec des entiers, une liste avec des entiers et des chaînes de caractères voire avoir une liste de listes). Pour écrire une liste, on écrit ses éléments, séparés par des virgules, le tout encadrés par des crochets.
Exemples
Par exemple, on peut écrire :
Une liste d'entiers :
>>> listeEntiers = [1, 2, 3, 4]
Une liste dont les valeurs sont de différents types :
>>> listeMélangée = [1, "coucou", 2.02, "toto"]
Une liste dont certaines valeurs sont elles-mêmes des listes :
>>> listeDeListes = [1, 2, [3, 4, 5], [5, 6, 7], 7, 8]
Les indices et les « tranches » (slicing)
Une fois qu'on a construit une liste, on a besoin d'un moyen pour accéder à une valeur donnée de cette liste. On peut également vouloir n'utiliser qu'un fragment (une « tranche ») de cette liste (en anglais on parle de slicing). La syntaxe de Python permet d'effectuer ces deux opérations assez simplement.
Utilisation des indices
Un élément d'une liste est défini par son indice qui est sa position par rapport au début de la liste (qui commence à gauche). Grâce à l'indice d'un élément, on pourra le récupérer en écrivant le nom de la liste suivi de l'indice entre crochets. Attention : la numérotation des indices commence à partir de 0.
>>> maListe = [1, 2, 3, 4, 5] >>> print(maListe[0]) 1 >>> maListe[1] 2 >>> maListe[4] 5
Si l'indice est supérieur à la longueur de la liste et qu'on essaye d'accéder à un tel élément, cela déclenchera une exception. Ainsi :
>>> maliste[5] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range
Connaître la longueur d'une liste : len()
La plupart du temps, on utilisera des listes de différentes tailles sans être capable de prévoir la taille de la liste avant de la manipuler. Connaître la longueur d'un liste est souvent utile et Python fournit donc une fonction native : len qui prend une liste comme argument et qui renvoie la longueur de cette liste comme argument (len vient de length en anglais qui signifie longueur).
>>> maListe = [1, 2, 3, 4, 5] >>> print(len(maListe)) 5
Une liste peut avoir un seul élément :
>>> simpleListe = ["toto"] >>> print(len(simpleListe)) 1
Voilà un exemple plus complexe avec une liste de listes :
>>> listeDeListes = [1, [2, 3], [4, 5, 6]] >>> print(len(listeDeListes)) 3 >>> print(len(listeDeListes[1])) 2 (la longueur de [2, 3])
Les indices négatifs
Il est aussi possible d'utiliser des indices négatifs pour accéder aux éléments d'une liste. Dans ce cas, Python parcourera la liste en sens inverse (de la fin vers le début) pour accéder à l'élément. Par exemple, maListe[-1] renverra le dernier élément de maListe. Cette notation est la bienvenue car elle permet de raccourcir et d'aléger considérablement des instructions trop longues et fréquemment utilisées comme maListe[len(maListe)-X] où X est l'indice inverse de l'élément qu'on souhaite utiliser.
>>> maListe = [1, 2, 3, 4, 5] >>> print(maListe[-1]) 5
Cette instruction précédente est équivalente à celle qui suit (qui est beaucoup plus longue) :
>>> print(maListe[len(maListe)-1]) 5
Découper un fragment de liste (slicing)
Dans certains cas, on peut vouloir n'utiliser qu'un fragment d'une liste (une partie du début de la liste, une partie de la fin ou une « tranche » dans le milieu de la liste). Cette opération de découpage est très utile, notamment pour créer de nouvelles listes à partir de listes existantes, sans avoir à aller chercher chacun des éléments un par un. La syntaxe pour découper une liste est la suivante : on utilise le nom de la liste suivi par deux indices séparés par deux points (:) entre crochets. Le premier indice indique l'endroit où commencer le découpage (l'élément correspondant sera inclus dans le résultat) et le second indice indique où finir la découpe (l'élément de l'indice correspondant ne fera pas partie du résultat). Les exemples qui suivent illustrent cette syntaxe :
Ici, on crée une deuxième liste avec les deux premiers éléments d'une liste existante :
>>> maListe = [1, 2, 3, 4, 5] >>> débutListe = maListe[0:2] >>> print(débutListe) [1, 2]
Là, on crée une autre liste avec les derniers éléments :
>>> maListe = [1, 2, 3, 4, 5] >>> finListe = maListe[3:5] >>> print(finListe) [4, 5]
Pour être tout à fait complet, illustrons quelques cas aux limites auxquels vous avez pu penser :
>>> maListe = [1, 2, 3, 4, 5] >>> print(maListe[0:85454]) [1,2,3,4,5] >>> print(maListe[2:1]) [] (car 2 est plus petit que 1)
Nous l'avons vu avant : les indices négatifs sont une notation raccourcie pour accéder aux éléments d'une liste dans un ordre inverse. Pour le découpage d'une liste, il existe également un notation raccourcie qui est plus pratique lorsqu'on souhaite avoir X éléments depuis le début d'une liste ou Y éléments depuis la fin d'une liste (voire obtenir une liste de tous les éléments sauf des X premiers ou encore obtenir une liste de tous les éléments sauf les Y derniers). Dans les exemples qui viennent, on voit cette notation raccourcie et les différents cas de figure qu'elle rend possible :
Comme avant, on crée une liste avec les deux premiers éléments mais avec une notation plus légère et plus facile à lire :
>>> maListe = [1, 2, 3, 4, 5] >>> débutListe = maListe[:2] >>> print(débutListe) [1, 2]
Là on crée une liste avec les derniers éléments mais avec la notation raccourcie :
>>> maListe = [1, 2, 3, 4, 5] >>> finListe = maListe[-2:] >>> print(finListe) [4, 5]
Dans cet exemple, on crée une liste en retirant quelques éléments du début :
>>> maList = [1, 2, 3, 4, 5] >>> listeSansTête = maListe[2:] >>> print(listeSansTête) [3, 4, 5]
Et ici, on crée une liste en retirant des éléments de la fin :
>>> maListe = [1, 2, 3, 4, 5] >>> listeSansQueue = maListe[:-4] >>> print(listeSansQueue) [1]
Caractère mutable
En Python, les listes sont mutables. Cela signifie qu'une fois qu'une liste a été définie, il est possible de modifier son contenu grâce aux instructions suivantes. Une liste peut être modifiée « directement » ou grâce à des opérations et/ou à des fonctions. Les exemples qui suivent illustrent quelques unes des opérations qui sont possibles.
En changeant la valeur d'un des éléments (ici le deuxième qu'on définit à 10) :
>>> maListe = [1, 2, 3, 4, 5] >>> maListe[1] = 10 >>> print(maListe) [1, 10, 3, 4, 5]
En concaténant deux listes :
>>> listeA = [1, 2, 3] >>> listeB = [2, 4, 6] >>> listeA = listeA + listeB >>> print(listeA) [1, 2, 3, 2, 4, 6]
En utilisant une fonction native pour modifier la liste :
>>> maListe = [1, "toto", "truc", 2] >>> maListe.reverse() >>> print(maListe) [2, "truc", "toto", 1]