Toute la structure html/css/js et une grande partie du contenu ont été réalisés par Nicolas Buyle-Bodin professeur au lycée Lacassagne, avec l'aide de Jean-Manuel Mény, professeur au lycée de la plaine de l'Ain. Ils ont travaillé pendant plusieurs centaines d'heures pour créer un site de formation à destination des enseignants du secondaire de l'académie de Lyon d'une grande qualité visible sur le portail Mathématiques du site académique. Ils ont eu la gentillesse de placer leur code source sous licence Creative Commons BY-NC-SA Respect de la Paternité - Pas d'utilisation commerciale - Partage des conditions initiales à l'identique..

Nous les en remercions chaleureusement.

• Une liste est une séquence d'objets placés entre crochets et séparés par un virgule.
• Les éléments d'une liste ne sont pas nécessairement de même type mais nous utiliserons de préférence des listes homogènes constitués uniquement de nombres, de type int ou float.
• Il existe plusieurs façons de définir une liste :
  • Par extension , en énumérant tous ses éléments :

    
    In [6]: L = [1, 4, 2]
    
    In [7]: L1 = [1, 4, 2]
    
    In [8]: L2 = [1, True, "chaine", 3.14]
    
    In [9]: print(type(L1), type(L2))
    < class 'list'> <class 'list'>
    

  • Avec le constructeur list, appliqué à une autre séquence, comme une chaîne de caractères, ou à un génrateur comme range :

    
    					In [12]: list(range(1, 6))
    					Out[12]: [1, 2, 3, 4, 5]
    					
    					In [13]: list("C'est l'été")
    					Out[13]: ['C', "'", 'e', 's', 't', ' ', 'l', "'", 'é', 't', 'é']
    
    					

  • Par compréhension en rassemblant les résultats d'une ou plusieurs boucles for:

    
    					In [14]: [x for x in range(1, 6)]
    					Out[14]: [1, 2, 3, 4, 5]
    					
    					In [15]: [x**2 for x in range(1, 6)]
    					Out[15]: [1, 4, 9, 16, 25]
    					
    					In [16]: [x for x in range(1, 6) if x ** 2 > 10]
    					Out[16]: [4, 5]
    					

• Comme pour les chaînes de caractère, on accède aux éléments d'une liste L par L[0], L[1], L[2]... Il faut noter que le premier élément d'une séquence (liste, chaîne de caractères, tuple) a forcément pour indice 0. Les éléments peuvent être indexés en mesurant leur décalage par rapport au premier élément d'indice $0$ en comptant $+1$ par décalage vers la droite, ou en mesurant leur décalage par rapport au dernier élément d'indice $-1$, en comptant $-1$ par décalage vers la gauche.
L = [2, 3, 8] for k in range(-3, 3): print("Elément d'index ", k, " : ", L[k]) Lancer le programme
• La longueur d'une liste peut s'obtenir avec la fonction len. L'index de l'élément auquel on souhaite accéder, doit être situé dans la plage d'index $[ -\text{len(L)} ; \text{len(L)} - 1 ]$, sinon Python retourne une erreur index out of range.

					In [17]: L = [2, 3, 8]
					
					In [18]: L[2]
					Out[18]: 8
					
					In [19]: L[3]
					---------------------------------------------------------------------------
					IndexError                                Traceback (most recent call last)
					 in ()
					----> 1 L[3]
					
					IndexError: list index out of range
					
					In [20]: L[-3]
					Out[20]: 2
					
					
					In [21]: L[-4]
					---------------------------------------------------------------------------
					IndexError                                Traceback (most recent call last)
					 in ()
					----> 1 L[-4]
					
					IndexError: list index out of range

					

• On peut extraire des sous-listes, découpage, slicing, ou extractions, d'une liste avec la syntaxe L[debut:fin:pas], où debut est l'indice du premier élément du découpage, fin est l'indice du premier élément exclu du découpage et pas est l'écart d'indice entre deux éléments consécutifs du découapge. Par défaut l'index de début est 0, l'index de fin est len(chaine) et le pas est de 1 et on laisse vide ces paramètres si on utilise les valeurs par défaut.
L = [2, 3, 8, 10, 15, 7] print("L[:3] => ", L[:3]) print("L[1:4] => ", L[1:4]) print("L[-3:] => ", L[-3:]) print("L[-3:-1] => ", L[-3:-1]) print("L[4:1:-1] => ", L[4:1:-1]) print("L[-1:-3:-1] => ", L[-1:-3:-1]) print("L[::2] => ", L[::2]) print("L[:] => ", L[:]) print("L[::-1] => ", L[::-1]) print("L[-3::-1] => ", L[-3::-1]) print("L[3::-1] => ", L[3::-1]) Lancer le programme

De valeur d'élément en valeur d'élément

On peut parcourir les éléments d'une liste avec for :

D'indice en indice

On peut également parcourir les éléments de liste avec une boucle for portant sur les indices des éléments de la liste :

