Guide complet des listes en Python

Introduction

Les listes sont l’une des structures de données les plus utilisées en Python. Elles permettent de stocker plusieurs valeurs dans une seule variable, de manière ordonnée et modifiable. Une liste peut contenir des éléments de types différents et offre de nombreuses méthodes pour manipuler son contenu.

1. Création de listes

Liste vide

ma_liste = []
print(ma_liste)
# Sortie : []

Liste avec des valeurs initiales

ma_liste = [10, 20, 30, 40]
print(ma_liste)
# Sortie : [10, 20, 30, 40]

Liste avec des éléments de types différents

Python permet de mélanger différents types de données dans une même liste :

ma_liste = [1, "texte", True, 3.14]
print(ma_liste)
# Sortie : [1, 'texte', True, 3.14]

Générer automatiquement des valeurs avec `range()`

La fonction range() combinée avec list() permet de créer rapidement des listes de nombres :

ma_liste = list(range(10))
print(ma_liste)
# Sortie : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Autres exemples avec range() :

# De 1 à 10
ma_liste = list(range(1, 11))
# Sortie : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# De 0 à 20 avec un pas de 2
ma_liste = list(range(0, 21, 2))
# Sortie : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

2. Accéder aux éléments d’une liste

Indexation simple

Les indices commencent à 0 en Python :

ma_liste = [1, "texte", True, 3.14, "nom est Riyad"]
print(ma_liste[0])  # Premier élément
# Sortie : 1

print(ma_liste[2])  # Troisième élément
# Sortie : True

Indexation négative

Les indices négatifs permettent d’accéder aux éléments depuis la fin :

print(ma_liste[-1])  # Dernier élément
# Sortie : nom est Riyad

print(ma_liste[-2])  # Avant-dernier élément
# Sortie : 3.14

Le slicing (découpage)

Le slicing permet d’extraire une portion de la liste avec la syntaxe liste[début:fin] :

sous_liste = ma_liste[1:4]
print(sous_liste)
# Sortie : ['texte', True, 3.14]

Note importante : L’indice de fin n’est pas inclus dans le résultat.

Le pas (step) dans le slicing

La syntaxe complète est liste[début:fin:pas] :

sous_liste = ma_liste[0:5:2]
print(sous_liste)
# Sortie : [1, True, 'nom est Riyad']

Exemples supplémentaires :

ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Tous les éléments
print(ma_liste[:])        # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Du début jusqu'à l'indice 5
print(ma_liste[:5])       # [0, 1, 2, 3, 4]

# De l'indice 5 jusqu'à la fin
print(ma_liste[5:])       # [5, 6, 7, 8, 9]

# Inverser une liste
print(ma_liste[::-1])     # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3. Ajouter et supprimer des éléments

Ajouter des éléments

`append()` - Ajouter à la fin

ma_liste = [10, 20, 30]
ma_liste.append(40)
print(ma_liste)
# Sortie : [10, 20, 30, 40]

`insert()` - Insérer à une position

ma_liste.insert(0, 18)
print(ma_liste)
# Sortie : [18, 10, 20, 30, 40]

`extend()` - Ajouter plusieurs éléments

ma_liste.extend([100, "bonjour"])
print(ma_liste)
# Sortie : [18, 10, 20, 30, 40, 100, 'bonjour']

Différence entre append() et extend() :

liste1 = [1, 2, 3]
liste1.append([4, 5])
print(liste1)
# Sortie : [1, 2, 3, [4, 5]]  # Ajoute la liste comme un seul élément

liste2 = [1, 2, 3]
liste2.extend([4, 5])
print(liste2)
# Sortie : [1, 2, 3, 4, 5]  # Ajoute chaque élément individuellement

Supprimer des éléments

`remove()` - Supprimer par valeur

ma_liste.remove("bonjour")
print(ma_liste)
# Sortie : [18, 10, 20, 30, 40, 100]

Note : Supprime uniquement la première occurrence de la valeur.

`pop()` - Supprimer par indice et retourner l’élément

dernier_element = ma_liste.pop()
print(dernier_element)
# Sortie : 100

print(ma_liste)
# Sortie : [18, 10, 20, 30, 40]

Sans argument, pop() supprime le dernier élément. Avec un indice, il supprime l’élément à cette position :

element = ma_liste.pop(1)  # Supprime l'élément à l'indice 1
print(element)
# Sortie : 10

`del` - Supprimer par indice ou tranche

del ma_liste[0]
print(ma_liste)
# Sortie : [20, 30, 40]

