Les listes en langage Python#
En Python, une liste (list) est une séquence ordonnée et mutable pouvant contenir une collection d'éléments, homogènes ou hétérogènes. Contrairement aux tableaux statiques du C, les listes Python sont dynamiques : leur taille s'adapte automatiquement au fur et à mesure des insertions et suppressions.
1. Création et indexation (Positif et Négatif)#
On définit une liste en plaçant ses éléments entre crochets [...], séparés par des virgules :
# Liste vide
vide = []
vide_alt = list()
# Liste hétérogène (types variés acceptés)
profil = ["Alice", 28, 1.72, True]
# Liste homogène de nombres
notes = [12.5, 14.0, 18.5, 9.0, 16.0]
Double indexation : Indices positifs et négatifs#
En Python, chaque élément possède deux indices :
- De gauche à droite (positif) : de 0 à N - 1.
- De droite à gauche (négatif) : de -1 (le dernier élément) à -N (le premier).
langages = ["Python", "C", "SQL", "R", "Java"]
print(langages[0]) # "Python" (premier élément)
print(langages[-1]) # "Java" (dernier élément)
print(langages[-2]) # "R" (avant-dernier élément)
2. Le découpage de listes (Slicing)#
Le slicing permet d'extraire une sous-liste avec la syntaxe liste[debut:fin:pas] :
- debut : indice de départ (inclus, par défaut 0).
- fin : indice d'arrivée (exclu, par défaut la fin de liste).
- pas : incrément de déplacement (par défaut 1).
chiffres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 1. Extraire les 3 premiers éléments
print(chiffres[:3]) # [0, 1, 2]
# 2. Extraire du 3e au 7e exclu
print(chiffres[3:7]) # [3, 4, 5, 6]
# 3. Prendre un élément sur deux (pas de 2)
print(chiffres[::2]) # [0, 2, 4, 6, 8]
# 4. Inverser élégamment une liste (pas négatif)
print(chiffres[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3. Méthodes fondamentales de manipulation#
Les listes étant mutables, vous pouvez modifier leur contenu in-place :
A. Ajout d'éléments#
fruits = ["pomme", "banane"]
# append() : ajoute un seul élément à la fin
fruits.append("orange")
print(fruits) # ['pomme', 'banane', 'orange']
# insert() : insère à un indice précis
fruits.insert(1, "mangue")
print(fruits) # ['pomme', 'mangue', 'banane', 'orange']
# extend() : fusionne une autre collection à la suite
fruits.extend(["ananas", "kiwi"])
print(fruits) # ['pomme', 'mangue', 'banane', 'orange', 'ananas', 'kiwi']
B. Suppression d'éléments#
# remove() : supprime la PREMIÈRE occurrence de la valeur spécifiée
fruits.remove("banane")
# pop() : extrait et renvoie l'élément à l'indice donné (par défaut le dernier)
dernier = fruits.pop()
print(f"Retire : {dernier}") # "kiwi"
# del : mot-clé pour supprimer un indice ou une tranche
del fruits[0] # Supprime le premier élément
# clear() : vide intégralement la liste
fruits.clear()
C. Recherche et tri#
scores = [45, 12, 89, 34, 12, 90]
# count() : compte les occurrences
print(scores.count(12)) # 2
# index() : trouve le premier indice d'une valeur
print(scores.index(89)) # 2
# sort() : tri in-place (modifie la liste originale)
scores.sort(reverse=True) # Tri décroissant
print(scores) # [90, 89, 45, 34, 12, 12]
# sorted() : fonction native qui renvoie une NOUVELLE liste triée
nouveau_tri = sorted([5, 2, 9])
4. Le piège classique de la copie par référence#
C'est l'un des bugs les plus fréquents chez les débutants en Python :
# ATTENTION : Erreur classique
liste_a = [1, 2, 3]
liste_b = liste_a # Ne copie PAS la liste ! Copie seulement la référence mémoire !
liste_b.append(99)
print(liste_a) # [1, 2, 3, 99] -> liste_a a été modifiée à nos dépens !
flowchart LR
subgraph References
A[liste_a]
B[liste_b = liste_a]
end
subgraph Objet Unique en Memoire
Obj["[1, 2, 3, 99]"]
end
A --> Obj
B --> Obj
Comment copier correctement une liste ?#
Pour obtenir un duplicata indépendant, il faut faire une copie superficielle (shallow copy) :
# Méthode 1 : méthode .copy()
liste_b = liste_a.copy()
# Méthode 2 : slicing complet
liste_b = liste_a[:]
# Méthode 3 : constructeur list()
liste_b = list(liste_a)
(Pour copier des listes imbriquées de listes, utilisez copy.deepcopy() du module copy).
5. Les compréhensions de listes (List Comprehensions)#
Les compréhensions de listes constituent l'une des fonctionnalités les plus puissantes et idiomatiques de Python. Elles permettent de filtrer et transformer des données de manière concise et optimisée :
# Approche impérative classique (5 lignes) :
carres_pairs = []
for x in range(10):
if x % 2 == 0:
carres_pairs.append(x ** 2)
# Approche déclarative par compréhension (1 ligne claire et rapide) :
carres_pairs = [x ** 2 for x in range(10) if x % 2 == 0]
print(carres_pairs) # [0, 4, 16, 36, 64]
6. Mise en pratique : Traitement de relevés de notes#
# Jeu de données d'un examen
notes_brutes = [14.5, 9.0, 18.0, 7.5, 12.0, 16.5, 8.0, 15.0]
# 1. Filtrer les étudiants admis (note >= 10) avec une compréhension
admis = [n for n in notes_brutes if n >= 10.0]
# 2. Calculer les statistiques
moyenne_promo = sum(notes_brutes) / len(notes_brutes)
meilleure_note = max(notes_brutes)
pire_note = min(notes_brutes)
taux_reussite = (len(admis) / len(notes_brutes)) * 100.0
print("=== STATISTIQUES DE L'EXAMEN ===")
print(f"Effectif total : {len(notes_brutes)} etudiants")
print(f"Moyenne de classe : {moyenne_promo:.2f} / 20")
print(f"Note maximale : {meilleure_note:.2f} / 20")
print(f"Note minimale : {pire_note:.2f} / 20")
print(f"Taux d'admission : {taux_reussite:.1f}% ({len(admis)} recus)")
7. Défi d'application#
À l'aide d'une seule compréhension de liste, prenez une liste de prénoms ["alice", "BOB", "charlie", "DIANA"] et produisez une nouvelle liste où tous les prénoms sont formatés avec la première lettre en majuscule et le reste en minuscules (méthode .capitalize()), en ne conservant que les prénoms ayant strictement plus de 3 lettres.
Commentaires