Notion de listes

En Python, une liste est une collection ordonnée et modifiable d'éléments. Imaginez-la comme une boîte où vous pouvez ranger plusieurs objets dans un ordre précis.

Voici les caractéristiques clés à retenir :

• Collection ordonnée : Les éléments d'une liste ont un ordre défini. Le premier élément est toujours le premier, le deuxième est toujours le deuxième, et ainsi de suite. Cet ordre ne change pas, sauf si vous le modifiez explicitement.
• Éléments modifiables : Une fois qu'une liste est créée, vous pouvez ajouter, supprimer ou modifier ses éléments. On dit qu'une liste est mutable. C'est une différence majeure avec d'autres types de collections comme les tuples, qui sont immutables.
• Types d'éléments hétérogènes : Une liste peut contenir des éléments de différents types de données. Vous pouvez avoir des nombres entiers, des chaînes de caractères, des nombres décimaux, des booléens, et même d'autres listes, le tout dans la même liste !

Exemple : Une liste de nombres : [1, 5, 9, 12] Une liste de noms : ["Alice", "Bob", "Charlie"] Une liste mixte : ["pomme", 3, True, 3.14]

La création d'une liste est très simple en Python.

Syntaxe avec crochets : Pour créer une liste, on utilise des crochets [] et on sépare les éléments par des virgules.

# Une liste de nombres entiers
ma_liste_de_nombres = [10, 20, 30, 40, 50]
print(ma_liste_de_nombres) # Affiche : [10, 20, 30, 40, 50]

# Une liste de chaînes de caractères (strings)
liste_de_fruits = ["pomme", "banane", "orange"]
print(liste_de_fruits) # Affiche : ['pomme', 'banane', 'orange']

# Une liste mixte
liste_mixte = ["Python", 3.14, 10, True]
print(liste_mixte) # Affiche : ['Python', 3.14, 10, True]

Liste vide : Vous pouvez créer une liste qui ne contient aucun élément. C'est utile lorsque vous voulez construire une liste progressivement.

liste_vide = []
print(liste_vide) # Affiche : []

Initialisation avec des valeurs : Souvent, vous savez déjà quels éléments vous voulez mettre dans votre liste dès le début.

jours_semaine = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]
print(jours_semaine)

Pour récupérer un élément spécifique d'une liste, on utilise son index (sa position).

Indexation (positive et négative) :

• Les listes sont indexées à partir de 0. Cela signifie que le premier élément est à l'index 0, le deuxième à l'index 1, et ainsi de suite.
• On peut aussi utiliser des index négatifs : -1 fait référence au dernier élément, -2 à l'avant-dernier, etc.

couleurs = ["rouge", "vert", "bleu", "jaune"]

# Accès avec index positif
print(couleurs[0]) # Affiche : rouge (premier élément)
print(couleurs[2]) # Affiche : bleu (troisième élément)

# Accès avec index négatif
print(couleurs[-1]) # Affiche : jaune (dernier élément)
print(couleurs[-3]) # Affiche : vert (troisième élément en partant de la fin)

Premier et dernier élément : Comme vu ci-dessus :

• Le premier élément est toujours liste[0].
• Le dernier élément est toujours liste[-1].

Erreur d'index : Si vous essayez d'accéder à un index qui n'existe pas (par exemple, un index supérieur ou égal à la longueur de la liste, ou un index négatif trop grand), Python déclenchera une erreur IndexError.

ma_liste = [10, 20, 30]
# print(ma_liste[3]) # Ceci provoquerait une erreur : IndexError: list index out of range
# print(ma_liste[-4]) # Ceci provoquerait aussi une erreur

Toujours vérifier la taille de la liste avant d'accéder à un index dont vous n'êtes pas sûr.

Pour changer la valeur d'un élément existant, vous utilisez l'index de cet élément et lui affectez une nouvelle valeur.

Affectation par index :

fruits = ["pomme", "banane", "cerise"]
print(fruits) # Affiche : ['pomme', 'banane', 'cerise']

# Modifier le deuxième élément (index 1)
fruits[1] = "mangue"
print(fruits) # Affiche : ['pomme', 'mangue', 'cerise']