Il est aussi possible d'effectuer ce parcours à partir de la fin :

Avec indices et éléments

Il est également possible de parcourir en même temps l'indice et la valeur de l'élément correspondant :

En fin de liste

• Les listes sont des séquences d'objets dynamiques, c'est-à-dire que leur taille peut varier.
• On ajoute un élément en queue de liste avec la méthode .append().
L = [8, 5] L.append(2) print(L) Lancer le programme
• On peut ainsi remplir une liste à partir d'une liste vide, notée [].
L = [] for k in range(5): L.append(k ** 2) print(L) Lancer le programme
• Si on sait comment remplir la liste, avant l'exécution du programme, on utilise plutôt une liste en compréhension.
L = [k ** 2 for k in range(5)] print(L) Lancer le programme

A n'importe quel emplacement de la liste

• On ajoute l'élément x à l'indice i avec la méthode .insert(i, x). Les éléments d'indice supérieur ou égal à i voient alors leur indice augmenter de 1 :
L = [8, 5] L.insert(1, 2) print(L) Lancer le programme
• Par conséquent, .insert(0,...) ajoute un élément en tête de liste et .insert(-1,...) ajoute un élément en fin de liste.
L = [8, 5] L.insert(-1, 2) print(L) L.insert(0, 4) print(L) Lancer le programme

• Avec l'instruction del, on peut supprimer un élément ou une extraction d'une liste à partir des indices.

					In [29]: L = [8,5,2,9,7,6]

					In [30]: del L[1]
					
					In [31]: L
					Out[31]: [8, 2, 9, 7, 6]
					
					In [32]: L[1:3]
					Out[32]: [2, 9]
					
					In [33]: del L[1:3]
					
					In [34]: L
					Out[34]: [8, 7, 6]


					

• Si on souhaite supprimer une valeur d'indice fixé et récupérer sa valeur, on peut utiliser la méthode .pop(indice).

					In [38]: L = [4, 2, 1]
					
					In [39]: a = L.pop(0)
					
					In [40]: L
					Out[40]: [2, 1]
					
					In [41]: a
					Out[41]: 4
					
					In [42]: b = L.pop()
					
					In [43]: L
					Out[43]: [2]
					
					In [44]: b
					Out[44]: 1

					

• La méthode .remove(valeur) permet de supprimer la première occurence d'une valeur fixée dans une liste.

					In [46]: L = [8, 5, 5, 2, 5]
					In [46]: L = [8, 5, 5, 2, 5]
					
					In [47]: L.remove(5)
					
					In [48]: L
					Out[48]: [8, 5, 2, 5]
					
					In [49]: L.remove(5)
					
					In [50]: L
					Out[50]: [8, 2, 5]
					
					In [51]: L.remove(5)
					
					In [52]: L
					Out[52]: [8, 2]


					

• L'opérateur in permet tester l'appartenance d'un élément à une liste, ou plus généralement à une séquence (tuple, chaîne de caractères ) :
L = [8, 5, 2, 5] print(8 in L) print(5 in L) print(3 in L) Lancer le programme
• La méthode .index(valeur) retourne l'indice de la première occurence d'une valeur dans une liste et retourne une erreur si la valeur n'appartient à la liste.
• La méthode .count(valeur) retourne le nombre d'occurences d'une valeur dans une liste.

					In [60]: L = [8, 3, 5, 5, 2, 5]
					
					In [61]: L.index(5)
					Out[61]: 2
					
					In [62]: L.index(4)
					---------------------------------------------------------------------------
					ValueError                                Traceback (most recent call last)
					 in ()
					----> 1 L.index(4)
					
					ValueError: 4 is not in list
					
					In [63]: L.count(5)
					Out[63]: 3
					
					In [64]: L.count(4)
					Out[64]: 0


					

• La méthode .sort() permet de trier une liste dans l'ordre croissant. Le tri est en place, ce qui signifie que la liste est modifiée.
• La fonction sorted s'applique à une liste et retourne une liste triée dans l'ordre croissant. Le tri est externe, La liste initiale n'est pas modifiée.
• En passant le paramètre reverse = True à la méthode .sort() ou la fonction sorted, on peut trier une liste dans l'ordre décroissant.

					In [9]: L = [8, 4, 6, 3, 7]
					
					In [10]: L.sort()
					
					In [11]: L
					Out[11]: [3, 4, 6, 7, 8]
					
					In [12]: L.sort(reverse = True)
					
					In [13]: L
					Out[13]: [8, 7, 6, 4, 3]
					
					In [14]: from random import shuffle
					
					In [15]: shuffle(L)
					
					In [16]: L
					Out[16]: [8, 6, 7, 4, 3]
					
					In [17]: L2 = sorted(L)
					
					In [18]: L2
					Out[18]: [3, 4, 6, 7, 8]
					
					In [19]: L
					Out[19]: [8, 6, 7, 4, 3]
					

Consulter la documentation Python pour connaître les autres méthodes concernant les listes.