2.7. Listes

Une liste est une séquence ordonnée et mutable de valeurs. Contrairement aux chaînes de caractères et aux octets, les listes peuvent contenir des valeurs de n’importe quel type, et vous pouvez modifier, ajouter ou supprimer des éléments sur place.

2.7.1. Créer des listes

Les crochets créent un littéral de liste :

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

Le constructeur list construit une liste à partir de n’importe quel itérable :

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. Longueur, indexation et découpage

len() renvoie le nombre d’éléments. L’indexation et le découpage fonctionnent de la même manière que pour les chaînes de caractères – les positions commencent à 0, les indices négatifs comptent depuis la fin, et un découpage hors de la plage valide est silencieusement rogné plutôt que de déclencher une erreur :

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

Les indices positifs comptent depuis le début ; les indices négatifs comptent depuis la fin.

La syntaxe de découpage est un raccourci pour un objet slice que Python construit en coulisses. nums[1:4] est identique à nums[slice(1, 4)]. Vous en construisez rarement un à la main, mais slice() est parfois utile pour stocker un découpage en tant que valeur réutilisable :

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. Modifier une liste

Les listes prennent en charge l’affectation indexée et découpée sur place :

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

Les méthodes de liste les plus courantes :

• list.append() – ajoute un seul élément à la fin.

• list.extend() – ajoute chaque élément d’un itérable.

• list.insert() – insère à une position donnée.

• list.remove() – supprime la première occurrence d’une valeur.

• list.pop() – supprime et renvoie un élément (le dernier par défaut).

• list.clear() – supprime tous les éléments.

• list.sort() – trie sur place. Passez reverse=True pour un ordre décroissant.

• list.reverse() – inverse sur place.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

Ces méthodes modifient la liste sur place et renvoient None. Écrire

nums = nums.sort()    # nums is now None -- common bug

n’est presque jamais ce que vous voulez ; la liste nums originale a bien été triée, mais l’affectation écrase ensuite le nom avec la valeur de retour. Soit vous appelez nums.sort() sur sa propre ligne, soit vous utilisez la fonction native sorted() pour obtenir une nouvelle liste triée sans modifier l’originale.

2.7.4. Opérateurs

• + concatène deux listes en une nouvelle liste.

• * répète une liste.

• in teste l’appartenance.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. Itérer sur une liste

Une boucle for parcourt les éléments dans l’ordre :

for n in [10, 20, 30]:
    print(n)

2.7.6. Alias et mutation

Une liste est une valeur unique en mémoire ; plusieurs noms peuvent pointer vers la même liste. Une mutation effectuée via un nom est visible par tous les autres noms qui pointent vers la même liste.

a et b pointent tous deux vers la même liste. Une mutation effectuée via l’un ou l’autre nom modifie ce que voit chaque autre nom.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

Pour faire une copie indépendante, découpez la liste entière ou appelez le constructeur list :

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

Cela ne copie que la liste de premier niveau ; les listes imbriquées restent partagées entre l’originale et la copie.