# Modifier le premier élément
fruits[0] = "poire"
print(fruits) # Affiche : ['poire', 'mangue', 'cerise']

Impact sur la liste : La modification est en place, c'est-à-dire qu'elle affecte directement la liste originale. Il n'y a pas de nouvelle liste créée.

Il existe plusieurs façons d'ajouter des éléments à une liste.

Méthode append() : La méthode append() ajoute un élément à la fin de la liste. C'est la façon la plus courante d'ajouter un seul élément.

ma_liste = [1, 2, 3]
ma_liste.append(4)
print(ma_liste) # Affiche : [1, 2, 3, 4]

ma_liste.append("cinq")
print(ma_liste) # Affiche : [1, 2, 3, 4, 'cinq']

Méthode insert() : La méthode insert(index, element) vous permet d'ajouter un élément à une position spécifique dans la liste. L'élément existant à cet index et tous les suivants sont décalés d'une position vers la droite.

nombres = [10, 30, 40]
nombres.insert(1, 20) # Insère 20 à l'index 1
print(nombres) # Affiche : [10, 20, 30, 40]

nombres.insert(0, 5) # Insère 5 au début de la liste
print(nombres) # Affiche : [5, 10, 20, 30, 40]

nombres.insert(len(nombres), 50) # Insère 50 à la fin (équivalent à append)
print(nombres) # Affiche : [5, 10, 20, 30, 40, 50]

Si l'index est trop grand, l'élément est ajouté à la fin. Si l'index est négatif et trop petit, il est ajouté au début.

Ajout de plusieurs éléments (avec extend()) : Pour ajouter tous les éléments d'une autre liste (ou de n'importe quel itérable) à la fin de la liste actuelle, utilisez la méthode extend().

liste1 = [1, 2, 3]
liste2 = [4, 5]
liste1.extend(liste2)
print(liste1) # Affiche : [1, 2, 3, 4, 5]

# Note : append() ajouterait la liste2 comme un seul élément !
liste3 = [1, 2]
liste3.append([3, 4])
print(liste3) # Affiche : [1, 2, [3, 4]]

Il existe plusieurs façons de supprimer des éléments d'une liste, selon que vous connaissez l'élément lui-même ou son index.

Instruction del : L'instruction del supprime un élément à un index donné.

couleurs = ["rouge", "vert", "bleu", "jaune"]
del couleurs[1] # Supprime l'élément à l'index 1 ("vert")
print(couleurs) # Affiche : ['rouge', 'bleu', 'jaune']

del couleurs[-1] # Supprime le dernier élément ("jaune")
print(couleurs) # Affiche : ['rouge', 'bleu']

# Vous pouvez même supprimer la liste entière (variable)
# del couleurs
# print(couleurs) # Ceci provoquerait une erreur : NameError: name 'couleurs' is not defined

Méthode remove() : La méthode remove(valeur) supprime la première occurrence de la valeur spécifiée dans la liste.

animaux = ["chien", "chat", "oiseau", "chien"]
animaux.remove("chien") # Supprime la première occurrence de "chien"
print(animaux) # Affiche : ['chat', 'oiseau', 'chien']

# Si l'élément n'est pas dans la liste, cela provoque une erreur ValueError
# animaux.remove("poisson") # Ceci provoquerait une erreur

Il est souvent judicieux de vérifier si l'élément existe avant de le supprimer avec remove().

Méthode pop() : La méthode pop(index) supprime l'élément à l'index spécifié et le retourne. Si aucun index n'est fourni, pop() supprime et retourne le dernier élément de la liste.

taches = ["lire", "écrire", "coder", "dormir"]

tache_terminee = taches.pop(2) # Supprime et retourne l'élément à l'index 2 ("coder")
print(taches) # Affiche : ['lire', 'écrire', 'dormir']
print(f"Tâche terminée : {tache_terminee}") # Affiche : Tâche terminée : coder

derniere_tache = taches.pop() # Supprime et retourne le dernier élément ("dormir")
print(taches) # Affiche : ['lire', 'écrire']
print(f"Dernière tâche : {derniere_tache}") # Affiche : Dernière tâche : dormir