del ma_liste[1:3]
print(ma_liste)
# Sortie : [20]

`clear()` - Vider la liste

ma_liste.clear()
print(ma_liste)
# Sortie : []

4. Modifier les éléments d’une liste

Modification d’un élément unique

ma_liste = [10, 20, 30, 40]
ma_liste[1] = 12
print(ma_liste)
# Sortie : [10, 12, 30, 40]

Modification d’une tranche

ma_liste[1:3] = [13, 44]
print(ma_liste)
# Sortie : [10, 13, 44, 40]

Insertion via le slicing

ma_liste[2:2] = [20, 54]
print(ma_liste)
# Sortie : [10, 13, 20, 54, 44, 40]

Explication : ma_liste[2:2] représente une position vide avant l’indice 2, permettant d’insérer des éléments sans supprimer quoi que ce soit.

5. Fonctions et méthodes intégrées

`len()` - Longueur de la liste

ma_liste = [100, 200, 300, 400, 500]
print(len(ma_liste))
# Sortie : 5

`index()` - Trouver la position d’un élément

position = ma_liste.index(400)
print(position)
# Sortie : 3

Note : Génère une erreur si l’élément n’existe pas.

Opérateur `in` - Vérifier l’existence

print(20 in ma_liste)
# Sortie : False

print(200 in ma_liste)
# Sortie : True

`count()` - Compter les occurrences

ma_liste = [100, 200, 200, 400, 500]
print(ma_liste.count(200))
# Sortie : 2

`sort()` - Trier la liste

ma_liste = [200, 100, 500, 400, 300]
ma_liste.sort()
print(ma_liste)
# Sortie : [100, 200, 300, 400, 500]

ma_liste.sort(reverse=True)
print(ma_liste)
# Sortie : [500, 400, 300, 200, 100]

Note : sort() modifie la liste en place. Pour obtenir une nouvelle liste triée sans modifier l’originale, utilisez sorted() :

ma_liste = [3, 1, 4, 1, 5]
nouvelle_liste = sorted(ma_liste)
print(nouvelle_liste)  # [1, 1, 3, 4, 5]
print(ma_liste)        # [3, 1, 4, 1, 5] (inchangée)

`reverse()` - Inverser l’ordre

ma_liste.reverse()
print(ma_liste)
# Sortie : [100, 200, 300, 400, 500]

`min()`, `max()`, `sum()` - Opérations mathématiques

ma_liste = [10, 50, 30, 20, 40]
print(min(ma_liste))  # 10
print(max(ma_liste))  # 50
print(sum(ma_liste))  # 150

6. Boucles et itérations sur une liste

Boucle `for` simple

ma_liste = [100, 200, 300, 400, 500]
for element in ma_liste:
    print(element)
# Sortie :
# 100
# 200
# 300
# 400
# 500

`enumerate()` - Obtenir l’indice et la valeur

for index, element in enumerate(ma_liste):
    print(f"Index {index} : {element}")
# Sortie :
# Index 0 : 100
# Index 1 : 200
# Index 2 : 300
# Index 3 : 400
# Index 4 : 500

Vous pouvez également spécifier un indice de départ :

for index, element in enumerate(ma_liste, start=1):
    print(f"Élément {index} : {element}")
# Sortie :
# Élément 1 : 100
# Élément 2 : 200
# ...

Boucle `while`

index = 0
while index < len(ma_liste):
    print(ma_liste[index])
    index += 1

7. Listes imbriquées (listes de listes)

Création et accès

ma_liste = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(ma_liste[0])
# Sortie : [1, 2, 3]

print(ma_liste[0][1])
# Sortie : 2

Visualisation :

     Col 0  Col 1  Col 2
Row 0  [1,    2,     3]
Row 1  [4,    5,     6]
Row 2  [7,    8,     9]

Parcourir une liste imbriquée

for sous_liste in ma_liste:
    for element in sous_liste:
        print(element)
# Sortie : 1, 2, 3, 4, 5, 6, 7, 8, 9

Aplatir une liste imbriquée

ma_liste_imbriquee = [
    [1, 2, 3],
    [4, 5],
    [6, 7, 8]
]

aplatie = [element for sous_liste in ma_liste_imbriquee for element in sous_liste]
print(aplatie)
# Sortie : [1, 2, 3, 4, 5, 6, 7, 8]

8. Les compréhensions de liste

Les compréhensions de liste offrent une syntaxe concise pour créer des listes basées sur des listes existantes.

Syntaxe de base

