Méthodes de listes en

À propos de Méthodes de listes

Un list est une collection mutable d'éléments en séquence. Comme la plupart des collections (voir les types natifs tuple, dict et set), les tableaux peuvent contenir des références vers n'importe quel type de données (voire plusieurs à la fois), y compris d'autres tableaux. En Python, ils sont considérés comme une séquence et peuvent être copiés en tout ou en partie grâce à la notation de tranche. Comme toute séquence, les éléments des lists peuvent être référencés par un 0-based index depuis la gauche, ou un -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 avec la construction for item in <list>, et avec for index, item in enumerate(<list>) quand on a besoin à la fois de l'élément et de son indice.

Python fournit de nombreuses méthodes utiles pour manipuler les tableaux.

Comme les tableaux sont mutables, les méthodes de tableau modifient l'objet tableau d'origine passé à la méthode. Si la modification n'est pas souhaitable, il faut faire une shallow copy (au minimum) du list d'origine, via slice ou <list>.copy().

Ajouter des éléments

Pour ajouter des éléments à la fin d'un tableau existant, on utilise <list>.append(<item>) :

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

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

Plutôt que de faire un append, <list>.insert(<index>, <item>) insère l'élément à un indice précis dans le tableau. <index> est l'indice de l'élément avant lequel on veut faire apparaître le nouvel élément. <item> est l'élément à insérer.

Remarque : si <index> vaut 0, l'élément est ajouté au début du tableau. Si <index> est supérieur au dernier indice du tableau, 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]

On peut combiner un iterable avec un tableau existant (en concaténant les deux) grâce à <list>.extend(<iterable>). <list>.extend(<iterable>) dépaquette l'itérable fourni et ajoute ses éléments, dans le même ordre, à la fin du tableau cible. Dans ce cas, utiliser <list>.append(<item>) 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]

Supprimer des éléments

<list>.remove(<item>) permet de supprimer un élément du tableau. <list>.remove(<item>) lève une ValueError si l'élément n'est pas présent dans le tableau.

>>> 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, la méthode <list>.pop(<index>) supprime et return un élément, que l'on peut ensuite utiliser.

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

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

>>> numbers
[2, 3]
>>> numbers.pop()
3

>>> numbers
[2]

# This will throw an error because there is only index 0.
>>> 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'un list avec <list>.clear(). Cette méthode ne prend aucun paramètre.

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

>>> numbers
[]

Inverser et réordonner

On peut inverser l'ordre des éléments d'un tableau sur place avec <list>.reverse(). Cela modifie le tableau d'origine.

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

>>> numbers
[3, 2, 1]

On peut réordonner un tableau sur place à l'aide de <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"]

Pour trier un tableau dans l'ordre décroissant, passe un argument reverse=True à la méthode :

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

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

Quand on ne souhaite pas modifier le list d'origine, on peut utiliser les fonctions natives sorted() et reversed(). sorted(<list>) renvoie une copie triée et prend les mêmes paramètres que <list>.sort(). reversed(<list>) renvoie un itérateur qui produit les éléments du tableau dans l'ordre inverse. Les Iterators seront traités en détail dans un autre exercice.

Occurrences d'un élément dans un tableau

Pour connaître le nombre d'occurrences d'un élément dans un tableau, on peut utiliser <list>.count(<item>). Cette méthode renvoie le nombre total de fois où <item> apparaît comme élément du tableau.

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

>>> items.count(1)
3

Trouver l'indice des éléments

<list>.index(<item>) renvoie le numéro d'indice de la première occurrence de l'élément passé. S'il n'y a aucune occurrence, une ValueError est levée. L'indexation est 0-based en partant de la gauche, ce qui signifie que la position du premier élément est l'indice 0. L'indexation depuis la droite est également prise en charge, en commençant par l'indice -1.

>>> items = [7, 4, 1, 0, 2, 5]
>>> items.index(4)
1

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

Fournir les indices start et end permet de chercher dans une section précise du tableau :

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
>>> names.index("Tina")
0

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

Si la position exacte d'un élément n'est pas nécessaire, l'opérateur natif in est plus efficace pour vérifier l'appartenance.

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

>>> "Thomas" in names
True

Faire des copies

Rappelle-toi qu'en Python, les variables sont des noms qui pointent vers des objets sous-jacents. Un nom peut être lié ou relié à différents objets tout au long de la vie d'un programme. Affecter un objet list à un nouveau nom de variable ne copie ni l'objet, ni aucune des données qu'il référence. Le nouveau nom et l'ancien pointeront tous les deux vers le même objet list. De plus, les tableaux sont des objets de type conteneur : pour économiser de l'espace, les conteneurs ne contiennent que des références vers les éléments, pas les éléments eux-mêmes. Cette « optimisation » peut avoir des conséquences inattendues pour qui n'y prend pas garde.

<list>.copy() crée un nouvel objet list, mais ne crée pas de nouveaux objets pour les éléments référencés du tableau : la copie est « superficielle ». Une shallow copy suffit généralement lorsqu'on veut ajouter ou supprimer des éléments dans l'un des objets list sans modifier l'autre. Mais s'il y a la moindre chance que les éléments sous-jacents d'un list soient modifiés par accident (et que cela modifie du même coup toutes les copies superficielles liées), il faut utiliser copy.deepcopy() du module copy pour créer une copie complète, ou « profonde », de toutes les références et de tous les objets.

Pour une explication détaillée du comportement des noms, des valeurs, des tableaux et des tableaux imbriqués, jette un œil à cet excellent article de blog de Ned Batchelder : Names and values: making a game board. Shallow vs Deep Copying of Python Objects offre également un bon panorama des points à considérer lors d'une copie.