13 Les listes

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.

13.1 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)

[12, 15, 9, 17, 11]
['Alice', 'Bob', 'Charlie']
[1, 'texte', 3.14, True, None]

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)

['P', 'y', 't', 'h', 'o', 'n']
[0, 1, 2, 3, 4]

13.2 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)

pomme
cerise
datte
cerise

⚠️ Piège TOSA : dépassement d’indice

Accéder à un indice hors limites lève une IndexError :

fruits = ["pomme", "banane"]
print(fruits[5])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[5], line 2
      1 fruits = ["pomme", "banane"]
----> 2 print(fruits[5])

IndexError: list index out of range

Pour vérifier la taille avant accès, utilisez len() :

fruits = ["pomme", "banane"]
indice = 5
if indice < len(fruits):
    print(fruits[indice])
else:
    print("Indice trop grand")

Indice trop grand

13.3 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ée

[30, 40, 50]
[10, 20, 30]
[60, 70, 80, 90]
[10, 30, 50, 70, 90]
[90, 80, 70, 60, 50, 40, 30, 20, 10]

Copier une liste avec [:]

nouvelle = ancienne[:] est un idiome pour copier une liste (copie superficielle).

originale = [1, 2, 3]
copie = originale[:]
copie.append(4)
print("Originale :", originale)
print("Copie    :", copie)

Originale : [1, 2, 3]
Copie    : [1, 2, 3, 4]

Sans le [:], copie = originale crée deux noms pour la même liste (piège vu en Partie 2).

13.4 Modifier une liste

Puisque les listes sont mutables, on peut modifier un élément :

fruits = ["pomme", "banane", "cerise"]
fruits[1] = "fraise"
print(fruits)

['pomme', 'fraise', 'cerise']

On peut aussi modifier plusieurs éléments avec un slice :

nombres = [1, 2, 3, 4, 5]
nombres[1:4] = [20, 30, 40]
print(nombres)

[1, 20, 30, 40, 5]

13.5 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)

['pomme', 'banane', 'cerise']
['fraise', 'pomme', 'banane', 'cerise']
['fraise', 'pomme', 'banane', 'cerise', 'kiwi', 'mangue']

⚠️ Piège TOSA : append vs extend

l1 = [1, 2, 3]
l1.append([4, 5])      # ajoute LA LISTE comme un élément
print(l1)

l2 = [1, 2, 3]
l2.extend([4, 5])      # ajoute les ÉLÉMENTS un par un
print(l2)

[1, 2, 3, [4, 5]]
[1, 2, 3, 4, 5]

Une question classique : « Que vaut l après l = [1, 2]; l.append([3, 4]) ? » Réponse : [1, 2, [3, 4]] (et non [1, 2, 3, 4]).

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)

['pomme', 'cerise', 'banane', 'datte']
Retiré : datte
Reste : ['pomme', 'cerise', 'banane']
Retiré à l'indice 1 : cerise
Reste : ['pomme', 'banane']

⚠️ Piège TOSA : remove lève une erreur si absent

l = [1, 2, 3]
l.remove(99)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[14], line 2
      1 l = [1, 2, 3]
----> 2 l.remove(99)

ValueError: list.remove(x): x not in list

Pour vérifier avant :

l = [1, 2, 3]
if 99 in l:
    l.remove(99)
else:
    print("99 absent")

99 absent

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)

Trié : [1, 1, 2, 3, 4, 5, 6, 9]
Décroissant : [9, 6, 5, 4, 3, 2, 1, 1]
Inversé : [1, 1, 2, 3, 4, 5, 6, 9]

sort() vs sorted()

liste.sort() → modifie la liste en place, renvoie None.
sorted(liste) → renvoie une nouvelle liste triée, sans modifier l’original.

original = [3, 1, 4, 1, 5]

# sort() modifie l'original
copie = original[:]
copie.sort()
print("Original inchangé :", original)

# sorted() renvoie une nouvelle liste
nouvelle = sorted(original)
print("Original inchangé :", original)
print("Nouvelle triée    :", nouvelle)

Original inchangé : [3, 1, 4, 1, 5]
Original inchangé : [3, 1, 4, 1, 5]
Nouvelle triée    : [1, 1, 3, 4, 5]

Piège classique : l = l.sort() → l devient None !

l = [3, 1, 2]
l = l.sort()
print(l)      # None (piège !)

None

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)

Indice du 20 : 1
Nombre de 20 : 3
50 présent ?  False
20 présent ?  True