# Si la liste est vide ou l'index hors limites, cela provoque une erreur IndexError
# liste_vide.pop() # Erreur

La fonction len() est universelle en Python et permet de connaître le nombre d'éléments dans de nombreuses collections, y compris les listes.

ma_liste = [10, 20, 30, 40]
longueur = len(ma_liste)
print(f"La liste contient {longueur} éléments.") # Affiche : La liste contient 4 éléments.

liste_vide = []
print(f"La liste vide contient {len(liste_vide)} éléments.") # Affiche : La liste vide contient 0 éléments.

len() est très utile pour éviter les erreurs d'index en connaissant la taille maximale de la liste.

Opérateur + (Concaténation) : Vous pouvez joindre deux listes ou plus pour en créer une nouvelle en utilisant l'opérateur +.

liste_a = [1, 2]
liste_b = [3, 4]
liste_c = liste_a + liste_b
print(liste_c) # Affiche : [1, 2, 3, 4]

# La concaténation ne modifie pas les listes originales
print(liste_a) # Affiche : [1, 2]

Opérateur * (Répétition) : L'opérateur * permet de créer une nouvelle liste en répétant les éléments d'une liste existante un certain nombre de fois.

zeros = [0] * 5
print(zeros) # Affiche : [0, 0, 0, 0, 0]

motif = ["a", "b"] * 3
print(motif) # Affiche : ['a', 'b', 'a', 'b', 'a', 'b']