ma_liste = [1, 2, 3, 4, 5]
carre = [x ** 2 for x in ma_liste]
print(carre)
# Sortie : [1, 4, 9, 16, 25]

Équivalent avec une boucle classique :

carre = []
for x in ma_liste:
    carre.append(x ** 2)

Avec des conditions

pairs = [x for x in ma_liste if x % 2 == 0]
print(pairs)
# Sortie : [2, 4]

Avec condition if-else :

resultat = [x if x % 2 == 0 else x * 10 for x in ma_liste]
print(resultat)
# Sortie : [10, 2, 30, 4, 50]

Compréhensions imbriquées

ma_liste_imbriquee = [[1, 2], [3, 4]]
carre = [[x**2 for x in sous_liste] for sous_liste in ma_liste_imbriquee]
print(carre)
# Sortie : [[1, 4], [9, 16]]

Exemples pratiques

# Créer une liste de tuples (nombre, carré)
nombres = [1, 2, 3, 4]
paires = [(x, x**2) for x in nombres]
print(paires)
# Sortie : [(1, 1), (2, 4), (3, 9), (4, 16)]

# Filtrer et transformer
mots = ["hello", "world", "python"]
majuscules = [mot.upper() for mot in mots if len(mot) > 4]
print(majuscules)
# Sortie : ['HELLO', 'WORLD', 'PYTHON']

9. Méthodes avancées

`copy()` - Copier une liste

ma_liste = [1, 2, 3]
copie = ma_liste.copy()
print(copie)
# Sortie : [1, 2, 3]

Important : Différence entre copie et référence :

# Référence (les deux variables pointent vers la même liste)
liste1 = [1, 2, 3]
liste2 = liste1
liste2.append(4)
print(liste1)  # [1, 2, 3, 4] - Modifiée aussi !

# Copie (deux listes indépendantes)
liste1 = [1, 2, 3]
liste2 = liste1.copy()
liste2.append(4)
print(liste1)  # [1, 2, 3] - Inchangée

Fusionner des listes

liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
fusion = liste1 + liste2
print(fusion)
# Sortie : [1, 2, 3, 4, 5, 6]

Autres méthodes de fusion :

# Avec extend()
liste1.extend(liste2)

# Avec unpacking (*)
fusion = [*liste1, *liste2]

`map()` et `filter()`

`map()` - Appliquer une fonction à chaque élément

ma_liste = [1, 2, 3]
carres = list(map(lambda x: x**2, ma_liste))
print(carres)
# Sortie : [1, 4, 9]

`filter()` - Filtrer les éléments

pairs = list(filter(lambda x: x % 2 == 0, ma_liste))
print(pairs)
# Sortie : [2]

Comparaison avec les compréhensions de liste :

# Avec map()
carres = list(map(lambda x: x**2, ma_liste))

# Avec compréhension (plus pythonique)
carres = [x**2 for x in ma_liste]

# Avec filter()
pairs = list(filter(lambda x: x % 2 == 0, ma_liste))

# Avec compréhension (plus lisible)
pairs = [x for x in ma_liste if x % 2 == 0]

`zip()` - Combiner plusieurs listes

noms = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
combinaison = list(zip(noms, ages))
print(combinaison)
# Sortie : [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

10. Bonnes pratiques

1. Utiliser les compréhensions de liste pour plus de lisibilité

# ❌ Moins lisible
resultat = []
for x in range(10):
    if x % 2 == 0:
        resultat.append(x ** 2)

# ✅ Plus lisible
resultat = [x ** 2 for x in range(10) if x % 2 == 0]

2. Éviter de modifier une liste pendant l’itération

# ❌ Dangereux
ma_liste = [1, 2, 3, 4, 5]
for element in ma_liste:
    if element % 2 == 0:
        ma_liste.remove(element)  # Comportement imprévisible

# ✅ Correct
ma_liste = [1, 2, 3, 4, 5]
ma_liste = [x for x in ma_liste if x % 2 != 0]

3. Utiliser `enumerate()` plutôt que `range(len())`

# ❌ Moins pythonique
for i in range(len(ma_liste)):
    print(f"Index {i}: {ma_liste[i]}")

# ✅ Plus pythonique
for i, element in enumerate(ma_liste):
    print(f"Index {i}: {element}")

4. Faire attention aux copies superficielles

# Pour les listes imbriquées, copy() ne suffit pas
import copy

liste_originale = [[1, 2], [3, 4]]
copie_superficielle = liste_originale.copy()
copie_profonde = copy.deepcopy(liste_originale)

