Les listes sont la structure de données la plus utilisée en Python. Elles permettent de regrouper plusieurs valeurs dans une seule variable, ordonnées et modifiables. Le TOSA teste massivement les listes — ce chapitre est central.
Qu'est-ce qu'une liste ?
Une liste est une séquence ordonnée et modifiable d'éléments, pouvant être de types différents.
notes = [12, 15, 9, 17, 11]
prenoms = ["Alice", "Bob", "Charlie"]
melangee = [1, "texte", 3.14, True, None]
print(notes)
print(prenoms)
print(melangee)Les quatre caractéristiques clés des listes Python :
- Ordonnées : chaque élément a une position fixe.
- Modifiables (mutables) : on peut ajouter, retirer, changer.
- Indexées à partir de 0 (comme les chaînes).
- Hétérogènes : mélange de types autorisé.
Créer une liste vide
Deux façons équivalentes :
liste1 = []
liste2 = list()
print(liste1, liste2)Créer une liste à partir d'une autre séquence
# Convertir une chaîne en liste de caractères
lettres = list("Python")
print(lettres)
# Convertir un range en liste
nombres = list(range(5))
print(nombres)Accéder aux éléments (indexation)
Comme pour les chaînes, on utilise les crochets [] avec un indice, à partir de 0.
fruits = ["pomme", "banane", "cerise", "datte"]
print(fruits[0]) # pomme (premier)
print(fruits[2]) # cerise
print(fruits[-1]) # datte (dernier)
print(fruits[-2]) # cerise (avant-dernier)Le slicing (découpage)
Même syntaxe que pour les chaînes : liste[debut:fin:pas].
nombres = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nombres[2:5]) # [30, 40, 50] (indices 2 à 4)
print(nombres[:3]) # [10, 20, 30] (début à 2)
print(nombres[5:]) # [60, 70, 80, 90] (de 5 à fin)
print(nombres[::2]) # [10, 30, 50, 70, 90] (un sur deux)
print(nombres[::-1]) # liste inverséeModifier une liste
Puisque les listes sont mutables, on peut modifier un élément :
fruits = ["pomme", "banane", "cerise"]
fruits[1] = "fraise"
print(fruits)On peut aussi modifier plusieurs éléments avec un slice :
nombres = [1, 2, 3, 4, 5]
nombres[1:4] = [20, 30, 40]
print(nombres)Les méthodes de liste (à connaître par cœur)
Voici les méthodes testées au TOSA sur les listes. Apprenez-les par cœur : c'est un passage obligé.
Ajouter des éléments
| Méthode | Effet | Exemple |
|---|---|---|
append(x) |
Ajoute x à la fin |
l.append(5) |
insert(i, x) |
Insère x à la position i |
l.insert(0, "début") |
extend(iter) |
Ajoute tous les éléments d'un itérable | l.extend([4, 5]) |
fruits = ["pomme", "banane"]
fruits.append("cerise")
print(fruits)
fruits.insert(0, "fraise") # insertion au début
print(fruits)
fruits.extend(["kiwi", "mangue"])
print(fruits)Retirer des éléments
| Méthode | Effet | Exemple |
|---|---|---|
remove(x) |
Retire la 1ère occurrence de x |
l.remove("banane") |
pop() |
Retire et renvoie le dernier | dernier = l.pop() |
pop(i) |
Retire et renvoie l'élément d'indice i |
x = l.pop(0) |
clear() |
Vide la liste | l.clear() |
del l[i] |
Instruction (pas méthode) : supprime l'élément d'indice i |
del l[0] |
fruits = ["pomme", "banane", "cerise", "banane", "datte"]
fruits.remove("banane") # retire la PREMIÈRE "banane" seulement
print(fruits)
dernier = fruits.pop()
print("Retiré :", dernier)
print("Reste :", fruits)
deuxieme = fruits.pop(1)
print("Retiré à l'indice 1 :", deuxieme)
print("Reste :", fruits)Trier et inverser
| Méthode | Effet |
|---|---|
sort() |
Trie la liste en place (modifie l'originale) |
sort(reverse=True) |
Trie dans l'ordre décroissant |
reverse() |
Inverse l'ordre en place |
nombres = [3, 1, 4, 1, 5, 9, 2, 6]
nombres.sort()
print("Trié :", nombres)
nombres.sort(reverse=True)
print("Décroissant :", nombres)
nombres.reverse()
print("Inversé :", nombres)Rechercher
| Méthode | Effet |
|---|---|
index(x) |
Indice de la 1ère occurrence, ValueError si absent |
count(x) |
Nombre d'occurrences |
in (opérateur) |
Teste l'appartenance |
nombres = [10, 20, 30, 20, 40, 20]
print("Indice du 20 :", nombres.index(20))
print("Nombre de 20 :", nombres.count(20))
print("50 présent ? ", 50 in nombres)
print("20 présent ? ", 20 in nombres)Fonctions utiles sur les listes
Outre les méthodes, plusieurs fonctions natives s'appliquent aux listes.
| Fonction | Effet |
|---|---|
len(l) |
Nombre d'éléments |
min(l) |
Plus petit élément |
max(l) |
Plus grand élément |
sum(l) |
Somme (liste numérique) |
sorted(l) |
Nouvelle liste triée |
reversed(l) |
Nouvel itérateur inversé |
list(iter) |
Convertit un itérable en liste |
notes = [12, 15, 9, 17, 11]
print("Nombre :", len(notes))
print("Min :", min(notes))
print("Max :", max(notes))
print("Somme :", sum(notes))
print("Moyenne:", sum(notes) / len(notes))Parcourir une liste
Comme une chaîne, on parcourt une liste avec for (chapitre précédent) :
fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
print(fruit)Avec l'indice via enumerate (détaillé au chapitre 10) :
for i, fruit in enumerate(fruits):
print(i, "→", fruit)Listes imbriquées (listes de listes)
Une liste peut contenir des listes. Utile pour représenter des tableaux à deux dimensions (matrices, grilles...).
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
# Accès à un élément : matrice[ligne][colonne]
print(matrice[0][0]) # 1
print(matrice[1][2]) # 6
print(matrice[2]) # [7, 8, 9] (ligne entière)Exercices
l = [1, 2, 3] l.append([4, 5]) print(l)
l[1:4] pour l = [10, 20, 30, 40, 50] ?
sorted([3, 1, 2]) ?
l après ce code ?
l = [1, 2, 3] l = l.sort()
len(l) pour l = [1, [2, 3], [4, 5, 6]] ?
l = [1, 2, 3, 4, 5] l[1:4] = [20, 30] print(l)
l après l.remove(2) pour l = [1, 2, 3, 2, 4] ?
Soit fruits = ["pomme", "banane", "cerise"]. Effectuez successivement :
- Ajouter
"kiwi"à la fin. - Insérer
"fraise"en première position. - Retirer
"banane". - Trier la liste par ordre alphabétique.
- Afficher le nombre d'éléments et le dernier élément.
Soit notes = [12, 15, 9, 17, 11, 14, 8, 18, 10]. Calculez et affichez, en rangeant chaque résultat dans la variable indiquée :
moyenne: la moyenne, sans l'arrondir.note_minetnote_max: la note la plus basse et la plus haute.compteur: le nombre de notes supérieures ou égales à 10.notes_decroissant: la liste triée par ordre décroissant.
Écrivez un programme qui inverse la liste liste sans utiliser reverse(), reversed() ni une tranche à pas négatif comme [::-1]. Utilisez uniquement une boucle, et rangez le résultat dans la variable inversee.