PYTHON : description rapide des listes
L'objet list de Python est un objet :
- séquentiel : on peut y accéder avec une boucle for numérique
- itérable : on peut y accéder avec une boucle for nominative
- mutable : en français, on dira modifiable après création (instanciation).
Cette fiche détaille l'utilisation des listes.
1 - Description des listes
Voyons d'abord comment créer une liste.
1a - Déclaration d'une liste
On définit une Liste à l'aide d'un caractère séparateur (un crochet [ ) signalant le début de la liste et on utilise un crochet ] dans l'autre sens pour signaler la fin de la liste.
Chaque élément de la liste est séparé des autres par une virgule jouant le rôle de caractère séparateur.
C'est un objet natif de Python, de la classe list.
ma_liste = [1,'a',45.2,"bonjour",'b'] crée une liste de 5 éléments contenant l'integer 1, le char a, le float 45.2, le string bonjour et le char b.
ma_liste = [1,'a',45.2,"bonjour",'b']
Si on veut afficher une liste, print(ma_liste) fonctionne.
>>> ma_liste = [1,'a',45.2,"bonjour",'b']
>>> ma_liste
[1,'a',45.2,'bonjour','b']
>>> print(ma_liste)
[1,'a',45.2,'bonjour','b']
>>> type(ma_liste)
<class 'list'>
Contrairement aux strings, il n'y a aucune différence entre le contenu d'une liste et son affichage avec print.
On notera qu'une liste peut contenir n'importe quel élément. Il ne s'agit pas nécessairement que d'integers ou que de strings ...
Il s'agit simplement d'éléments séparés par des virgules.
On peut même placer un objet (comme une liste) dans une liste.
>>> legumes = ['poivron','concombre','oignon']
>>> fruits = ['pomme','poire']
>>> ma_liste = [legumes,fruits]
>>> print(ma_liste)
[['poivron', 'concombre', 'oignon'], ['pomme', 'poire']]
Pour créer une liste contenant x fois le même élément, on peut utiliser ceci :
>>> ma_liste = ['a']*10
>>> ma_liste
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
Pour créer une liste contenant une succession de nombres, on peut utiliser la fonction range (qu'on détaille plus bas, lors de l'utilisation du for). Il faut alors l'associer à la fonction native list qui crée automatiquement une liste à partir d'un objet qu'on lui transmet. L'objet doit bien entendu être transformable en liste, il doit être composé d'une séquence d'éléments.
>>> ma_liste = list( range(0,11,2) )
>>> ma_liste
[0, 2, 4, 6, 8, 10]
On notera qu'on place ici des parenthèses puisque list(...) est bien une fonction native qui crée une liste. Pas de [] donc.
Dernier exemple : on peut créer une liste à partir d'un string :
>>> x = 'abcde'
>>> ma_liste = list( x )
>>> ma_liste
['a', 'b', 'c', 'd', 'e']
On peut sinon également utiliser une boucle pour définir le contenu d'une liste :
>>> x = [i*i for i in range(0,20,2)]
>>> x
[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
On commence par fournir le calcul à faire sur i puis on donne à la suite de for la liste des éléments i.
Il est temps de voir comment lire le contenu d'une liste.
1b - Objet ordonné et itérable
Une Liste est un ensemble ordonné de données : on peut y accéder en utilisant un index chiffré.
On peut accéder au contenu de l'index x en utilisant des crochets : [i].
Attention : la case du début est la case 0.
>>> ma_liste = [ 1, 'a', 45.2, "bonjour", 'b', ['fraises','framboises'] ]
>>> print(ma_liste[0])
1
>>> print(ma_liste[1])
a
On peut connaître la longueur d'un string en utilisant la fonction générale len(x) où x est l'objet à étudier.
>>> print(len(ma_liste))
6
On voit bien que ma_liste contient 6 éléments ( numérotés de 0 à 5).
- n°0 :
1 - n°1 :
'a' - n°2 :
45.2 - n°3 :
'bonjour' - n°4 :
'b' - n°5 :
['fraises','framboises']
On peut alors lire le contenu d'une liste en utilisant une boucle for associée à la longueur de la liste :
>>> x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
>>> for i in range(len(x)):
... print(x[i])
...
1
a
45.2
bonjour
b
['fraises', 'framboises']
Ce n'est pas le moyen le plus simple de lire les éléments un par un. On peut également lire le contenu d'une liste en utilisant une boucle for nominative : on dit que la Liste est itérable.
>>> x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
>>> for e in x:
... print(e)
...
1
a
45.2
bonjour
b
['fraises', 'framboises']
Attention : ici la variable e ne contient pas le numéro de l'élément mais bien l'élément à cette position. Nous aurions pu nommer cette variable e comme dans le cas précédent ( i ) mais c'est une source courante d'erreur. Ici, comme je sais que cela va contenir un élément, j'ai choisi de la noter e.
1c - Lecture rapide des éléments d'une liste
Pour lire le contenu des éléments de 0 à 5 (c'est à dire tant que élément < 6), on peut écrire :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
for i in range(0,6) : # On peut écrire plus simplement in range(6)
print(x[i])
1
a
45.2
bonjour
b
['fraises', 'framboises']
On obtient les éléments de 0 à 5 ( car (0,6) veut dire de i = 0 à i < 6).
On peut obtenir la liste permettant d'extraire ces données avec les instructions suivantes :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
print(x[0:6]) # On peut écrire plus simplement x[:6]
[1, 'a', 45.2, 'bonjour', 'b', ['fraises', 'framboises']]
Pour lire le contenu des cases de 2 à 5 ( car (2,6) veut dire de i = 2 à i < 6), on peut écrire :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
for i in range(2,6) : # On peut écrire plus simplement in range(6)
print(x[i])
45.2
bonjour
b
['fraises', 'framboises']
On obtient les éléments de 2 à 5.
On peut obtenir la liste contenant les éléments précédents avec les instructions suivantes :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
print(x[2:6])
[45.2, 'bonjour', 'b', ['fraises', 'framboises']]
Pour lire le contenu des cases de 2 à 5 de deux en deux, on peut écrire :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
for i in range(2,6,2) : # On peut écrire plus simplement in range(6)
print(x[i])
45.2
b
On obtient les éléments de 2 et 4 ( car (2,6,2) veut dire de i = 2 à i < 6 de 2 en 2).
On peut obtenir la liste ayant le même contenu avec les instructions suivantes :
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
print(x[2:6:2])
[45.2, 'b']
On peut omettre de noter certains paramètres. Il suffit de ne pas le mettre mais de placer le : suivant.
Si on ne place pas l'élément initial, l'interpréteur remplacera par 0.
Si on ne place pas l'élément final, l'interpréteur ira jusqu'au bout de la liste.
Si on ne place pas la valeur de l'itération, l'interpréteur augmentera de 1 en 1.
Ainsi les cas suivants sont équivalents :
>>> x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
>>> print(x[0:4:1])
[1, 'a', 45.2, 'bonjour']
>>> print(x[0:4])
[1, 'a', 45.2, 'bonjour']
>>> print(x[:4])
[1, 'a', 45.2, 'bonjour']
Et un dernier truc pour la route : comment inverser une liste ? Il suffit de lui dire de compter non pas en 1 mais en -1 !.
Ici, je ne précise ni le début de la lecture, ni la fin. J'ai donc noter :: pour indiquer que je donne uniquement la valeur de l'itération.
>>> x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
>>> print(x[::-1])
[['fraises', 'framboises'], 'b', 'bonjour', 45.2, 'a']
Nous aurions pu noter le début de la lecture par exemple :
>>> x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
>>> print(x[5::-1])
[['fraises', 'framboises'], 'b', 'bonjour', 45.2, 'a']
Pour lire une liste à l'envers, on peut même faire mieux encore avec la fonction reversed qui va renvoyer les index dans le sens inverse. C'est une fonction optimisée pour parcourir un objet itérable en sens inverse, elle sera donc normalement plus rapide que la méthode précédente qui est plus généraliste.
x = [1,'a',45.2,"bonjour",'b',['fraises','framboises']]
for e in reversed(x) :
print(e)
['fraises', 'framboises']
b
bonjour
45.2
a
1
Par contre, s'il s'agit de créer une nouvelle liste inversée, y = x[::-1] est plus adaptée. Vous verrez plus bas qu'il existe aussi une méthode pour modifier (en l'inversant) la liste actuelle.
1d - La Liste est mutable
Cela veut dire qu'on peut modifier une Liste après sa création.
Première conséquence : la modification par interaction directe est possible.
On peut modifier une liste en utilisant un code de ce type (contrairement aux strings) :
>>> x = ["Bonjour", " à ", "tous !"]
>>> id(x)
2676573460296
>>> x[1] = ' les '
>>> x[2] = ' gens !'
>>> x
['Bonjour', ' les ', ' gens !']
>>> id(x)
2676573460296
On voit bien que le contenu de x a changé par modification directe. De plus, il a bien gardé le même identifiant : x pointe toujours vers le même objet, ce n'est pas un objet différent ayant écrasé le précédent.
Deuxième conséquence : l'utilisation de la modification par l'opérateur + peut être contre-productive.
Lorsqu'on "modifie" une liste par 'concaténation',on crée par contre un nouvel objet. Il faut être vigilant sur ce point car on pourrait croire que puisque les listes sont mutables (modifiables) ont garde le même objet.
>>> x = [1,2,3]
>>> id(x)
2676573390920
>>> y = [4,5,6]
>>> x = x + y
>>> x
[1, 2, 3, 4, 5, 6]
>>> id(x)
2676573390856
On voit ici clairement qu'on utilise le même nom x mais qu'on fait référence à deux entités différentes.
On peut se demander en quoi c'est génant. On change d'id, et alors ?
Pour comprendre le problème, il faut avoir connaissance de la façon dont se passe la 'copie' d'une liste via l'opérateur =. C'est la partie suivante.
1e - Utilisation de l'opérateur =
Une liste est traitée comme n'importe quel objet par Python, contrairement aux strings.
Voyons ce que cela implique pour la 'copie' de listes :
>>> x = [1,2,3]
>>> id(x)
2676573391048
>>> y = x
>>> id(y)
2676573391048
Jusqu'à présent, rien de nouveau par rapport aux strings. Python ne crée pas réellement un nouvel objet mais juste un alias : il pointe vers la même case mémoire.
Par contre, les strings sont non mutables : si on modifie x, on crée une nouvelle string nommée x mais qui pointe vers une autre case mémoire. x et y ne pointent donc plus vers le même objet et modifier x ne modifie pas y.
Ici, c'est différent avec les listes : si on s'arrange pour modifier la liste x (sans utilisation destructrice d'un + par exemple), x et y font continuer à pointer vers le même objet et modifier x va également permettre à son alias d'afficher la modification.
>>> x = [1,2,3]
>>> y = x
>>> id(x)
2676573391048
>>> id(y)
2676573391048
>>> y
[1,2,3]
>>> x[0] = 10
>>> x
[10, 2, 3]
>>> id(x)
2676573391048
>>> y
[10, 2, 3]
>>> id(y)
2676573391048
L'utilisation du signe = dans y=x crée un alias de x et non pas réelleemnt une nouvelle liste. On obtient deux façons x et y de nommer le même objet.
Alors, en quoi l'utilisation du + est-elle à éviter ?
Si vous vouliez garder un lien entre x et y, l'utilisation de + va la briser : x = x + ['a'] ne va pas réellement rajouter 'a' à votre liste : cela va créer une nouvelle liste à partir de l'ancienne liste x et du nouvel élément. Mais votre nouvelle liste x ne va plus pointer vers la même adresse mémoire que y !
Un exemple pour concrétiser cela :
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> id(x)
2676573235400
>>> y = x
>>> y
[1, 2, 3]
>>> id(y)
2676573235400
>>> x = x + [4]
>>> x
[1, 2, 3, 4]
>>> id(x)
2676573390856
>>> y
[1, 2, 3]
>>> id(y)
2676573235400
On voit bien que x et y pointent vers le même objet au début mais que lorsqu'on modifie x, y ne suit pas.
Et si je veux juste une copie d'une liste ? Dans ce cas, il faut utiliser une méthode particulière qu'on applique à la liste copy() :
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> id(x)
2676573518344
>>> y = x.copy()
>>> y
[1, 2, 3]
>>> id(y)
2676573389384
Les autres fonctions sont traitées dans la dernière partie, mais celle-ci est vraiment pratique dès qu'on veut juste une copie et pas un alias.
Sinon, il faut sortir un code du type :
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> id(x)
2676573518344
>>> y = x[:]
>>> y
[1, 2, 3]
>>> id(x)
2676573518472
Ici, on crée une nouvelle liste car on va lire le contenu de a avec x[:] qui est interprété en x[0:len(x):1], c'est dire qu'il lit toute la liste de l'élément 0 à l'élément final, de un en un.
Autre manière de faire :
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> id(x)
2676573518344
>>> y = x + []
>>> y
[1, 2, 3]
>>> id(x)
2676573518472
En gros, l'utilsation du + avec une liste vide [] va provoquer la création d'un nouvel objet avec une adresse différente de x mais avec le même contenu. Ca fonctionne mais autant utiliser la méthode qui va bien.
1f - Test d'égalité de deux listes
On peut comparer deux listes de deux façons :
- A l'aide d'un test logique
x == yqui teste l'égalité de contenu. - A l'aide d'un test
x is yqui teste l'égalité d'identité (même objet). On peut dire queisteste si x et y sont deux alias du même objet.
Si vous n'allez pas plus loin dans cette sous-partie, retenez ceci : Pour comparer le contenu de deux listes, utilisez toujours ==..
Ici, on crée deux listes a et b de contenu identique mais ayant des identifiants (ou adresses) différents.
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> id(a)
2676573169992
>>> b = [1,2,3]
>>> b
[1, 2, 3]
>>> id(b)
2676573518728
>>> a == b
True
>>> a is b
False
C'est clair : Python parvient à dire que les deux listes ont le même contenu mais ne sont pas réellement le même objet. Ainsi modifier proprement a ne modifie pas b.
Donc, attention : pour tester l'égalité du contenu, il faut utiliser ==.
1g - Test d'appartenance
On ne peut pas directement savoir si une liste est incluse dans une autre. Il faudra utiliser une fonction ou une méthode propre aux listes.
Par contre, pour savoir si une liste a contient un élément e, on peut par contre utiliser le test in :
>>> a = [1,2,3,4]
>>> e = 3
>>> e in a
True
>>> 7 in a
False
Attention, le test vérifie aussi le type :
>>> a = [1,2,3,4]
>>> 2 in a
True
>>> "2" in a
False
2 - Méthodes d'ajout et suppression des éléments de liste
On peut ajouter et supprimer des éléments en utilisant les intervalles (le slicing). Mais il existe aussi des méthodes qui permettent de rajouter ou de supprimer des éléments de la liste sans modifier l'adresse de la liste : on reste donc réellement sur le même objet, on ne changera pas son numéro d'identification.
Pour chaque méthode, je fournis dans l'exemple l'équivalent en utilisant un intervalle.
Des exemples d'utilisation se trouvent sous le tableau.
Attention : les crochets [ ] indiquent que l'argument qu'on y touve est optionnel.
| Méthode | Action réalisée |
|---|---|
list.append(x) |
Rajoute l'élément Si |
list.extend(x_iter) |
Comme au dessus mais l'argument On rajoute alors les éléments internes de |
list.insert(i,x) |
Rajoute l'élément Si on utilise |
list.pop([i]) |
Supprime de la liste l'élément situé à la position i et le renvoie en retour. On peut donc stocker l'élément retiré dans une variable au besoin en notant par exemple Le paramètre i est optionnel (notation [i]). Si vous utilisez simplement Permet de gérer les flux en file ou en pile. |
list.remove(x) |
Supprime de la liste le premier élément de la liste qui est égal à Une exception est levée s’il existe aucun élément avec cette valeur. |
list.pop([i]) |
Supprime de la liste l'élément situé à la position i et le renvoie en retour. On peut donc stocker l'élément retiré dans une variable au besoin en notant par exemple Le paramètre i est optionnel (notation [i]). Si vous utilisez simplement |
str.count(sub[, start[, end]]) | Renvoie le nombre d'occurences du string sub dans le string str. On peut rajouter les numéros de début et de fin des cases à analyser. |
Exemple : pour list.append(x)
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> a.append('4')
>>> a
[1, 2, 3, '4']
>>> b = [7,8,9]
>>> a.append(b)
>>> a
[1, 2, 3, '4', [7, 8, 9]]
On remarque que a est modifié par la méthode. Il ne faut pas noter quelque chose comme a = a.append(b) qui crée alors une nouvelle liste nommée a qui va écraser l'ancienne. La modification se fait directement.
Attention : on rajoute l'élément x, on ne rajoute pas les éléments de x si x est itérable. Ici, on a bien rajouté une liste b dans la liste a et pas les élements de b dans a.
Le code équivalent avec l'intervalle serait :
a[len(a):] = ['4']
a[len(a):] = [b]
On rajoute les éléments d'une liste à la suite du dernier élément. D'où la présence du : après len(a).
Cette méthode permet donc de considérer les listes comme des piles de livres : on rajoute les éléments au dessus des derniers éléments.
Exemple : pour list.extend(x_iter)
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> b = [7,8,9]
>>> a.extend(b)
>>> a
[1, 2, 3, '4', 7, 8, 9]
Le code équivalent avec l'intervalle serait :
a[len(a):] = b
On rajoute les éléments d'une liste à la suite du dernier élément. D'où la présence du : après len(a).
Exemple : pour list.insert(i,x)
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> a.insert(0,'0')
>>> a
['0', 1, 2, 3]
>>> a.insert(len(a),'4')
>>> a
['0', 1, 2, 3, '4']
>>> b = [7,8,9]
>>> a.insert(3,b)
>>> a
['0', 1, 2, [7, 8, 9], 3, '4']
On rajoute '0' en tant que premier élément avec insert(0, ...).
On rajoute '4' en tant que dernier élément (d'ailleurs utiliser a.insert(len(a),truc) revient à utiliser a.append(truc).
On rajoute une liste b avant l'élément qui était à la position 3 avant cela. N'oubliez pas que le premier élément est l'élément 0.
Attention : on rajoute l'élément x, on ne rajoute pas les éléments de x si x est itérable. Ici, on a bien rajouté une liste b dans la liste a et pas les élements de b dans a.
Au final, on obtient alors :
Pour faire la même chose avec les éléments de la liste b, c'est plus compliqué puisque x ne peut être qu'un élément unique :
for e in b[::-1] :
a.insert(3,e)
Cela donnerait alors :
['0', 1, 2, 7, 8, 9, 3, '4']
Pourquoi commencer par le dernier élément ? Tout simplement car on pousse tout vers la droite à chaque fois :
['0', 1, 2, 3, '4'] devient :
['0', 1, 2, 9, 3, '4'] qui devient :
['0', 1, 2, 8, 9, 3, '4'] qui permet d'obtenir :
['0', 1, 2, 7, 8, 9, 3, '4']
Le code équivalent avec l'intervalle pour insérer une liste b serait :
a[3:3] = [b]
On place l'élément entre la position n°3 pour le début et la position n°3 pour la fin. On pousse donc les anciens éléments 3 et plus.
Notez qu'on place les crochets autour de b pour dire de rajouter la liste et pas ses éléments.
Pour rajouter les éléments de b, nous aurions utilisé b, sans les crochets. C'est plus facile qu'avec la méthode.
a[3:3] = b
Exemple : pour list.pop([i])
>>> a = ['0', 1, 2, [7, 8, 9], 3, '4']
>>> a
['0', 1, 2, [7, 8, 9], 3, '4']
>>> a.pop()
'4'
>>> a
['0', 1, 2, [7, 8, 9], 3]
On voit qu'on supprime le dernier élément et que la méthode renvoie l'élément qu'elle a détruit. Nous aurions pu noter plutôt ceci pour récuperer la valeur :
>>> a = ['0', 1, 2, [7, 8, 9], 3, '4']
>>> a
['0', 1, 2, [7, 8, 9], 3, '4']
>>> z = a.pop()
>>> a
['0', 1, 2, [7, 8, 9], 3]
>>> z
'4'
L'association des méthodes append() et pop() permet donc réellement de gérer les informations comme une pile : on rajouter toujours au sommet et on traite d'abord le sommet la pile. Ainsi, ce qui est en début de liste et en bas de la pile et ne pourra être traiter qu'une fois que ce qui est au dessus sera traité. Si vous avez un système dont la priorité est de réagir d'abord aux derniers événements, cette association de méthodes est faite pour vous :
Bien. Imaginons maintenant que nous voulions supprimer et récupérer la liste [7,8,9]. Elle est en position 3, il doit donc utiliser la méthode pop(3) :
>>> a = ['0', 1, 2, [7, 8, 9], 3]
>>> a
['0', 1, 2, [7, 8, 9], 3]
>>> z = a.pop(3)
>>> a
['0', 1, 2, 3]
>>> z
[7, 8, 9]
Une utilisation concrète est le pop(0) pour créer l'inverse de la pile à savoir : la file. Comme dans une file d'attente. Le premier arrivé sera le premier servi. Et on rajoute les derniers à l'arrière :
>>> a = ['a', 'b', 'c', 'd']
>>> a
['a', 'b', 'c', 'd']
>>> z = a.pop(0)
>>> a
['b', 'c', 'd']
>>> print("On traite le cas de ",z)
On traite le cas de a
>>> z = a.pop(0)
>>> a
['c', 'd']
>>> print("On traite le cas de ",z)
On traite le cas de b
Exemple : pour list.remove(x)
>>> a = ['a', 'b', 'c', 'd', 'a']
>>> a
['a, 'b', 'c', 'd', 'a']
>>> a.remove('a')
>>> a
['b', 'c', 'd', 'a']
>>> a.remove('d')
>>> a
['b', 'c', 'a']
>>> a.remove('4')
ValueError: list.remove(x): x not in list
Notez bien qu'on enlève d'abord les éléments ayant le numéro d'index le plus petit. L'exception ValueError devra elle être gérer par l'utilisation d'un try ou avec une vérification préliminaire à l'action du remove.
Il existe également une fonction permettant de supprimer un élément d'une liste. La fonction del().
Quelques exemples d'utilisation où j'ai placé en bleu les valeurs ciblées par le del situé en dessous.
>>> x = [i*i for i in range(0,20,2)]
>>> x
[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
>>> del x[1]
>>> x
[0, 16, 36, 64, 100, 144, 196, 256, 324]
>>> del x[2]
>>> x
[0, 16, 64, 100, 144, 196, 256, 324]
>>> del x[-1]
>>> x
[0, 16, 64, 100, 144, 196, 256]
>>> del x[1:3]
>>> x
[0, 100, 144, 196, 256]
>>> del x[::2]
>>> x
[100, 196]
3 - Les autres méthodes
Il existe d'autres méthodes que celles qui permettent de rajouter ou de supprimer des éléments dans les listes.
Des exemples d'utilisation se trouvent sous le tableau.
Attention : les crochets [ ] indiquent que l'argument qu'on y touve est optionnel.
| Méthode | Action réalisée |
|---|---|
list.clear() |
Supprime tous les éléments d'une liste, qui se retrouve donc vide. |
list.index(x[, start[, end]]) |
Renvoie le plus petit numéro d'index correspondant à l'élément x. Renvoie une exception Les valeurs start et end sont optionnelles et se comporte comme un intervalle. Les valeurs par défaut sont 0 et la longueur de la liste. |
list.count(x) |
Renvoie le nombre de fois où l'élément x est présent dans la liste. |
list.sort(key=None, reverse=False) |
Trie les éléments sur place, (les arguments peuvent personaliser le tri, voir sorted() pour leur explication). |
list.copy() |
Renvoie une copie superficielle de la liste. Équivalent à a[:]. |
list.reverse() |
Inverse l’ordre des éléments de la liste. |
Exemple : pour list.clear()
>>> a = ['a', 'b', 'c', 'd', 'a']
>>> a
['a, 'b', 'c', 'd', 'a']
>>> a.clear()
>>> a
[]
Exemple : pour list.index(x[, start[, end]])
>>> a = ['a', 'b', 'c', 'd', 'a']
>>> a
['a, 'b', 'c', 'd', 'a']
>>> a.index('a')
0
>>> a.index('d')
3
>>> a.index('z')
ValueError: 'z' is not in list
Notez bien qu'on détecte d'abord les éléments ayant le numéro d'index le plus petit. L'exception ValueError devra elle être gérer par l'utilisation d'un try ou d'un count.
Exemple : pour list.count(x)
>>> a = ['a', 'b', 'c', 'd', 'a']
>>> a
['a, 'b', 'c', 'd', 'a']
>>> a.count('a')
2
>>> a.count('b')
1
>>> a.count('z')
0