copie_superficielle[0][0] = 999
print(liste_originale)  # [[999, 2], [3, 4]] - Modifiée !

copie_profonde[1][0] = 888
print(liste_originale)  # [[999, 2], [3, 4]] - Inchangée

5. Utiliser les méthodes appropriées selon le contexte

Besoin	Méthode recommandée
Ajouter un élément	`append()`
Ajouter plusieurs éléments	`extend()`
Insérer à une position	`insert()`
Supprimer par valeur	`remove()`
Supprimer par indice	`pop()` ou `del`
Trier sans modifier l’original	`sorted()`
Trier en place	`sort()`

Résumé

Les listes Python sont des structures de données puissantes et flexibles qui offrent :

Stockage ordonné et modifiable d’éléments
Support de types mixtes
Nombreuses méthodes intégrées pour la manipulation
Syntaxe intuitive avec les compréhensions de liste
Possibilité de créer des structures complexes (listes imbriquées)

Maîtriser les listes est essentiel pour devenir un développeur Python efficace, car elles sont utilisées dans pratiquement tous les programmes Python.

📋 Évaluation des connaissances

À quoi sert cette évaluation ?

Cette évaluation rapide (3 minutes) va vous permettre de vérifier votre compréhension des listes en Python : création, manipulation, méthodes et compréhensions.

Instructions :

🕒 Temps limité : 3 minutes
🎯 Seuil de réussite : 80%
💡 Les réponses seront expliquées à la fin

À vous de jouer ! 🚀

📝 Exercices pratiques

Exercice 1 : Création et manipulation basique

Énoncé : Créez une liste contenant les nombres de 1 à 5, puis :

Ajoutez le nombre 6 à la fin
Insérez le nombre 0 au début
Affichez la liste finale

Exemple d’exécution :

# Votre code ici

Voir la solution

# Création de la liste
ma_liste = [1, 2, 3, 4, 5]
print(f"Liste initiale : {ma_liste}")

# Ajouter 6 à la fin
ma_liste.append(6)
print(f"Après append(6) : {ma_liste}")

# Insérer 0 au début
ma_liste.insert(0, 0)
print(f"Après insert(0, 0) : {ma_liste}")

Résultat attendu :

Liste initiale : [1, 2, 3, 4, 5]
Après append(6) : [1, 2, 3, 4, 5, 6]
Après insert(0, 0) : [0, 1, 2, 3, 4, 5, 6]

Exercice 2 : Slicing et indexation

Énoncé : Avec la liste nombres = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100], extrayez :

Les 3 premiers éléments
Les 3 derniers éléments
Les éléments d’indice 2 à 5
Un élément sur deux
La liste inversée

Exemple d’exécution :

nombres = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# Votre code ici

Voir la solution

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

print(f"Liste complète : {nombres}")
print()

# 3 premiers
premiers = nombres[:3]
print(f"3 premiers : {premiers}")

# 3 derniers
derniers = nombres[-3:]
print(f"3 derniers : {derniers}")

# Indices 2 à 5 (l'indice 6 n'est pas inclus)
milieu = nombres[2:6]
print(f"Indices 2 à 5 : {milieu}")

# Un sur deux
un_sur_deux = nombres[::2]
print(f"Un sur deux : {un_sur_deux}")

# Liste inversée
inverse = nombres[::-1]
print(f"Liste inversée : {inverse}")

Résultat attendu :

