Les montagnes russes colossales de Chaitana

Une list est une collection modifiable d'éléments en séquence. Comme la plupart des collections (voir les types natifs tuple, dict et set), les tableaux peuvent référencer n'importe quel type (ou plusieurs types) de données, y compris d'autres tableaux. On peut copier un tableau en tout ou en partie grâce à la notation de tranche ou en utilisant <list>.copy(). Comme toute séquence, les éléments d'une list sont référencés par leur 0-based index depuis la gauche, ou leur -1-based index depuis la droite.

Les tableaux prennent en charge à la fois les opérations de séquence courantes et les opérations de séquence mutables, comme min(<list>)/max(<list>), <list>.index(), <list>.append() et <list>.reverse(). On peut parcourir les éléments d'une list avec la construction for item in <list>. On peut utiliser for index, item in enumerate(<list>) lorsqu'on a besoin à la fois de l'indice et de la valeur d'un élément.

Python fournit aussi de nombreuses méthodes de liste utiles pour travailler avec les tableaux. Une sélection de ces list methods est présentée ci-dessous.

Note que lorsqu'on manipule une list avec une list-method, on modifie l'objet tableau qui a été passé. Si on ne souhaite pas modifier la list d'origine, il faut au moins en faire une shallow copy via une tranche ou <list>.copy().

Ajoute des éléments

Pour ajouter un élément à la fin ou du « côté droit » d'un tableau existant, utilise <list>.append(<item>) :

>>> numbers = [1, 2, 3]
>>> numbers.append(9)

>>> numbers
[1, 2, 3, 9]

Plutôt que d'ajouter en fin de tableau, <list>.insert() permet d'insérer l'élément à un indice précis du tableau. Elle prend 2 paramètres :

1. le <index> auquel on souhaite insérer l'élément ;
2. le <item> à insérer.

Note : si l'index donné est 0, l'élément est ajouté au début (« côté gauche ») de la list. Si l'index fourni est supérieur au dernier index de la list, l'élément est ajouté à la dernière position, ce qui équivaut à utiliser <list>.append(<item>).

>>> numbers = [1, 2, 3]
>>> numbers.insert(0, -2)

>>> numbers
[-2, 1, 2, 3]

>>> numbers.insert(1, 0)

>>> numbers
[-2, 0, 1, 2, 3]

<list>.extend(<item>) permet de combiner un tableau existant avec les éléments d'un autre itérable (par exemple un set, un tuple, un str ou une list). L'itérable est dépaqueté et ses éléments sont ajoutés dans l'ordre (utiliser <list>.append(<item>) dans ce cas ajouterait l'itérable entier comme un seul élément.).

>>> numbers = [1, 2, 3]
>>> other_numbers = [5, 6, 7]

>>> numbers.extend(other_numbers)

>>> numbers
[1, 2, 3, 5, 6, 7]

>>> numbers.extend([8, 9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9]

>>> numbers.append([8,9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9, [8, 9]]

Supprime des éléments

Pour supprimer un élément d'un tableau, utilise <list>.remove(<item>) en passant l'élément à supprimer en argument. <list>.remove(<item>) lève une ValueError si l'élément n'est pas présent dans la list.

>>> numbers = [1, 2, 3]
>>> numbers.remove(2)

>>> numbers
[1, 3]

# Trying to remove a value that is not in the list throws a ValueError
>>> numbers.remove(0)
ValueError: list.remove(x): x not in list

Sinon, utiliser la méthode <list>.pop(<index>) permet à la fois de supprimer et de return un élément pour l'utiliser.

<list>.pop(<index>) prend un paramètre facultatif : l'index de l'élément à supprimer et à renvoyer. Si l'argument index (facultatif) n'est pas précisé, le dernier élément de la list est supprimé et renvoyé. Si l'index indiqué est supérieur à l'index du dernier élément, une IndexError est levée.

>>> numbers = [1, 2, 3]

>>> numbers.pop(0)
1

>>> numbers
[2, 3]

>>> numbers.pop()
3

>>> numbers
[2]

>>> numbers.pop(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

On peut supprimer tous les éléments d'une list avec list.clear(). Elle ne prend aucun paramètre.

>>> numbers = [1, 2, 3]
>>> numbers.clear()

>>> numbers
[]

Inverse et réordonne

La méthode <list>.reverse() inverse l'ordre des éléments sur place.

>>> numbers = [1, 2, 3]
>>> numbers.reverse()

>>> numbers
[3, 2, 1]

On peut réordonner un tableau sur place grâce à <list>.sort(). L'ordre de tri par défaut est croissant en partant de la gauche. La documentation Python propose d'autres conseils et techniques de tri.

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

# The default sort order is *ascending*.
>>> names.sort()

>>> names
["Bruce", "Natasha", "Thor", "Tony"]

Si on souhaite un ordre décroissant, passe l'argument reverse=True :

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]
>>> names.sort(reverse=True)

>>> names
["Tony", "Thor", "Natasha", "Bruce"]

Lorsqu'on ne souhaite pas modifier le tableau d'origine, on peut utiliser la fonction native sorted(<iterable>) pour renvoyer une copie triée.

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

>>> sorted(names)
['Bruce', 'Natasha', 'Thor', 'Tony']

Occurrences d'un élément dans un tableau

On peut calculer le nombre d'occurrences d'un élément dans un tableau à l'aide de list.count(<item>). Elle prend en argument l'item à compter et renvoie le nombre total de fois où cet élément apparaît dans la list.

>>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]

>>> items.count(1)
3

Trouve l'indice des éléments

<list>.index(<item>) renvoie le numéro d'index de la première occurrence d'un élément passé en argument. S'il n'y a aucune occurrence, une ValueError est levée. Si la position exacte d'un élément n'est pas nécessaire, l'opérateur natif in est plus efficace pour vérifier qu'un tableau contient une valeur donnée.

L'indexation part de zéro à gauche, donc la position du « premier » élément est 0. L'indexation fonctionne aussi depuis la droite, en commençant par -1.

>>> items = [7, 4, 1, 0, 2, 5]

>>> items.index(4)
1

>>> items.index(10)
ValueError: 10 is not in list

On peut aussi fournir les indices start et end pour limiter la recherche à une section précise de la lists :

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]

>>> names.index("Tina")
0

>>> names.index("Tina", 2, 5)
3