Dans le tableau suivant, s est une séquence mutable (une liste, a priori), et x est un objet qu’on écrit, ajoute, supprime ou recherche dans s. On note t un objet “itérable” dont les éléments sont écrits dans s ou ajoutés à la fin de s.
| Opérations communes aux séquences mutables, donc applicables aux listes | |||
s[i] = x |
remplace s[i] par x | del s[i] |
supprime l’élément s[i] |
s[i:j] = t |
remplace s[i], . . . , s[j −1] par les élts de t | s[i:j:k] = t |
idem mais avec le pas k |
del s[i:j] |
supprime s[i], s[i + 1], …, s[j −1] | del s[i:j:k] |
idem mais avec le pas k |
s.append(x) |
ajoute un élément x à s | s.clear() |
efface tous les éléments de s |
s.copy() |
copie indépendante de s (idem s[:]) |
s.extend(t) |
ajoute les élts de l’itérable t à s |
s.insert(i,x) |
insère x en position i dans s | s.pop(i) |
supprime et renvoie le ième élt de s |
s.remove(x) |
supprime la 1ère occurence de x dans s | s.reverse() |
inverse l’ordre des éléments de s |
Attention : la plupart des instructions précédentes renvoient la valeur None mais mutent la liste (sans changer son adresse). Prenons quelques exemples, en plaçant une même liste dans s et t, et en faisant une copie “fraîche” de cette liste dans u. Les modifications sur s se répercutent dans t mais pas dans u :
|
1 2 3 4 5 6 7 8 9 10 |
>>> s = t = list(range(10,20)); t # place dans s et t la même liste (même adresse!) [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] >>> u = s.copy(); u # met dans u une copie indépendante de l'original [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] >>> s[3] = 'coucou'; t # remplace s[3], modification répercutée sur t [10, 11, 12, 'coucou', 14, 15, 16, 17, 18, 19] >>> del s[3]; t # supprime s[3], modification répercutée sur t [10, 11, 12, 14, 15, 16, 17, 18, 19] >>> s.insert(3,0); t # insère 0 en position 3 dans s (idem dans t) [10, 11, 12, 0, 14, 15, 16, 17, 18, 19] |
À la suite des instructions précédentes, on voit comment utiliser des coupes (slices) de la liste s :
|
1 2 3 4 5 6 |
>>> s[1:9:2] # lit une coupe de longueur 4 dans s [11, 0, 15, 17] >>> s[1:9:2] = 'abcd'; t # remplace ces 4 élts par ceux de 'abcd' [10, 'a', 12, 'b', 14, 'c', 16, 'd', 18, 19] >>> del s[1:5]; t # efface les éléments de positions 1 à 4 [10, 'c', 16, 'd', 18, 19] |
Terminons cette série d’exemples par quelques manipulations supplémentaires sur la liste s :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
>>> s.append('xyz'); t # ajoute l'objet 'xyz' à la fin de la liste [10, 'c', 16, 'd', 18, 19, 'xyz'] >>> s.extend('uvw'); t # complète la liste par les éléments de 'uvw' [10, 'c', 16, 'd', 18, 19, 'xyz', 'u', 'v', 'w'] >>> s.pop(5) # renvoie s[5], et le supprime de la liste 19 >>> s.remove(16); t # supprime la première occurence de la valeur 16 [10, 'c', 'd', 18, 'xyz', 'u', 'v', 'w'] >>> s.reverse(); t # inverse la liste s (opération 'sur place') ['w', 'v', 'u', 'xyz', 18, 'd', 'c', 10] >>> u # pendant ce temps-là, l'original n'a pas changé [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] |
Pour trier “sur place” la liste contenue dans une variable s, on écrit s.sort(), et pour obtenir une copie triée de cette liste, mais sans affecter l’original, on évalue l’expression sorted(s). Dans tous les cas, il y a deux arguments facultatifs : key=fonction (défaut key=None) pour préciser une clef de tri, et reverse=True/False (défaut reverse=False) pour inverser l’ordre du tri.
|
1 2 3 4 5 6 7 8 9 |
>>> from random import sample # importe la fonction sample du module random >>> s = sample(range(100,1000),10); s # liste de 10 entiers différents à trois chiffres [831, 348, 562, 879, 130, 864, 758, 886, 756, 355] >>> sorted(s) # renvoie la liste triée [130, 348, 355, 562, 756, 758, 831, 864, 879, 886] >>> s # mais l'original n'a pas été modifié [831, 348, 562, 879, 130, 864, 758, 886, 756, 355] >>> s.sort(); s # ici le tri s'effectue sur place [130, 348, 355, 562, 756, 758, 831, 864, 879, 886] |