Les listes
Une liste est une "collection" d'objets indicés.
Les exemples ci-dessous illustrent la façon dont les éléments sont indicés.
Vous retiendrez également de ces exemples les diverses méthodes de parcours des éléments de la liste.
# une liste de nombres
a = [2, 10, 5//3, 7.2, 8]
print("Longueur de la liste a : ", len(a) )
print("La liste : ", a)
On obtient :
Longueur de la liste a : 5
La liste : [2, 10, 1, 7.2, 8]
# une liste de nombres
a = [2, 10, 5//3, 7.2, 8]
print("Contenu, élément un à un : ", a[0],a[1],a[2],a[3], a[4] )
print('\n')
print('Parcours des éléments avec une boucle sur les indices :')
for i in range(len(a)) :
print(a[i],end=', ')
print('\n')
On obtient :
Contenu, élément un à un : 2 10 1 7.2 8
Parcours des éléments avec une boucle sur les indices :
2, 10, 1, 7.2, 8,
# une liste de nombres
a = [2, 10, 5//3, 7.2, 8]
print('Parcours des éléments avec une boucle sans les indices :')
for x in a :
print(x,end='; ')
print('\n')
print('Parcours des éléments avec indices et éléments :')
for i,x in enumerate(a) :
print("Le terme d'indice {} est {}.".format(i,x) )
On obtient :
Parcours des éléments avec une boucle sans les indices :
2; 10; 1; 7.2; 8;
Parcours des éléments avec indices et éléments :
Le terme d'indice 0 est 2.
Le terme d'indice 1 est 10.
Le terme d'indice 2 est 1.
Le terme d'indice 3 est 7.2.
Le terme d'indice 4 est 8.
On retiendra que les indices, comme pour les chaînes de caractères, commencent à zéro et non à un.
Le dernier indice est donc len(a)-1 et non len(a).
Autre exemple :
def f(x) :
return 5*x**2+3*x+1
# une liste contenant divers objets :
a = [2, 'coucou', f, f(7)]
print("Longueur de la liste a : ", len(a) )
print("La liste : ", a)
print('\n')
print('Les éléments de la liste :')
for i, x in enumerate(a) :
print("Le terme d'indice {} est {}.".format(i,x))
print('\n')
print('Les types des éléments de la liste :')
for i, x in enumerate(a) :
print( "Le type du terme d'indice {} est {}.".format(i,type(x)) )
print('\n')
On obtient :
Longueur de la liste a : 4
La liste : [2, 'coucou', function f at 0x7f29b4ab8bf8, 267]
Les éléments de la liste :
Le terme d'indice 0 est 2.
Le terme d'indice 1 est coucou.
Le terme d'indice 2 est function f at 0x7f29b4ab8bf8.
Le terme d'indice 3 est 267.
Les types des éléments de la liste :
Le type du terme d'indice 0 est class 'int'.
Le type du terme d'indice 1 est class 'str'.
Le type du terme d'indice 2 est class 'function'.
Le type du terme d'indice 3 est class 'int'.
Une liste peut donc contenir des objets de types différents.
Créer une liste
Liste vide
Il s'agit de la liste []. Elle permet, par exemple, d'initialisr une variable de type liste au début d'une fonction.
maliste = []
Concaténer
Comme pour les chaines de caractères, on utiliser l'opérateur +. Il crée une nouvelle liste qui contient les éléments des deux opérandes mis bout-à-bout.
Exemple :
L = [ 1, 2, 5] + [ 'a', 'toto' , 9]
print(L)
Le résultat :
[ 1, 2, 5, 'a', 'toto' , 9]
Liste de n éléments identiques
Comme pour les chaines de caractères, c'est le résultat de l'opérateur * :
L = [ 19] * 5
print(L)
Le résultat :
[ 19, 19, 19, 19, 19]
Attention ! Cette technique ne doit qu'exceptionnellement être utilisée pour créer une liste de listes. En effet, les listes recopiées sont en fait des références à la même liste de départ, qui si elle est modifiée répercute cette modification à toutes les autres.
L = [ [1,2]]*3
print("Liste originale : ", L)
L[0][0] = 5 # on modiie le premier élément de la première liste
print ("Liste modifiée : ", L)
Le résultat :
Liste originale : [[1,2], [1,2], [1,2]]
Liste modifiée : [[5,2], [5,2], [5,2]]
On observe que les autres listes aussi sont modifiées, en fait ce ne sont pas des copies indépendantes mais des références à la première liste qui sont créées. On traitera plus en détail de ce point plus loin.
Fonction list
Elle est utilisée pour créer une nouvelle liste. Nous l'utiliserons dans 3 cas principalement.
#premier cas : liste vide
L1 = list()
#deuxième cas : liste de caractères
L2 = list("abracadabra")
#troisième cas : liste de nombres
L3 = list(range(14,18))
print ("L1 : ", L1)
print ("L2 : ", L2)
print ("L3 : ", L3)
Le résultat :
L1 : []
L2 : ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"]
L3 : [14, 15, 16, 17]
La première instruction est un synonyme de L1 = []. Dans les deux autres cas, on transforme en liste un objet que l'on peut parcourir avec un for.
Avec un for : listes en compréhension (approfondissement)
La création des listes L2 et L3 ci-dessus peut être codée d'une autre manière en python, qui est à peu près synonyme.
L2 = [ x for x in "abracadabra" ]
L3 = [ x for x in range(14,18) ]
print ("L2 : ", L2)
print ("L3 : ", L3)
Le résultat :
L2 : ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"]
L3 : [14, 15, 16, 17]
Cette méthode peut être généralisée en effectuant un traitement sur l'élément qui parcourt la liste initiale.
#liste des dix premiers nombes paires
lp = [ 2*x for x in range(10) ]
print (lp)
Le résultat :
[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Modifier les éléments d'une liste.
Modifier la valeur d'un élément d'indice connu.
L = ['ba', 'be', 'bi', 'bo', 'bu']
L[2] = 'fifi'
print(L)
La liste L est modifiée :
['ba', 'be', 'fifi', 'bo', 'bu']
Effacer un élément d'indice connu.
L = ['ba', 'be', 'bi', 'bo', 'bu']
del(L[3])
print(L)
L'élément d'indice 3 est ainsi effacé :
['ba', 'be', 'bi', 'bu']
On peut également utiliser pop :
L = ['ba', 'be', 'bi', 'bo', 'bu']
L.pop(3)
print(L)
On obtient :
['ba', 'be', 'bi', 'bu']
Avec pop, on peut en fait également récupérer la valeur de l'élément supprimé en même temps :
L = ['ba', 'be', 'bi', 'bo', 'bu']
a = L.pop(3)
print(L)
print(a)
On obtient :
['ba', 'be', 'bi', 'bu']
bo
Récupérer l'indice d'un élément.
Si on l'on veut connaître l'indice d'un élément présent dans la liste L, on peut utiliser index :
L = ['ba', 'be', 'bi', 'bo', 'bu']
k = L.index('bo')
print(k)
Ce qui donne :
3
Si l'élément a plusieurs occurrences dans la liste L, L.index() renverra le plus petit indice correspondant.
L = ['ba', 'be', 'bi', 'bo', 'bu', 'bo', 'by', 'bo']
k = L.index('bo')
print(k)
Ce qui donne :
3
Si l'élément n'est pas présent dans la liste, python renvoie une erreur :
L = ['ba', 'be', 'bi', 'bu', 'by']
k = L.index('bo')
print(k)
donne :
ValueError: 'bo' is not in list
Pour éviter une erreur, on peut utiliser count qui permet de retourner le nombre d'éléments de valeur donnée
présents dans la liste.
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
compteur = L.count('bo')
print("Nombre de 'bo' présents dans la liste L : ",compteur)
donne :
Nombre de 'bo' présents dans la liste L : 2
et pour éviter une erreur en cas d'absence de la valeur :
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
if L.count('bo') > 0 :
print("Premier indice de 'bo' dans la liste L : ", L.index('bo') )
else :
print("Aucun 'bo' dans cette liste.")
Effacer un élément d'indice inconnu.
Avec remove, on peut supprimer la première occurrence d'une valeur donnée dans la liste.
Attention, python retourne une
erreur si la valeur n'était pas présente.
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
if L.count('bo') > 0 :
L.remove('bo')
print("Liste L après remove : ", L )
else :
print("La liste ne contenait aucun 'bo'.")
donne :
Liste L après remove : ['ba', 'be', 'bi', 'bu', 'by', 'bo']
Ajouter un élément à une liste
append()
On ajoute un élément à une liste L avec L.append(valeur à ajouter). La nouvelle valeur
est insérée en fin de liste (et devient donc le dernier élément de la liste après modification) :
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
L.append('foo')
print(L)
L.append(7)
print(L)
L'affichage obtenu :
['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'foo']
['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'foo', 7]
insert()
On peut insérer un élément à une position précise dans une liste avec insert(position, valeur à insérer) :
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
L.insert(0,'foo')
print(L)
L.insert(2,'fii')
print(L)
L.insert(len(L), 'un ajout à la fin')
print(L)
L'affichage obtenu :
['foo', 'ba', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
['foo', 'ba', 'fii', 'bo', 'be', 'bi', 'bu', 'by', 'bo']
['foo', 'ba', 'fii', 'bo', 'be', 'bi', 'bu', 'by', 'bo', 'un ajout à la fin']
extend()
On peut ajouter les éléments d'une liste M à une liste L :
L = ['ba', 'bo', 'be', 'bi', 'bu', 'by']
M = [ 4.8, 9.3, 7.2]
L.extend(M)
print(L)
L'affichage obtenu :
['ba', 'bo', 'be', 'bi', 'bu', 'by', 4.8, 9.3, 7.2]
Copier une liste.
Il est important de comprendre la différence entre une instruction L= M dans laquelle M est une liste et
cette même instruction lorsque M est par exemple de type int, float, str.
Ces différences et les "pièges" à éviter sont
à découvrir ici.