Liste complète : [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

3 premiers : [10, 20, 30]
3 derniers : [80, 90, 100]
Indices 2 à 5 : [30, 40, 50, 60]
Un sur deux : [10, 30, 50, 70, 90]
Liste inversée : [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

Exercice 3 : Méthodes de suppression

Énoncé : Créez une liste fruits = ["pomme", "banane", "orange", "banane", "kiwi"], puis :

Supprimez la première occurrence de “banane”
Supprimez le dernier élément avec pop()
Supprimez l’élément à l’indice 0 avec del
Affichez la liste à chaque étape

Exemple d’exécution :

fruits = ["pomme", "banane", "orange", "banane", "kiwi"]
# Votre code ici

Voir la solution

fruits = ["pomme", "banane", "orange", "banane", "kiwi"]
print(f"Liste initiale : {fruits}")

# Supprimer la première "banane"
fruits.remove("banane")
print(f"Après remove('banane') : {fruits}")

# Supprimer le dernier élément
dernier = fruits.pop()
print(f"Élément supprimé : {dernier}")
print(f"Après pop() : {fruits}")

# Supprimer l'élément à l'indice 0
del fruits[0]
print(f"Après del fruits[0] : {fruits}")

Résultat attendu :

Liste initiale : ['pomme', 'banane', 'orange', 'banane', 'kiwi']
Après remove('banane') : ['pomme', 'orange', 'banane', 'kiwi']
Élément supprimé : kiwi
Après pop() : ['pomme', 'orange', 'banane']
Après del fruits[0] : ['orange', 'banane']

Exercice 4 : Statistiques sur une liste

Énoncé : Créez une liste de notes notes = [15, 12, 18, 14, 16, 12, 19, 13], puis calculez et affichez :

Le nombre total de notes
La note minimale
La note maximale
La somme des notes
La moyenne

Exemple d’exécution :

notes = [15, 12, 18, 14, 16, 12, 19, 13]
# Votre code ici

Voir la solution

notes = [15, 12, 18, 14, 16, 12, 19, 13]

print("📊 STATISTIQUES DES NOTES")
print("-" * 40)

nombre_notes = len(notes)
note_min = min(notes)
note_max = max(notes)
somme = sum(notes)
moyenne = somme / nombre_notes

print(f"Notes : {notes}")
print(f"Nombre de notes : {nombre_notes}")
print(f"Note minimale : {note_min}")
print(f"Note maximale : {note_max}")
print(f"Somme : {somme}")
print(f"Moyenne : {moyenne:.2f}")

Résultat attendu :

📊 STATISTIQUES DES NOTES
----------------------------------------
Notes : [15, 12, 18, 14, 16, 12, 19, 13]
Nombre de notes : 8
Note minimale : 12
Note maximale : 19
Somme : 119
Moyenne : 14.88

Exercice 5 : Tri et recherche

Énoncé : Créez une liste nombres = [45, 12, 67, 23, 89, 34, 56], puis :

Triez la liste par ordre croissant
Affichez la liste triée
Trouvez l’indice du nombre 67
Vérifiez si 100 est dans la liste
Comptez combien de fois 12 apparaît

Exemple d’exécution :

nombres = [45, 12, 67, 23, 89, 34, 56]
# Votre code ici

Voir la solution

nombres = [45, 12, 67, 23, 89, 34, 56]
print(f"Liste originale : {nombres}")

# Trier
nombres.sort()
print(f"Liste triée : {nombres}")

# Trouver l'indice de 67
indice = nombres.index(67)
print(f"Indice de 67 : {indice}")

# Vérifier si 100 est dans la liste
est_present = 100 in nombres
print(f"100 est dans la liste : {est_present}")

# Compter les occurrences de 12
occurrences = nombres.count(12)
print(f"Nombre d'occurrences de 12 : {occurrences}")

Résultat attendu :

Liste originale : [45, 12, 67, 23, 89, 34, 56]
Liste triée : [12, 23, 34, 45, 56, 67, 89]
Indice de 67 : 5
100 est dans la liste : False
Nombre d'occurrences de 12 : 1

Exercice 6 : Compréhension de liste - Carrés

Énoncé : Créez une compréhension de liste qui génère les carrés des nombres de 1 à 10. Ensuite, créez une autre compréhension qui ne garde que les carrés pairs.

Exemple d’exécution :

# Votre code ici

Voir la solution

# Carrés de 1 à 10
carres = [x**2 for x in range(1, 11)]
print(f"Carrés de 1 à 10 : {carres}")

# Carrés pairs uniquement
carres_pairs = [x**2 for x in range(1, 11) if (x**2) % 2 == 0]
print(f"Carrés pairs : {carres_pairs}")

# Alternative : filtrer la liste des carrés
carres_pairs_alt = [c for c in carres if c % 2 == 0]
print(f"Carrés pairs (méthode 2) : {carres_pairs_alt}")

Résultat attendu :

Carrés de 1 à 10 : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Carrés pairs : [4, 16, 36, 64, 100]
Carrés pairs (méthode 2) : [4, 16, 36, 64, 100]

Exercice 7 : Filtrage avec compréhension

Énoncé : À partir d’une liste de mots, créez une nouvelle liste qui ne contient que les mots de plus de 5 lettres, et transformez-les en majuscules.

Exemple d’exécution :

mots = ["python", "code", "programmation", "test", "développement", "web"]
# Votre code ici

Voir la solution

mots = ["python", "code", "programmation", "test", "développement", "web"]

print(f"Liste originale : {mots}")

# Compréhension de liste avec condition et transformation
mots_longs = [mot.upper() for mot in mots if len(mot) > 5]

print(f"Mots de plus de 5 lettres (en majuscules) : {mots_longs}")

# Détails pour chaque mot
print("\nDétails :")
for mot in mots:
    longueur = len(mot)
    garde = "✅" if longueur > 5 else "❌"
    print(f"{mot:<20} ({longueur} lettres) {garde}")

Résultat attendu :

Liste originale : ['python', 'code', 'programmation', 'test', 'développement', 'web']
Mots de plus de 5 lettres (en majuscules) : ['PYTHON', 'PROGRAMMATION', 'DÉVELOPPEMENT']

Détails :
python               (6 lettres) ✅
code                 (4 lettres) ❌
programmation        (13 lettres) ✅
test                 (4 lettres) ❌
développement        (13 lettres) ✅
web                  (3 lettres) ❌

Exercice 8 : Enumerate et itération

Énoncé : Créez une liste de prénoms et utilisez enumerate() pour afficher chaque prénom avec son numéro (en commençant à 1).

Exemple d’exécution :

prenoms = ["Alice", "Bob", "Charlie", "Diana"]
# Votre code ici

Voir la solution

prenoms = ["Alice", "Bob", "Charlie", "Diana"]

print("📋 LISTE DES PARTICIPANTS")
print("-" * 40)

# Avec enumerate, démarrant à 1
for numero, prenom in enumerate(prenoms, start=1):
    print(f"{numero}. {prenom}")

print()

# Version avec indice par défaut (à partir de 0)
print("📋 AVEC INDICES (démarrant à 0)")
print("-" * 40)
for index, prenom in enumerate(prenoms):
    print(f"Index {index} : {prenom}")

Résultat attendu :

📋 LISTE DES PARTICIPANTS
----------------------------------------
1. Alice
2. Bob
3. Charlie
4. Diana

📋 AVEC INDICES (démarrant à 0)
----------------------------------------
Index 0 : Alice
Index 1 : Bob
Index 2 : Charlie
Index 3 : Diana

Exercice 9 : Listes imbriquées

Énoncé : Créez une liste représentant une matrice 3x3 (tableau de nombres), puis :

Affichez l’élément à la position (1, 2)
Calculez la somme de tous les éléments
Affichez chaque ligne sur une ligne séparée

Exemple d’exécution :

# Votre code ici

Voir la solution

# Création de la matrice 3x3
matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print("🔢 MATRICE 3x3")
print("-" * 40)

# Afficher la matrice
for ligne in matrice:
    print(ligne)

print()

# Élément à la position (1, 2)
element = matrice[1][2]
print(f"Élément à la position (1, 2) : {element}")

# Somme de tous les éléments
somme = sum(sum(ligne) for ligne in matrice)
print(f"Somme de tous les éléments : {somme}")

# Afficher chaque ligne formatée
print("\nAffichage formaté :")
for i, ligne in enumerate(matrice):
    print(f"Ligne {i} : {' '.join(map(str, ligne))}")

Résultat attendu :

🔢 MATRICE 3x3
----------------------------------------
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Élément à la position (1, 2) : 6
Somme de tous les éléments : 45

Affichage formaté :
Ligne 0 : 1 2 3
Ligne 1 : 4 5 6
Ligne 2 : 7 8 9

Exercice 10 : Fusion et dédoublonnage

Énoncé : Créez deux listes de nombres, fusionnez-les, puis créez une nouvelle liste sans doublons et triée.

Exemple d’exécution :

liste1 = [1, 3, 5, 7, 9]
liste2 = [2, 4, 5, 6, 9, 10]
# Votre code ici

Voir la solution

liste1 = [1, 3, 5, 7, 9]
liste2 = [2, 4, 5, 6, 9, 10]

print(f"Liste 1 : {liste1}")
print(f"Liste 2 : {liste2}")
print()

# Fusion des deux listes
fusion = liste1 + liste2
print(f"Fusion : {fusion}")

# Méthode 1 : Utiliser set() pour éliminer les doublons
sans_doublons = sorted(list(set(fusion)))
print(f"Sans doublons (méthode 1 - set) : {sans_doublons}")

# Méthode 2 : Compréhension de liste avec condition
sans_doublons_v2 = []
for nombre in fusion:
    if nombre not in sans_doublons_v2:
        sans_doublons_v2.append(nombre)
sans_doublons_v2.sort()
print(f"Sans doublons (méthode 2 - manuelle) : {sans_doublons_v2}")

# Statistiques
print(f"\nNombre d'éléments dans la fusion : {len(fusion)}")
print(f"Nombre d'éléments uniques : {len(sans_doublons)}")
print(f"Nombre de doublons supprimés : {len(fusion) - len(sans_doublons)}")

Résultat attendu :

Liste 1 : [1, 3, 5, 7, 9]
Liste 2 : [2, 4, 5, 6, 9, 10]

Fusion : [1, 3, 5, 7, 9, 2, 4, 5, 6, 9, 10]
Sans doublons (méthode 1 - set) : [1, 2, 3, 4, 5, 6, 7, 9, 10]
Sans doublons (méthode 2 - manuelle) : [1, 2, 3, 4, 5, 6, 7, 9, 10]

Nombre d'éléments dans la fusion : 11
Nombre d'éléments uniques : 9
Nombre de doublons supprimés : 2

Exercice 11 : Gestionnaire de tâches

Énoncé : Créez un gestionnaire de tâches simple avec les fonctionnalités suivantes :

Ajouter une tâche
Afficher toutes les tâches avec leur numéro
Supprimer une tâche par son numéro
Compter le nombre de tâches

Exemple d’exécution :

# Votre code ici

Voir la solution

# Initialisation de la liste de tâches
taches = []

print("📝 GESTIONNAIRE DE TÂCHES")
print("=" * 50)

# Ajouter des tâches
taches.append("Apprendre Python")
taches.append("Faire les exercices")
taches.append("Réviser les listes")

print("\n✅ 3 tâches ajoutées")

# Afficher toutes les tâches
print("\n📋 LISTE DES TÂCHES :")
print("-" * 50)
for numero, tache in enumerate(taches, start=1):
    print(f"{numero}. {tache}")

# Compter les tâches
nombre_taches = len(taches)
print(f"\nNombre total de tâches : {nombre_taches}")

# Supprimer une tâche (exemple : tâche numéro 2)
tache_a_supprimer = 2
if 1 <= tache_a_supprimer <= len(taches):
    tache_supprimee = taches.pop(tache_a_supprimer - 1)
    print(f"\n❌ Tâche supprimée : '{tache_supprimee}'")

# Afficher la liste mise à jour
print("\n📋 LISTE MISE À JOUR :")
print("-" * 50)
for numero, tache in enumerate(taches, start=1):
    print(f"{numero}. {tache}")

print(f"\nNombre de tâches restantes : {len(taches)}")

Résultat attendu :

📝 GESTIONNAIRE DE TÂCHES
==================================================

✅ 3 tâches ajoutées

📋 LISTE DES TÂCHES :
--------------------------------------------------
1. Apprendre Python
2. Faire les exercices
3. Réviser les listes

Nombre total de tâches : 3

❌ Tâche supprimée : 'Faire les exercices'

📋 LISTE MISE À JOUR :
--------------------------------------------------
1. Apprendre Python
2. Réviser les listes

Nombre de tâches restantes : 2

Exercice 12 : Analyse de données avec compréhensions

Énoncé : À partir d’une liste de températures en Celsius, créez :

Une liste avec les températures en Fahrenheit (F = C × 9/5 + 32)
Une liste des températures supérieures à 20°C
La température moyenne
Le nombre de températures négatives

Exemple d’exécution :

temperatures_celsius = [15, -5, 22, 18, 30, -2, 25, 12]
# Votre code ici

Voir la solution

temperatures_celsius = [15, -5, 22, 18, 30, -2, 25, 12]

print("🌡️ ANALYSE DES TEMPÉRATURES")
print("=" * 60)

print(f"\n📊 Températures en Celsius : {temperatures_celsius}")

# Conversion en Fahrenheit
temperatures_fahrenheit = [c * 9/5 + 32 for c in temperatures_celsius]
print(f"\n📊 Températures en Fahrenheit : {[f'{t:.1f}' for t in temperatures_fahrenheit]}")

# Températures supérieures à 20°C
temps_chauds = [t for t in temperatures_celsius if t > 20]
print(f"\n🔥 Températures > 20°C : {temps_chauds}")

# Température moyenne
moyenne = sum(temperatures_celsius) / len(temperatures_celsius)
print(f"\n📈 Température moyenne : {moyenne:.2f}°C")

# Nombre de températures négatives
nb_negatives = len([t for t in temperatures_celsius if t < 0])
print(f"\n❄️ Nombre de températures négatives : {nb_negatives}")

# Températures min et max
temp_min = min(temperatures_celsius)
temp_max = max(temperatures_celsius)
print(f"\n🌡️ Température minimale : {temp_min}°C")
print(f"🌡️ Température maximale : {temp_max}°C")
print(f"📏 Amplitude thermique : {temp_max - temp_min}°C")

Résultat attendu :

🌡️ ANALYSE DES TEMPÉRATURES
============================================================

📊 Températures en Celsius : [15, -5, 22, 18, 30, -2, 25, 12]

📊 Températures en Fahrenheit : ['59.0', '23.0', '71.6', '64.4', '86.0', '28.4', '77.0', '53.6']

🔥 Températures > 20°C : [22, 30, 25]

📈 Température moyenne : 14.38°C

❄️ Nombre de températures négatives : 2

🌡️ Température minimale : -5°C
🌡️ Température maximale : 30°C
📏 Amplitude thermique : 35°C

📢 Partagez cet article

LinkedIn Twitter Facebook WhatsApp

À propos de l'auteur

Riyad ODJOUADEExpert en cybersécurité & infrastructure

Je partage des guides techniques pratiques sur la cybersécurité, l'administration système et le développement web. Tous les contenus sont basés sur des expérimentations réelles.

LinkedIn GitHub Email

Dernière mise à jour : 31 Décembre 2025

Guide complet des listes en Python

Guide complet des listes en Python

Introduction

1. Création de listes

Liste vide

Liste avec des valeurs initiales

Liste avec des éléments de types différents

Générer automatiquement des valeurs avec range()

2. Accéder aux éléments d’une liste

Indexation simple

Indexation négative

Le slicing (découpage)

Le pas (step) dans le slicing

3. Ajouter et supprimer des éléments

Ajouter des éléments

append() - Ajouter à la fin

insert() - Insérer à une position

extend() - Ajouter plusieurs éléments

Supprimer des éléments

remove() - Supprimer par valeur

pop() - Supprimer par indice et retourner l’élément

del - Supprimer par indice ou tranche

clear() - Vider la liste

4. Modifier les éléments d’une liste

Modification d’un élément unique

Modification d’une tranche

Insertion via le slicing

5. Fonctions et méthodes intégrées

len() - Longueur de la liste

index() - Trouver la position d’un élément

Opérateur in - Vérifier l’existence

count() - Compter les occurrences

sort() - Trier la liste

reverse() - Inverser l’ordre

min(), max(), sum() - Opérations mathématiques

6. Boucles et itérations sur une liste

Boucle for simple

enumerate() - Obtenir l’indice et la valeur

Boucle while

7. Listes imbriquées (listes de listes)

Création et accès

Parcourir une liste imbriquée

Aplatir une liste imbriquée

8. Les compréhensions de liste

Syntaxe de base

Avec des conditions

Compréhensions imbriquées

Exemples pratiques

9. Méthodes avancées

copy() - Copier une liste

Fusionner des listes

map() et filter()

map() - Appliquer une fonction à chaque élément

filter() - Filtrer les éléments

zip() - Combiner plusieurs listes

10. Bonnes pratiques

1. Utiliser les compréhensions de liste pour plus de lisibilité

2. Éviter de modifier une liste pendant l’itération

3. Utiliser enumerate() plutôt que range(len())

4. Faire attention aux copies superficielles

5. Utiliser les méthodes appropriées selon le contexte

Résumé

📋 Évaluation des connaissances

À quoi sert cette évaluation ?

📝 Exercices pratiques

📢 Partagez cet article

À propos de l'auteur

Générer automatiquement des valeurs avec `range()`

`append()` - Ajouter à la fin

`insert()` - Insérer à une position

`extend()` - Ajouter plusieurs éléments

`remove()` - Supprimer par valeur

`pop()` - Supprimer par indice et retourner l’élément

`del` - Supprimer par indice ou tranche

`clear()` - Vider la liste

`len()` - Longueur de la liste

`index()` - Trouver la position d’un élément

Opérateur `in` - Vérifier l’existence

`count()` - Compter les occurrences

`sort()` - Trier la liste

`reverse()` - Inverser l’ordre

`min()`, `max()`, `sum()` - Opérations mathématiques

Boucle `for` simple

`enumerate()` - Obtenir l’indice et la valeur

Boucle `while`

`copy()` - Copier une liste

`map()` et `filter()`

`map()` - Appliquer une fonction à chaque élément

`filter()` - Filtrer les éléments

`zip()` - Combiner plusieurs listes

3. Utiliser `enumerate()` plutôt que `range(len())`