13.6 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))

Nombre : 5
Min    : 9
Max    : 17
Somme  : 64
Moyenne: 12.8

13.7 Parcourir une liste

Comme une chaîne, on parcourt une liste avec for (chapitre 9) :

fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
    print(fruit)

pomme
banane
cerise

Avec l’indice via enumerate (vu au chapitre 10) :

for i, fruit in enumerate(fruits):
    print(i, "→", fruit)

0 → pomme
1 → banane
2 → cerise

13.8 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)

1
6
[7, 8, 9]

🧩 Quiz 4.1 — Les listes

Question 1

Que renvoie ce code ?

l = [1, 2, 3]
l.append([4, 5])
print(l)

[1, 2, 3, 4, 5]
[1, 2, 3, [4, 5]]
[[1, 2, 3], [4, 5]]
Une erreur

🔍 Réponse

b) [1, 2, 3, [4, 5]] — append ajoute son argument comme un seul élément. Pour ajouter les éléments un par un, utilisez extend.

l = [1, 2, 3]
l.append([4, 5])
print(l)

l2 = [1, 2, 3]
l2.extend([4, 5])
print(l2)

[1, 2, 3, [4, 5]]
[1, 2, 3, 4, 5]

Question 2

Que vaut l[1:4] pour l = [10, 20, 30, 40, 50] ?

[10, 20, 30]
[20, 30, 40]
[20, 30, 40, 50]
[10, 20, 30, 40]

🔍 Réponse

b) [20, 30, 40] — indices 1, 2, 3 (l’indice 4 est exclu).

l = [10, 20, 30, 40, 50]
print(l[1:4])

[20, 30, 40]

Question 3

Que renvoie sorted([3, 1, 2]) ?

None
[1, 2, 3]
[3, 2, 1]
Rien, modifie la liste en place

🔍 Réponse

b) [1, 2, 3] — sorted() renvoie une nouvelle liste triée. Ne pas confondre avec .sort() qui modifie en place et renvoie None.

print(sorted([3, 1, 2]))
print([3, 1, 2].sort())

[1, 2, 3]
None

Question 4

Que vaut l après ce code ?

l = [1, 2, 3]
l = l.sort()

[1, 2, 3]
[3, 2, 1]
None
Une erreur

🔍 Réponse

c) None — piège TOSA classique ! .sort() modifie en place et ne renvoie rien (None). En affectant l = l.sort(), on écrase l avec None.

l = [1, 2, 3]
l = l.sort()
print(l)

None

La bonne syntaxe :

l = [1, 2, 3]
l.sort()           # modifie l directement
print(l)

[1, 2, 3]

Question 5

Que vaut len(l) pour l = [1, [2, 3], [4, 5, 6]] ?

🔍 Réponse

a) 3 — len() compte les éléments de premier niveau. Ici : 1, [2, 3], [4, 5, 6] font 3 éléments.

l = [1, [2, 3], [4, 5, 6]]
print(len(l))

Question 6

Que s’affiche-t-il ?

l = [1, 2, 3, 4, 5]
l[1:4] = [20, 30]
print(l)

[1, 20, 30, 5]
[1, 20, 30, 4, 5]
[1, 2, 20, 30, 5]
Une erreur

🔍 Réponse

a) [1, 20, 30, 5] — l’affectation par slice remplace la portion (3 éléments : indices 1, 2, 3) par les nouveaux éléments (ici 2 éléments). La liste se redimensionne automatiquement.

l = [1, 2, 3, 4, 5]
l[1:4] = [20, 30]
print(l)

[1, 20, 30, 5]

Question 7

Que vaut l après l.remove(2) pour l = [1, 2, 3, 2, 4] ?

[1, 3, 4]
[1, 3, 2, 4]
[1, 2, 3, 4]
Une erreur

🔍 Réponse

b) [1, 3, 2, 4] — remove() retire uniquement la première occurrence. Pour tout retirer, il faut boucler (ou utiliser une compréhension vue en Partie 3).

l = [1, 2, 3, 2, 4]
l.remove(2)
print(l)

[1, 3, 2, 4]

✏️ Exercice 5.1 — Manipulations de liste

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.

Énoncé
Solution

fruits = ["pomme", "banane", "cerise"]

# Effectuez les 5 opérations

fruits = ["pomme", "banane", "cerise"]

# 1. Ajouter kiwi à la fin
fruits.append("kiwi")

# 2. Insérer fraise en première position
fruits.insert(0, "fraise")