Attention : La répétition de listes contenant des objets mutables (comme d'autres listes) peut entraîner des comportements inattendus. Chaque référence dans la liste répétée pointe vers le MÊME objet.

liste_interne = [1]
liste_externe = [liste_interne] * 3
print(liste_externe) # Affiche : [[1], [1], [1]]

liste_externe[0][0] = 99 # Modification du premier élément de la première sous-liste
print(liste_externe) # Affiche : [[99], [99], [99]] - Toutes les sous-listes sont affectées !

Pour éviter cela, utilisez des compréhensions de liste ou la méthode copy() pour créer des copies indépendantes.

Pour savoir si un élément est présent ou non dans une liste, on utilise les opérateurs in et not in.

Opérateur in : Retourne True si l'élément est trouvé dans la liste, sinon False.

fruits = ["pomme", "banane", "orange"]
print("banane" in fruits) # Affiche : True
print("kiwi" in fruits)   # Affiche : False

Opérateur not in : Retourne True si l'élément n'est PAS trouvé dans la liste, sinon False.

print("kiwi" not in fruits)   # Affiche : True
print("pomme" not in fruits) # Affiche : False

Ces opérateurs sont très pratiques pour la recherche d'un élément sans avoir à parcourir manuellement la liste.

Parcourir une liste signifie visiter chaque élément de la liste, généralement pour effectuer une opération sur chacun d'eux.

Boucle for avec in : C'est la méthode la plus simple et la plus idiomatique pour parcourir les éléments d'une liste.

nombres = [1, 2, 3, 4, 5]
for nombre in nombres:
    print(nombre * 2)
# Affiche :
# 2
# 4
# 6
# 8
# 10

Cette méthode est idéale si vous avez seulement besoin des éléments eux-mêmes.

Boucle for avec range(len()) : Si vous avez besoin d'accéder à la fois aux éléments et à leurs indices, utilisez range(len(liste)).

fruits = ["pomme", "banane", "orange"]
for i in range(len(fruits)):
    print(f"L'élément à l'index {i} est {fruits[i]}.")
# Affiche :
# L'élément à l'index 0 est pomme.
# L'élément à l'index 1 est banane.
# L'élément à l'index 2 est orange.

Utilisation de enumerate() (pour éléments ET indices) : La fonction enumerate() est souvent préférée à range(len()) car elle est plus lisible et plus directe pour obtenir à la fois l'indice et la valeur.

legumes = ["carotte", "brocoli", "chou"]
for index, legume in enumerate(legumes):
    print(f"Le légume n°{index + 1} est {legume}.")
# Affiche :
# Le légume n°1 est carotte.
# Le légume n°2 est brocoli.
# Le légume n°3 est chou.

enumerate() est la méthode recommandée lorsque vous avez besoin de l'index et de la valeur simultanément.

Le slicing (tranchage) est une fonctionnalité puissante de Python pour extraire des sous-parties d'une liste. Il crée une nouvelle liste sans modifier l'originale.

Syntaxe [début:fin:pas] :

• début : L'index de départ (inclus). Si omis, commence au début de la liste (index 0).
• fin : L'index de fin (exclu). Si omis, va jusqu'à la fin de la liste.
• pas : Le pas (intervalle) entre les éléments. Si omis, le pas est de 1.

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

# Tranche de l'index 2 (inclus) à l'index 5 (exclu)
sous_liste = ma_liste[2:5]
print(sous_liste) # Affiche : [30, 40, 50]

# Tranche du début jusqu'à l'index 4 (exclu)
debut_liste = ma_liste[:4]
print(debut_liste) # Affiche : [10, 20, 30, 40]

# Tranche de l'index 6 (inclus) jusqu'à la fin
fin_liste = ma_liste[6:]
print(fin_liste) # Affiche : [70, 80, 90]

# Tranche avec un pas de 2
pas_deux = ma_liste[::2]
print(pas_deux) # Affiche : [10, 30, 50, 70, 90]

# Tranche avec un pas négatif (inverse la liste)
inverse_liste = ma_liste[::-1]
print(inverse_liste) # Affiche : [90, 80, 70, 60, 50, 40, 30, 20, 10]

Tranches partielles et avec pas : Ces exemples montrent la flexibilité du slicing. C'est un outil très puissant pour manipuler des séquences.

Lorsqu'on travaille avec des listes, il est crucial de comprendre la différence entre assigner une référence et créer une copie.

Copie superficielle (slice complet) : La manière la plus simple de créer une copie superficielle d'une liste est d'utiliser un slice complet [:]. Cela crée une nouvelle liste qui contient les mêmes éléments que l'originale.

originale = [1, 2, 3]
copie_slice = originale[:] # Crée une nouvelle liste
print(copie_slice) # Affiche : [1, 2, 3]

copie_slice[0] = 99
print(copie_slice) # Affiche : [99, 2, 3]
print(originale)   # Affiche : [1, 2, 3] (originale n'est pas modifiée)

Méthode copy() : La méthode .copy() est une autre façon explicite de créer une copie superficielle d'une liste.

originale = ["A", "B", "C"]
copie_methode = originale.copy()
print(copie_methode) # Affiche : ['A', 'B', 'C']

copie_methode[1] = "X"
print(copie_methode) # Affiche : ['A', 'X', 'C']
print(originale)     # Affiche : ['A', 'B', 'C'] (originale n'est pas modifiée)

Impact des modifications : Dans les deux cas ([:] et .copy()), la liste copiée est indépendante de l'originale pour les éléments "simples" (nombres, chaînes, booléens). Modifier la copie n'affecte pas l'originale, et vice-versa. Cependant, pour les listes contenant des objets mutables (comme d'autres listes), une copie superficielle ne copie que les références à ces objets internes.

liste_avec_listes = [[1, 2], [3, 4]]
copie_superficielle = liste_avec_listes.copy()

copie_superficielle[0][0] = 99 # Modifie la sous-liste interne
print(copie_superficielle) # Affiche : [[99, 2], [3, 4]]
print(liste_avec_listes)   # Affiche : [[99, 2], [3, 4]] -> L'originale est aussi modifiée !

Pour une copie entièrement indépendante (copie profonde), il faut utiliser le module copy et sa fonction deepcopy(). C'est un sujet plus avancé.

Comprendre comment Python gère les variables et les objets est fondamental.

Affectation simple (référence) : Quand vous faites liste_b = liste_a, vous ne créez pas une nouvelle liste. Vous faites en sorte que la variable liste_b pointe vers la même liste en mémoire que liste_a. Les deux variables sont des références au même objet.

liste_1 = [10, 20, 30]
liste_2 = liste_1 # liste_2 référence la même liste que liste_1

