3.1. Listes¶
3.1.1. Création de listes et opérations de base¶
Une liste est tout simplement une collection d’objets. On la déclare en séparant ses éléments par des virgules , et en les encadrant par des crochets [...].
In [1]: type([1,2,3])
Out[1]: list
Les objets contenus dans une même liste peuvent être de types différents.
In [2]: [1.23, 'abc', 45]
Out[2]: [1.23, 'abc', 45]
On peut même imbriquer des listes.
In [3]: [1.23, ["abc", "def", "ghi"], [45, 67]]
Out[3]: [1.23, ['abc', 'def', 'ghi'], [45, 67]]
L’opérateur + permet de concaténer des listes.
In [4]: [1.23, 'abc', 45] + [6, 'def', 'ghi', 7.89]
Out[4]: [1.23, 'abc', 45, 6, 'def', 'ghi', 7.89]
On devine alors l’action de l’opérateur * [1].
In [5]: [1.23, 'abc', 45] * 3
Out[5]: [1.23, 'abc', 45, 1.23, 'abc', 45, 1.23, 'abc', 45]
Note
On ne peut évidemment multiplier une liste que par un entier.
La fonction len permet de récupérer la longueur d’une liste.
In [6]: len([1.23, 'abc', 45])
Out[6]: 3
3.1.2. Accès aux éléments¶
On peut accéder aux éléments d’une liste via leurs indices et l’opérateur [ ].
In [7]: ma_liste = [25, 34, 48, 67]
In [8]: ma_liste[2]
Out[8]: 48
Avertissement
Il est à noter que les indices des listes commencent à 0 et non 1. Le dernier indice d’une liste de \(n\) éléments est donc \(n-1\) et non \(n\).
On peut bien sûr accéder à des éléments de listes imbriquées.
In [9]: ma_liste = [1.23, ["abc", "def", "ghi"], [45, 67]]
In [10]: ma_liste[1][2]
Out[10]: 'ghi'
On peut également accéder à des éléments d’une liste « par la fin ».
In [11]: ma_liste = ['a', 'b', 'c', 'd', 'e']
In [12]: ma_liste[-1]
Out[12]: 'e'
In [13]: ma_liste[-3]
Out[13]: 'c'
3.1.3. Modification des éléments¶
L’opérateur [ ] permet également de modifier les éléments d’une liste.
In [14]: ma_liste = [25, 34, 48, 67]
In [15]: ma_liste[2] = 666
In [16]: ma_liste
Out[16]: [25, 34, 666, 67]
Bien évidemment, cela fonctionne aussi pour les listes imbriquées.
In [17]: ma_liste = [1.23, ["abc", "def", "ghi"], [45, 67]]
In [18]: ma_liste[1][2] = "toto"
In [19]: ma_liste
Out[19]: [1.23, ['abc', 'def', 'toto'], [45, 67]]
3.1.4. Insertion et suppression d’éléments¶
Il existe plusieurs moyens d’ajouter des éléments à une liste.
La première méthode est de les ajouter un par un grâce aux méthodes append (insertion en fin de liste) ou insert (insertion à un endroit donné).
In [20]: ma_liste = ['a', 1, 'b']
In [21]: ma_liste.append(2)
In [22]: ma_liste
Out[22]: ['a', 1, 'b', 2]
In [23]: ma_liste.insert(2, 'toto')
In [24]: ma_liste
Out[24]: ['a', 1, 'toto', 'b', 2]
Pour ajouter plusieurs éléments d’affilée, on peut utiliser l’opérateur de concaténation + ou de concaténation/affectation += ou encore la méthode append.
In [25]: ma_liste = ['a', 1, 'b', 2]
In [26]: ma_liste = ma_liste + ['c', 3, 'd']
In [27]: ma_liste
Out[27]: ['a', 1, 'b', 2, 'c', 3, 'd']
In [28]: ma_liste += [4, 5]
In [29]: ma_liste
Out[29]: ['a', 1, 'b', 2, 'c', 3, 'd', 4, 5]
In [30]: ma_liste.extend(['e', 6, 'f'])
In [31]: ma_liste
Out[31]: ['a', 1, 'b', 2, 'c', 3, 'd', 4, 5, 'e', 6, 'f']
De même, il existe plusieurs façons de supprimer des éléments d’une liste.
Pour supprimer des éléments, on peut utiliser les méthodes pop (renvoie le dernier élément et le supprime de la liste) ou remove (supprime un élément de valeur donnée).
In [32]: ma_liste = ['a', 1, 'b', 2, 'c', 3]
In [33]: ma_liste.pop()
Out[33]: 3
In [34]: ma_liste
Out[34]: ['a', 1, 'b', 2, 'c']
In [35]: ma_liste.remove('b')
In [36]: ma_liste
Out[36]: ['a', 1, 2, 'c']
Note
La méthode remove ne supprime que la première occurence d’une valeur donnée.
In [37]: ma_liste = [1, 2, 3, 2, 4, 2]
In [38]: ma_liste.remove(2)
In [39]: ma_liste
Out[39]: [1, 3, 2, 4, 2]
La suppression d’éléments peut également se faire au moyen du mot-clé del [2].
In [40]: ma_liste = ['a', 1, 'b', 2, 'c', 3]
In [41]: del ma_liste[2]
In [42]: ma_liste
Out[42]: ['a', 1, 2, 'c', 3]
3.1.5. Sous-listes (slicing)¶
Il existe une syntaxe permettant de créer une sous-liste d’une liste.
In [43]: ma_liste = ['a', 'b', 'c', 'd', 'e', 'f']
In [44]: ma_liste[2:5]
Out[44]: ['c', 'd', 'e']
De manière générale, si li est une liste, alors li[a:b] renvoie la liste formée des éléments de la liste li dont les indices sont compris entre a (inclus) et b (non inclus).
Si a ou b sont omis, la sélection s’opére à partir du début ou jusqu’à la fin de la liste.
In [45]: ma_liste = ['a', 'b', 'c', 'd', 'e', 'f']
In [46]: ma_liste[2:]
Out[46]: ['c', 'd', 'e', 'f']
In [47]: ma_liste[:4]
Out[47]: ['a', 'b', 'c', 'd']
On peut encore sélectionner des éléments à intervalles réguliers.
In [48]: ma_liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
In [49]: ma_liste[2:9:3]
Out[49]: ['c', 'f', 'i']
In [50]: ma_liste[7:2:-2]
Out[50]: ['h', 'f', 'd']
Le slicing permet aussi de modifier les éléments d’une liste.
In [51]: ma_liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
In [52]: ma_liste[2:9:3]
Out[52]: ['c', 'f', 'i']
In [53]: ma_liste[2:9:3] = 'toto', 'tata', 'titi'
In [54]: ma_liste
Out[54]: ['a', 'b', 'toto', 'd', 'e', 'tata', 'g', 'h', 'titi', 'j', 'k', 'l']
On peut combiner le slicing et le mot-clé del pour supprimer plusieurs éléments à la fois.
In [55]: ma_liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
In [56]: ma_liste[5:10:2]
Out[56]: ['f', 'h', 'j']
In [57]: del ma_liste[5:10:2]
In [58]: ma_liste
Out[58]: ['a', 'b', 'c', 'd', 'e', 'g', 'i', 'k', 'l']
Notes