# 3. Retirer banane
fruits.remove("banane")

# 4. Trier
fruits.sort()

# 5. Afficher
print("Nombre d'éléments :", len(fruits))
print("Dernier :", fruits[-1])
print("Liste finale :", fruits)

Nombre d'éléments : 4
Dernier : pomme
Liste finale : ['cerise', 'fraise', 'kiwi', 'pomme']

✏️ Exercice 5.2 — Statistiques sur une liste

Soit notes = [12, 15, 9, 17, 11, 14, 8, 18, 10]. Affichez :

La moyenne.
La note la plus basse et la plus haute.
Le nombre de notes supérieures ou égales à 10.
La liste triée par ordre décroissant.

notes = [12, 15, 9, 17, 11, 14, 8, 18, 10]

# Calculer et afficher les 4 stats

notes = [12, 15, 9, 17, 11, 14, 8, 18, 10]

# 1. Moyenne
moyenne = sum(notes) / len(notes)
print("Moyenne :", moyenne)

# 2. Min et max
print("Min :", min(notes))
print("Max :", max(notes))

# 3. Notes >= 10 : on compte avec une boucle
compteur = 0
for n in notes:
    if n >= 10:
        compteur += 1
print("Notes >= 10 :", compteur)

# 4. Tri décroissant
notes_decroissant = sorted(notes, reverse=True)
print("Décroissant :", notes_decroissant)

Moyenne : 12.666666666666666
Min : 8
Max : 18
Notes >= 10 : 7
Décroissant : [18, 17, 15, 14, 12, 11, 10, 9, 8]

Avec une compréhension (vue plus tard) :

notes = [12, 15, 9, 17, 11, 14, 8, 18, 10]
valides = [n for n in notes if n >= 10]
print("Notes valides :", valides)
print("Nombre :", len(valides))

Notes valides : [12, 15, 17, 11, 14, 18, 10]
Nombre : 7

✏️ Exercice 5.3 — Inverser sans `reverse()` ni slicing

Écrivez un programme qui inverse une liste sans utiliser reverse(), reversed() ni [::-1]. Utilisez uniquement une boucle.

liste = [1, 2, 3, 4, 5]

# Créer la liste inversée manuellement
inversee = ...

print(inversee)    # Attendu : [5, 4, 3, 2, 1]

liste = [1, 2, 3, 4, 5]
inversee = []

for element in liste:
    inversee.insert(0, element)    # on insère chaque élément au DÉBUT

print(inversee)

[5, 4, 3, 2, 1]

liste = [1, 2, 3, 4, 5]
inversee = []

# On parcourt de la fin vers le début
for i in range(len(liste) - 1, -1, -1):
    inversee.append(liste[i])

print(inversee)

[5, 4, 3, 2, 1]

Les deux versions produisent le même résultat. La première est plus idiomatique et lisible.

À retenir

Points clés du chapitre

Les listes sont ordonnées, modifiables, hétérogènes. Indexation à partir de 0.
Méthodes d’ajout : append() (1 élément à la fin), insert() (position donnée), extend() (plusieurs éléments).
Méthodes de retrait : remove() (par valeur, 1ère occurrence), pop() (par indice, renvoie la valeur), clear() (tout vider).
sort() modifie en place et renvoie None. sorted() renvoie une nouvelle liste.
l.sort() renvoie None → jamais l = l.sort().
Piège append vs extend : append([4,5]) ajoute la liste comme 1 élément ; extend([4,5]) ajoute les éléments un par un.
Slicing l[a:b], l[::-1], copie avec l[:].

← Chapitre précédent : Conditions • Chapitre suivant : Les tuples →

13.1 Qu’est-ce qu’une liste ?

Créer une liste vide

Créer une liste à partir d’une autre séquence

13.2 Accéder aux éléments (indexation)

13.3 Le slicing (découpage)

13.4 Modifier une liste

13.5 Les méthodes de liste (à connaître par cœur)

Ajouter des éléments

Retirer des éléments

Trier et inverser

Rechercher

13.6 Fonctions utiles sur les listes

13.7 Parcourir une liste

13.8 Listes imbriquées (listes de listes)

🧩 Quiz 4.1 — Les listes

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

✏️ Exercice 5.1 — Manipulations de liste

✏️ Exercice 5.2 — Statistiques sur une liste

✏️ Exercice 5.3 — Inverser sans reverse() ni slicing

À retenir

✏️ Exercice 5.3 — Inverser sans `reverse()` ni slicing