liste_2[0] = 100 # Modification via liste_2
print(liste_1)   # Affiche : [100, 20, 30] -> liste_1 est aussi modifiée !
print(liste_2)   # Affiche : [100, 20, 30]

Comportement inattendu : C'est une source d'erreurs fréquentes pour les débutants. Si vous modifiez liste_2, vous modifiez liste_1 parce qu'il s'agit du même objet.

Importance de la copie : Si vous voulez une liste indépendante, vous devez explicitement créer une copie en utilisant [:] ou .copy(). ==Retenez bien : L'affectation = ne copie pas les listes, elle crée une nouvelle référence. Pour copier, utilisez [:] ou .copy().==

Méthode sort() (en place) : La méthode sort() trie les éléments de la liste directement (en place). Elle ne retourne rien (None).

nombres = [3, 1, 4, 1, 5, 9, 2]
nombres.sort() # Tri par défaut (croissant)
print(nombres) # Affiche : [1, 1, 2, 3, 4, 5, 9]

mots = ["pomme", "orange", "banane"]
mots.sort()
print(mots) # Affiche : ['banane', 'orange', 'pomme']

# Tri décroissant
nombres.sort(reverse=True)
print(nombres) # Affiche : [9, 5, 4, 3, 2, 1, 1]

La méthode sort() modifie la liste originale.

Fonction sorted() (nouvelle liste) : La fonction sorted() prend une liste (ou tout itérable) en argument et retourne une nouvelle liste triée, laissant la liste originale inchangée.

nombres = [3, 1, 4, 1, 5, 9, 2]
liste_triee = sorted(nombres)
print(liste_triee) # Affiche : [1, 1, 2, 3, 4, 5, 9]
print(nombres)     # Affiche : [3, 1, 4, 1, 5, 9, 2] (originale non modifiée)

# Tri décroissant avec sorted()
liste_triee_desc = sorted(nombres, reverse=True)
print(liste_triee_desc) # Affiche : [9, 5, 4, 3, 2, 1, 1]

Utilisez sort() quand vous voulez modifier la liste existante, et sorted() quand vous voulez une nouvelle liste triée sans altérer l'originale.

Méthode index() : La méthode index(valeur) retourne l'index de la première occurrence de la valeur spécifiée.

animaux = ["chien", "chat", "oiseau", "chien"]
position_chat = animaux.index("chat")
print(f"Le chat est à l'index : {position_chat}") # Affiche : Le chat est à l'index : 1

# Gestion des erreurs (ValueError) : si l'élément n'est pas trouvé
try:
    position_poisson = animaux.index("poisson")
    print(position_poisson)
except ValueError:
    print("Le poisson n'est pas dans la liste.")

Toujours utiliser un bloc try-except ou vérifier l'appartenance avec in avant d'appeler index() pour éviter les erreurs.

Méthode count() : La méthode count(valeur) retourne le nombre de fois qu'une valeur spécifiée apparaît dans la liste.

notes = [15, 12, 18, 15, 10, 15]
nombre_de_15 = notes.count(15)
print(f"Le nombre 15 apparaît {nombre_de_15} fois.") # Affiche : Le nombre 15 apparaît 3 fois.

nombre_de_20 = notes.count(20)
print(f"Le nombre 20 apparaît {nombre_de_20} fois.") # Affiche : Le nombre 20 apparaît 0 fois.

Méthode reverse() : La méthode reverse() inverse l'ordre des éléments de la liste en place. Elle ne retourne rien.

chiffres = [1, 2, 3, 4, 5]
chiffres.reverse()
print(chiffres) # Affiche : [5, 4, 3, 2, 1]

Slice [::-1] : Comme vu précédemment dans le slicing, utiliser [::-1] crée une nouvelle liste qui est l'inverse de l'originale. La liste originale n'est pas modifiée.

lettres = ["a", "b", "c", "d"]
lettres_inversees = lettres[::-1]
print(lettres_inversees) # Affiche : ['d', 'c', 'b', 'a']
print(lettres)           # Affiche : ['a', 'b', 'c', 'd'] (originale non modifiée)

Choisissez la méthode d'inversion en fonction de si vous voulez modifier la liste originale ou obtenir une nouvelle liste inversée.