$$ \def\CC{\bf C} \def\QQ{\bf Q} \def\RR{\bf R} \def\ZZ{\bf Z} \def\NN{\bf N} $$

Listes

In [ ]:
from __future__ import division, print_function   # Python 3

En Python, les listes sont beaucoup utilisées. Il est donc important de connaîtres les différentes façons de créer, modifier et utiliser les listes. Dans ce chapitre, nous allons voir les différentes opérations sur les listes.

Les listes sont créées avec l'utilisation des crochets et on peut mettre n'importe quel objet dans une liste:

In [ ]:
[2, 3, 4, 'bateau', 3.24]
Out[ ]:
[2, 3, 4, 'bateau', 3.24]

On accède aux éléments de la liste de la même façon qu'avec les chaînes de caractères, c'est-à-dire en utilisant les crochets et le premier élément est à la position zéro:

In [ ]:
L = [2, 3, 4, 'bateau', 3.24]
L[0]
Out[ ]:
2
In [ ]:
L[3]
Out[ ]:
'bateau'

On peut modifier la liste en lui ajoutant des objets avec la méthode append de la façon suivante:

In [ ]:
L.append(789)
L
Out[ ]:
[2, 3, 4, 'bateau', 3.24, 789]

On vérifie que le dernier élément de la liste est bien le nombre entier 789 :

In [ ]:
L[-1]
Out[ ]:
789

La fonction list permet de transformer un objet en liste pourvu qu'il soit itérable:

In [ ]:
list(w)
Out[ ]:
['b', 'o', 'n', 'j', 'o', 'u', 'r']

Plusieurs autres opérations sont possibles sur les listes. On peut consulter l'aide ou la documentation pour en savoir plus:

In [ ]:
L.<TAB>
help(list)

Opérations sur les listes

D'abord, créons une liste:

In [ ]:
L = [1, 8, -4, 38, 8, 8, 4, 18]

Pour créer une sous-liste commençant à l'indice 2 jusqu'à l'indice 5-1=4:

In [ ]:
L[2:5]
Out[ ]:
[-4, 38, 8]

On peut créer une nouvelle liste avec l'opération d'addition (+) qui concatène deux listes. Ceci ne change pas les listes utilisées. Par exemple:

In [ ]:
L + [1,2,3]
Out[ ]:
[1, 8, -4, 38, 8, 8, 4, 18, 1, 2, 3]
In [ ]:
L
Out[ ]:
[1, 8, -4, 38, 8, 8, 4, 18]

La fonction len retourne la longueur d'une liste:

In [ ]:
len(L)
Out[ ]:
9

Les fonctions min et max retournent la valeur minimum et maximum d'une liste:

In [ ]:
min(L)
Out[ ]:
-4
In [ ]:
max(L)
Out[ ]:
38

Pour savoir si une valeur est dans une liste, on utilise valeur in liste. Cela retourne un booléen. Par exemple:

In [ ]:
77 in L
Out[ ]:
False
In [ ]:
38 in L
Out[ ]:
True

La méthode .count() permet de compter le nombre d'objets de la liste ayant une certaine valeur:

In [ ]:
L.count(38)
Out[ ]:
1
In [ ]:
L.count(8)
Out[ ]:
3
In [ ]:
L.count(77)
Out[ ]:
0

La méthode .index() retourne la position (ou indice) où un élément se retrouve dans la liste:

In [ ]:
L
Out[ ]:
[1, 8, -4, 38, 8, 8, 4, 18]
In [ ]:
L.index(38)
Out[ ]:
3

Modification de listes

Pour ajouter un élément à la liste, on utilise la méthode .append() qui ajoute un élément à la fin de la liste:

In [ ]:
L
Out[ ]:
[1, 8, -4, 38, 8, 8, 4, 18]
In [ ]:
L.append(15)
L
Out[ ]:
[1, 8, -4, 38, 8, 8, 4, 18, 15]

La méthode .remove() permet d'enlever un élément de la liste:

In [ ]:
L.remove(4)
L
Out[ ]:
[1, 8, -4, 38, 8, 8, 18, 15]

Si l'élément est là plus d'une fois, seule la première occurence de celle-ci est retirée:

In [ ]:
L.remove(8)
L
Out[ ]:
[1, -4, 38, 8, 8, 18, 15]

La méthode .reverse() permet d'inverser l'ordre d'une liste:

In [ ]:
L.reverse()
L
Out[ ]:
[15, 18, 8, 8, 38, -4, 1]

La méthode .sort() permet de trier les éléments d'une liste en ordre croissant:

In [ ]:
L.sort()
L
Out[ ]:
[-4, 1, 8, 8, 15, 18, 38]

La fonction range

La fonction range(n) permet de créer la liste des entiers de 0 à n-1 :

In [ ]:
range(15)                  # Python 2
list(range(15))            # Python 3
Out[ ]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Avec deux arguments, la fonction range(a, b) crée la liste des entiers de a à b-1 :

In [ ]:
range(3, 15)
Out[ ]:
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Avec trois arguments, la fonction range(a, b, saut) crée la liste des entiers de a à b-1 par saut de saut :

In [ ]:
range(3,40,4)
Out[ ]:
[3, 7, 11, 15, 19, 23, 27, 31, 35, 39]

Compréhension de listes

Soit la liste des entiers de zéro à neuf:

In [ ]:
L = range(10)
L
Out[ ]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Les compréhensions de listes (list comprehensions en anglais, certains auteurs écrivent intentions de listes en français) permettent de créer des listes facilement en une ligne. La syntaxe ressemble à la syntaxe qui permet de décrire un ensemble mathématique: [expression_de_i for i in liste]. Par exemple, l'ensemble des cubes des valeurs de la liste L s'écrit:

In [ ]:
[i**3 for i in L]
Out[ ]:
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

L'ensemble des cubes des valeurs impaires de la liste L se fait en ajoutant une condition à la fin de l'expression:

In [ ]:
[i**3 for i in L if i%2 == 1]
Out[ ]:
[1, 27, 125, 343, 729]