Listes
Les
listes
Python sont des ensemble ordonnés et dynamique d’éléments. Ces ensemble peuvent
contenir des éléments de différents types, leur seul point commun est que ce sont des objets. Et
comme tout est objet, les listes sont elles mêmes des objets (instances de la classe
list
).
L’exemple suivant crée tout d’abord deux listes vides avec les deux manières possibles.
>>>
mylist = []
>>>
mylist2 = list()
Ensuite, après avoir défini
x
, une liste contenant la chaîne ‘bar’, l’entier 12345 et l’objet réfé-
rencé par la variable
x
est créée.
>>>
x = True
>>>
foo = [’bar’, 12345, x]
>>>
foo
[’bar’, 12345, True]
Les listes et les chaînes ont pour point commun le fait d’être des ensembles ordonnés. L’accès
à un élément d’une liste se fait donc aussi par indexation (ligne 1). Il est possible de prendre
une partie de liste (ligne 3) et d’obtenir une copie de liste (ligne 5). Une copie de liste crée une
nouvelle liste, mais partage les éléments contenus dans la liste d’origine.
Cette dernière manipulation est très importante lors de parcours de listes (voir section [sub-
Chap1LoopPbl]) pour ne pas modifier la liste qui est parcourue et se retrouver dans une boucle
sans fin.
>>>
foo[2]
True
>>>
foo[1:]
[12345, True]
>>>
bar = foo[:]
Enfin, le contenu de la liste peut être changé par simple affection en utilisant l’index cible.
Comme la liste référencée par
bar
est une copie de la liste référencée par
foo
, le dernier
élément de
bar
n’est pas modifié par l’affectation du dernier élément de
foo
.
Initiation à Python par l’exemple Documentation, Version 1.5.0
>>>
foo[2] = 1
>>>
foo
[’bar’, 12345, 1]
>>>
bar[-1]
True
L’ajout d’éléments dans une liste se fait à l’aide des méthodes
append
pour un ajout en fin de
liste, et
insert
, pour un ajout à un index donné. Enfin, la méthode
extend
ajoute le contenu
d’une liste passé en paramètre à la fin de la liste.
>>>
foo.append(’new’)
>>>
foo
[’bar’, 12345, 1, ’new’]
>>>
foo.insert(2, ’new’)
>>>
foo
[’bar’, 12345, ’new’, 1, ’new’]
>>>
foo.extend([67, 89])
>>>
foo
[’bar’, 12345, ’new’, 1, ’new’, 67, 89]
La méthode
index
permet de connaître l’index de la première occurrence d’un élément dans
une liste. Dans le cas où l’élément fournit en paramètre n’est pas présent, la méthode lève
l’exception
ValueError
. L’utilisation de la construction
in
retourne quant à elle
True
si
l’élément est présent dans la liste et
False
sinon.
>>>
foo.index(’new’)
2
>>>
foo.index(34)
Traceback (most recent call last):
File “<stdin>”, line 1, in ?
ValueError: list.index(x): x not in list
>>>
34
in
foo
False
Les listes peuvent être fusionnées par concaténation. Ces concaténations peuvent aussi bien se
faire par copie que par ajout. La ligne 1 représente une concaténation par copie des deux listes
existantes. La ligne 4 présente une concaténation par ajout d’éléments à une liste existante.
Enfin, la ligne 7 présente une manière simple de créer une liste par répétition d’un motif qui
doit être lui même une liste.
>>>
bar = [0, 1] + [1, 0]
>>>
bar
[0, 1, 1, 0]
>>>
bar += [2, 3]
>>>
bar
[0, 1, 1, 0, 2, 3]
>>>
[0, 1]
*
3
[0, 1, 0, 1, 0, 1]
Attention
Dans le cas d’une création de liste par répétition, les éléments ne sont pas dupliqués,
mais ce sont leurs références qui sont répétées (et donc présentes plusieurs fois dans la liste
finale). Utiliser l’opérateur
*
pour la construction de matrice est donc une mauvaise idée car
toutes les lignes seraient alors la même liste référencée plusieurs fois.
>>>
matrix = [[1, 2, 3]]
*
3
>>>
matrix
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
>>>
matrix[1][1] = 4
>>>
matrix
[[1, 4, 3], [1, 4, 3], [1, 4, 3]]
De manière symétrique à l’ajout d’éléments dans une liste, il est possible d’en supprimer. La
méthode
remove
permet de supprimer la première occurrence d’un élément d’une liste en le
désignant.
>>>
foo.remove(’new’)
>>>
foo
[’bar’, 12345, 1, ’new’, 67, 89]
Si l’élément fourni en paramètre n’existe pas dans la liste, l’exception
ValueError
est levée.
>>>
foo.remove(34)
Traceback (most recent call last):
File “<stdin>”, line 1, in ?
ValueError: list.remove(x): x not in list
L’opérateur
del
(
delete
) permet de détruire une référence à un objet Python, ou à une partie
d’une liste
4
.
>>> del
foo[1:3]
>>>
foo
[’bar’, ’new’, 67, 89]
D’autres formes plus avancées de manipulation de listes sont présentées dans la section
[sub :chap1 :listes].
