Académique Documents
Professionnel Documents
Culture Documents
Larhlimi
Chap. 5 :
Listes en Python
5.1 Définition
Une liste est une structure de données qui contient une série de valeurs. Python
autorise la construction de liste contenant des valeurs de types différents (par
exemple entier et chaîne de caractères), ce qui leur confère une grande flexibilité. Une
liste est déclarée par une série de valeurs (n'oubliez pas les guillemets, simples ou
doubles, s'il s'agit de chaînes de caractères) séparées par des virgules, et le tout
encadré par des crochets. En voici quelques exemples :
Lorsque l'on affiche une liste, Python la restitue telle qu'elle a été saisie.
5.2 Utilisation
Un des gros avantages d'une liste est que vous pouvez appeler ses éléments par leur
position. Ce numéro est appelé indice (ou index) de la liste.
Soyez très attentifs au fait que les indices d'une liste de n éléments commence à 0 et
se termine à n-1. Voyez l'exemple suivant :
P a g e 1 | 21
A.Larhlimi
>>> LClient[4]
Traceback (innermost last):
File "<stdin>", line 1, in ?
IndexError: list index out of range
Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un
seul élément à la fin d'une liste.
>>> a = []
>>> a
[]
puis lui ajouter deux éléments, l'un après l'autre, d'abord avec la concaténation :
>>> a = a + [15]
>>> a
[15]
>>> a = a + [-5]
>>> a
[15, -5]
>>> a.append(13)
>>> a
[15, -5, 13]
>>> a.append(-3)
>>> a
[15, -5, 13, -3]
P a g e 2 | 21
A.Larhlimi
Dans l'exemple ci-dessus, nous ajoutons des éléments à une liste en utilisant
l'opérateur de concaténation + ou la méthode .append(). Nous vous conseillons dans
ce cas précis d'utiliser la méthode .append() dont la syntaxe est plus élégante.
Nous reverrons en détail la méthode .append() dans le chapitre 11 Plus sur les listes.
ou encore :
liste : ['A','B','C','D','E','F']
indice positif : 0 1 2 3 4 5
indice négatif : -6 -5 -4 -3 - 2 -1
Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est
que vous pouvez accéder au dernier élément d'une liste à l'aide de l'indice -1 sans pour
autant connaître la longueur de cette liste. L'avant-dernier élément a lui l'indice -2,
l'avant-avant dernier l'indice -3, etc.
Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre
connaître le bon indice :
>>> LClient[-4]
Client1
5.5 Tranches
Un autre avantage des listes est la possibilité de sélectionner une partie d'une liste en
utilisant un indiçage construit sur le modèle [m:n+1] pour récupérer tous les éléments,
du émième au énième (de l'élément m inclus à l'élément n+1 exclu). On dit alors qu'on
récupère une tranche de la liste, par exemple :
P a g e 3 | 21
A.Larhlimi
Notez que lorsqu'aucun indice n'est indiqué à gauche ou à droite du symbole deux-
points, Python prend par défaut tous les éléments depuis le début ou tous les éléments
jusqu'à la fin respectivement.
Finalement, on se rend compte que l'accès au contenu d'une liste fonctionne sur le
modèle liste[début:fin:pas].
P a g e 4 | 21
A.Larhlimi
L'instruction range() est une fonction spéciale en Python qui génère des nombres
entiers compris dans un intervalle. Lorsqu'elle est utilisée en combinaison avec la
fonction list(), on obtient une liste d'entiers. Par exemple :
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
La commande list(range(10)) a généré une liste contenant tous les nombres entiers
de 0 inclus à 10 exclu. Nous verrons l'utilisation de la fonction range() toute seule dans
le chapitre 5 Boucles et comparaisons.
Dans l'exemple ci-dessus, la fonction range() a pris un argument, mais elle peut
également prendre deux ou trois arguments, voyez plutôt :
L'instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les arguments
entre crochets sont optionnels. Pour obtenir une liste de nombres entiers, il faut
l'utiliser systématiquement avec la fonction list().
Enfin, prenez garde aux arguments optionnels par défaut (0 pour début et 1 pour pas):
>>> list(range(10,0))
[]
Ici la liste est vide car Python a pris la valeur du pas par défaut qui est de 1. Ainsi, si on
commence à 10 et qu'on avance par pas de 1, on ne pourra jamais atteindre 0. Python
génère ainsi une liste vide. Pour éviter ça, il faudrait, par exemple, préciser un pas de -
1 pour obtenir une liste d'entiers décroissants :
>>> list(range(10,0,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
P a g e 5 | 21
A.Larhlimi
Dans cet exemple, chaque sous-liste contient une catégorie d'animal et le nombre
d'LClient pour chaque catégorie.
>>> zoo[1]
[Client2, 2]
>>> zoo[1][0]
Client2
>>> zoo[1][1]
2
On verra un peu plus loin qu'il existe en Python des dictionnaires qui sont également
très pratiques pour stocker de l'information structurée. On verra aussi qu'il existe un
module nommé NumPy qui permet de créer des listes ou des tableaux de nombres
(vecteurs et matrices) et de les manipuler.
Même si en théorie ces fonctions peuvent prendre en argument une liste de strings,
on les utilisera la plupart du temps avec des types numériques (liste d'entiers et / ou
de floats).
Nous avions déjà croisé min(), max() dans le chapitre 2 Variables. On avait vu que ces
deux fonctions pouvaient prendre plusieurs arguments entiers et / ou floats, par
exemple :
P a g e 6 | 21
A.Larhlimi
>>> min(3, 4)
3
Attention toutefois à ne pas mélanger entiers et floats d'une part avec une liste
d'autre part, car cela renvoie une erreur :
>>> min(liste, 3, 4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'list'
Soit on passe plusieurs entiers et / ou floats en argument, soit on passe une liste
unique.
5.10 Exercices
Conseil : utilisez l'interpréteur Python.
5.10.2 Saisons
Créez 4 listes hiver, printemps, ete et automne contenant les mois correspondants à
ces saisons. Créez ensuite une liste saisons contenant les
listes hiver, printemps, ete et automne. Prévoyez ce que renvoient les instructions
suivantes, puis vérifiez-le dans l'interpréteur :
1. saisons[2]
2. saisons[1][0]
3. saisons[1:2]
4. saisons[:][1]. Comment expliquez-vous ce dernier résultat ?
P a g e 8 | 21
A.Larhlimi
Chap6.
Plus sur les listes
Nous avons vu les listes dès le chapitre 4 et les avons largement utilisées depuis le
début de ce cours. Dans ce chapitre nous allons plus loin avec les méthodes associées
aux listes, ainsi que d'autres caractéristiques très puissantes telles que les tests
d'appartenance ou les listes de compréhension.
11.1.1 .append()
La méthode .append(), que l'on a déjà vu au chapitre 4 Listes, ajoute un élément à la
fin d'une liste :
>>> a = [1, 2, 3]
>>> a.append(5)
>>> a
[1, 2, 3, 5]
>>> a = [1, 2, 3]
>>> a = a + [5]
>>> a
[1, 2, 3, 5]
Conseil : préférez la version avec .append() qui est plus compacte et facile à lire.
11.1.2 .insert()
La méthode .insert() insère un objet dans une liste avec un indice déterminé :
>>> a = [1, 2, 3]
>>> a.insert(2, -15)
>>> a
[1, 2, -15, 3]
P a g e 9 | 21
A.Larhlimi
11.1.3 del
L'instruction del supprime un élément d'une liste à un indice déterminé :
>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]
Remarque
11.1.4 .remove()
La méthode .remove() supprime un élément d'une liste à partir de sa valeur :
>>> a = [1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2]
11.1.5 .sort()
La méthode .sort() trie une liste :
>>> a = [3, 1, 2]
>>> a.sort()
>>> a
[1, 2, 3]
11.1.6 .reverse()
La méthode .reverse() inverse une liste :
>>> a = [3, 1, 2]
>>> a.reverse()
>>> a
[2, 1, 3]
11.1.7 .count()
La méthode .count() compte le nombre d'éléments (passés en argument) dans une
liste :
P a g e 10 | 21
A.Larhlimi
>>> a = [1, 2, 4, 3, 1, 1]
>>> a.count(1)
3
>>> a.count(4)
1
>>> a.count(23)
0
Remarque
Cela signifie que la liste est modifiée « sur place », c'est-à-dire dans la méthode au
moment où elle s'exécute. La liste est ainsi modifiée en dur dans la méthode, cette
dernière ne renvoie donc rien.
Pour cela, il est commode de définir préalablement une liste vide de la forme maliste
= []. Voici un exemple où une chaîne de caractères est convertie en liste :
P a g e 11 | 21
A.Larhlimi
[]
>>> for base in seq:
... seq_list.append(base)
...
>>> seq_list
['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C']
Cette méthode est certes plus simple, mais il arrive parfois qu'on doive utiliser des
boucles tout de même, comme lorsqu'on lit un fichier. On rappelle que
l'instruction list(seq) convertit un objet de type chaîne de caractères en un objet de
type liste (il s'agit donc d'une opération de casting). De même
que list(range(10)) convertit un objet de type range en un objet de type list.
liste = [1, 3, 5, 7, 9]
>>> 3 in liste
True
>>> 4 in liste
False
>>> 3 not in liste
False
>>> 4 not in liste
True
La variation avec not permet, a contrario, de vérifier qu'un élément n'est pas dans une
liste.
>>> x = [1, 2, 3]
>>> y = x
>>> y
[1, 2, 3]
>>> x[1] = -15
>>> x
P a g e 12 | 21
A.Larhlimi
[1, -15, 3]
>>> y
[1, -15, 3]
Pour éviter ce problème, il va falloir créer une copie explicite de la liste initiale.
Observez cet exemple :
>>> x = [1, 2, 3]
>>> y = x[:]
>>> x[1] = -15
>>> y
[1, 2, 3]
L'instruction x[:] a créé une copie « à la volée » de la liste x. Vous pouvez utiliser aussi
la fonction list() qui renvoie explicitement une liste:
>>> x = [1, 2, 3]
>>> y = list(x)
>>> x[1] = -15
>>> y
[1, 2, 3]
Si on regarde à nouveau dans Python Tutor (Figure 12), on voit clairement que
l'utilisation d'une tranche [:] ou de la fonction list() crée des copies explicites.
Chaque flèche pointe vers une liste différente, indépendante des autres.
P a g e 13 | 21
A.Larhlimi
Attention, les deux astuces précédentes ne fonctionnent que pour les listes à une
dimension, autrement dit les listes qui ne contiennent pas elles-mêmes d'autres
listes. Voyez par exemple :
et
>>> y = list(x)
>>> x[1][1] = 77
>>> x
[[1, 2], [3, 77]]
>>> y
[[1, 2], [3, 77]]
P a g e 14 | 21
A.Larhlimi
Une manière originale et très puissante de générer des listes est liste de
compréhension (ou la la compréhension de listes). Pour plus de détails, consultez à
ce sujet le site de Python et celui de Wikipédia.
P a g e 15 | 21
A.Larhlimi
11.6 Exercices
Conseil : pour ces exercices, créez des scripts puis exécutez-les dans un shell.
Utilisez cette fonction pour générer aléatoirement une séquence d'ADN de 15 bases.
11.6.4 Doublons
Soit la liste de nombres liste = [5, 1, 1, 2, 5, 6, 3, 4, 4, 4, 2].
A partir de liste, créez une nouvelle liste sans les doublons, triez-la et affichez-la.
Utilisez cette fonction pour générer aléatoirement une séquence d'ADN de 50 bases
contenant 10 % de A, 30 % de T, 50 % de G et 10 % de C.
On vous propose d'employer une méthode dite « brute force », c'est-à-dire d'utiliser
une boucle et à chaque itération de tester les différentes conditions.
11
21 1
31 2 1
1 3 3 1
P a g e 17 | 21
A.Larhlimi
41 4 6 4 1
5 1 5 10 10 5 1
6 [...]
7
Déduisez comment une ligne est construite à partir de la précédente. Par exemple, à
partir de la ligne 2 (1 1), construisez la ligne suivante (ligne 3 : 1 2 1) et ainsi de suite.
P a g e 18 | 21
A.Larhlimi
Section QUIZ
Puzzles
Initiatives Geeksforgeeks
ANNONCES PAR ADRECOVER
3) []
1) r
2) b
3) r
4) é
5) k
1. 4
P a g e 19 | 21
A.Larhlimi
2. 5
3. 6
4. dix
Question: 5 Recherchez la sortie du programme suivant:
check1 = ['Learn', 'Quiz', 'Practice', 'Contribute']
check2 = check1
check3 = check1[:]
check2[0] = 'Code'
check3[1] = 'Mcq'
count = 0
for c in (check1, check2, check3):
if c[0] == 'Code':
count += 1
if c[1] == 'Mcq':
count += 10
print (count)
1. 4
2. 5
3. 11
4. 12
5. [3, 2, 1, 0, 1, 4]
6. [0, 1, 0, 1, 4]
7. [0, 1]
8. []
Question: 7 Recherchez la sortie du programme suivant:
# statement 1
list1 = range(100, 110)
# statement 2
print (list1.index(105))
1. 105
2. 5
3. 106
4. 104
list2[0] = 0;
print( list1)
P a g e 20 | 21
A.Larhlimi
print (list1[1][-1])
1. p
2. y
3. 7
4. 2
P a g e 21 | 21