Informatique - EMINES – Université Mohamed 6
P ython - Listes
Som m aire
Python - Listes ........................................................................................................................................................ 1
1 Les listes .................................................................................................................................................... 2
1.1 Définition............................................................................................................................................... 2
1.2 Utilisation .............................................................................................................................................. 2
1.3 Opération sur les listes ........................................................................................................................... 2
1.4 Indice négatif et sous-liste ..................................................................................................................... 3
1.5 Fonction len() ........................................................................................................................................ 4
1.6 Les fonctions range() et list() ................................................................................................................. 5
1.7 Listes de listes........................................................................................................................................ 5
1.8 Exercices ............................................................................................................................................... 6
Informatique - EMINES – Université Mohamed 6
1 Les listes
1.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 type différent (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 (ne
pas oublier 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 :
>>> employes = ['ali','amine','safa','kamal']
>>> tailles = [5, 2.5, 1.75, 0.15]
>>> mixte = ['ali', 5, 'kamal', 0.15]
>>> employes
['ali', 'amine', 'safa', 'kamal']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['ali', 5, 'kamal', 0.15]
Lorsque l’on affiche une liste, Python la restitue telle qu’elle a été saisie.
1.2 U tilisation
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.
liste : ['ali', 'amine', 'safa', 'kamal']
indice : 0 1 2 3
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 :
>>> employes = ['ali','amine','safa','kamal']
>>> employes[0]
'ali'
>>> employes[1]
'amine'
>>> employes[3]
'kamal'
Par conséquent, si on appelle l’élément d’indice 4 de notre liste, Python renverra un message d’erreur :
>>> employes[4]
Traceback (innermost last):
File "<stdin>", line 1, in ?
IndexError: list index out of range
1.3 Opération sur les listes
Tout comme les chaînes de caractères, les listes supportent l’opérateur + de concaténation, ainsi que
l’opérateur * pour la duplication :
>>> ani1 = ['ali','amine']
>>> ani2 = ['safa','kamal']
>>> ani1 + ani2
['ali', 'amine', 'safa', 'kamal']
>>> ani1 * 3
['ali', 'amine', 'ali', 'amine', 'ali', 'amine']
L’opérateur + est très pratique pour concaténer deux listes. Vous pouvez aussi utiliser la
fonction append() lorsque vous souhaitez ajouter un seul élément à la fin d’une liste.
Dans l’exemple suivant nous allons créer une liste vide puis lui ajouter deux éléments, d’abord avec la
concaténation :
Informatique - EMINES – Université Mohamed 6
>>> l = [] # liste vide
>>> l
[]
>>> l = l + [15]
>>> l
[15]
>>> l = l + [-5]
>>> l
[15, -5]
puis avec la fonction append() :
>>> l = []
>>> l
[]
>>> [Link](15)
>>> l
[15]
>>> [Link](-5)
>>> l
[15, -5]
Dans l’exemple ci-dessus nous obtenons le même résultat pour faire grandir une liste en utilisant
l’opérateur de concaténation ou la fonction append(). Nous vous conseillons néanmoins dans ce cas
précis d’utiliser la fonction append() dont la syntaxe est plus élégante.
Il est parfois nécessaire de supprim er une entrée de la liste. Pour cela vous pouvez utiliser la
fonction del.
>>> liste = ["a", "b", "c"]
>>> del liste[1]
>>> liste
['a', 'c']
Il est possible de supprim er une entrée d'une liste avec sa valeur avec la méthode rem ove.
>>> liste = ["a", "b", "c"]
>>> [Link]("a")
>>> liste
['b', 'c']
Vous pouvez inverser les items d'une liste avec la méthode reverse.
>>> liste = ["a", "b", "c"]
>>> [Link]()
>>> liste
['c', 'b', 'a']
1.4 Indice négatif et sous-liste
Indice négatif
La liste peut également être indexée avec des nombres négatifs selon le modèle suivant :
liste : ['ali', 'amine', 'safa', 'kamal']
indice positif : 0 1 2 3
indice négatif : -4 -3 -2 -1
ou encore :
liste : ['A','C','D','E','F','G','H','I','K','L']
indice positif : 0 1 2 3 4 5 6 7 8 9
indice negatif : -10 -9 -8 -7 -6 -5 -4 -3 - 2 -1
Informatique - EMINES – Université Mohamed 6
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.
>>> employes = ['ali','amine','safa','kamal']
>>> employes[-1]
'kamal'
>>> employes[-2]
'safa'
Pour accéder au premier élément de la liste, il faut par contre connaître le bon indice :
>>> employes[-4]
'ali'
Dans ce cas, on utiliserait plutôt employes[0].
Sous-liste
Un autre avantage des listes est la possibilité de sélectionner une partie 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 exclus). On dit alors qu’on récupère une tranche (sous-liste) de
la liste, par exemple :
>>> employes= ['ali', 'amine', 'safa', 'kamal']
>>> employes[0:2]
['ali', 'amine']
>>> employes[0:3]
['ali', 'amine', 'safa']
>>> employes[0:]
['ali', 'amine', 'safa', 'kamal']
>>> employes[:]
['ali', 'amine', 'safa', 'kamal']
>>> employes[1:]
['amine', 'safa', 'kamal']
>>> employes[1:-1]
['amine', 'safa']
Notez que lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole :, Python prend par
défaut tous les éléments depuis le début ou tous les éléments jusqu’à la fin respectivement.
On peut aussi préciser le pas en ajoutant un : supplémentaire et en indiquant le pas par un entier.
>>> employes = ['ali', 'amine', 'safa', 'kamal']
>>> employes[0:3:2]
['ali', 'safa']
>>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::2]
[0, 2, 4, 6, 8]
>>> x[::3]
[0, 3, 6, 9]
>>> x[1:6:3]
[1, 4]
Finalement, on voit que l’accès au contenu d’une liste avec des crochets fonctionne sur le
modèle liste[début:fin:pas].
1.5 Fonction len()
L’instruction len() vous permet de connaître la longueur d’une liste, c’est-à-dire le nombre d’éléments
que contient la liste. Voici un exemple d’utilisation :
>>> employes= ['ali', 'amine', 'safa', 'kamal']
>>> len(employes)
4
>>> len([1, 2, 3, 4, 5, 6, 7, 8])
Informatique - EMINES – Université Mohamed 6
1.6 Les fonctions rang e() et list()
L’instruction range() est une fonction spéciale en Python qui va nous permettre de générer des
nombres entiers compris dans un intervalle lorsqu’elle est utilisée en combinaison avec la
fonction list() . 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 exclus. Nous verrons l’utilisation de la fonction range() toute seule dans le chapitre suivant sur les
boucles.
Dans l’exemple ci-dessus, la fonction range() a pris un argument, mais elle peut également prendre
deux ou trois arguments, voyez plutôt :
>>> list(range(0,5))
[0, 1, 2, 3, 4]
>>> list(range(15,20))
[15, 16, 17, 18, 19]
>>> list(range(0,1000,200))
[0, 200, 400, 600, 800]
>>> list(range(2,-2,-1))
[2, 1, 0, -1]
L’instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les arguments entre
crochets sont optionnels. Pour obtenir une liste, 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 faudra absolument préciser le pas de -1 pour les listes décroissantes :
>>> list(range(10,0,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
1.7 Listes de listes
Pour finir, sachez qu’il est tout-à-fait possible de construire des listes de listes. Cette fonctionnalité
peut être parfois très pratique. Par exemple :
>>> enclos1 = ['kamal', 4]
>>> enclos2 = ['amine', 2]
>>> enclos3 = ['safa', 5]
>>> societe = [enclos1, enclos2, enclos3]
>>> societe
[['kamal', 4], ['amine', 2], ['safa', 5]]
Dans cet exemple, chaque sous-liste contient une catégorie d’employé et le nombre d’employés pour
chaque catégorie.
Pour accéder à un élément de la liste, on utilise l’indiçage habituel :
>>> societe [1]
['amine', 2]
Pour accéder à un élément de la sous-liste, on utilise un double indiçage :
>>> societe [1][0]
'amine'
Informatique - EMINES – Université Mohamed 6
>>> societe [1][1]
2
1.8 Exercices
Exercice 1 : Jours de la sem aine
Constituez une liste semaine contenant les 7 jours de la semaine.
1. À partir de cette liste, comment récupérez-vous seulement les 5 premiers jours de la semaine
d’une part, et ceux du week-end d’autre part (utilisez pour cela l’indiçage) ?
2. Cherchez un autre moyen pour arriver au même résultat (en utilisant un autre indiçage).
3. Trouvez deux manières pour accéder au dernier jour de la semaine.
4. Inversez les jours de la semaine en une commande.
Exercice 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 sous-listes hiver, printemps, ete et automne. Prévoyez ce que
valent les variables 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 ?
Exercice 3 : Table des 8
Affichez la table des 8 en une seule commande avec les instructions range() et list().
Exercice 4 : N om bres pairs
Avec Python, répondez à la question suivante en une seule commande. Combien y a-t-il de nombres
pairs dans l’intervalle [2, 5000] inclus ?