Notion de liste

En Python, une liste est une collection ordonnée d'éléments. Imaginez une liste de courses ou une liste d'élèves dans une classe. Chaque élément a une place spécifique et un ordre bien défini.

Voici les caractéristiques clés d'une liste :

• Collection ordonnée : L'ordre des éléments est maintenu. Le premier élément reste le premier, le deuxième le deuxième, etc.
• Éléments modifiables : C'est une caractéristique très importante ! Une fois créée, vous pouvez ajouter, supprimer ou modifier les éléments d'une liste. On dit qu'une liste est mutable.
• Types de données hétérogènes : Une liste peut contenir des éléments de types différents. Par exemple, elle peut contenir à la fois des nombres entiers, des chaînes de caractères, des nombres décimaux, et même d'autres listes !

Exemple : [1, "pomme", 3.14, True] est une liste valide.

Pour créer une liste en Python, c'est très simple :

• Vous utilisez des crochets [] pour délimiter la liste.
• Les éléments de la liste sont séparés par des virgules ,.

Pour créer une liste vide (qui ne contient aucun élément), il suffit d'écrire [].

# Une liste vide
ma_liste_vide = []
print(ma_liste_vide) # Affiche : []

# Une liste avec des éléments
ma_premiere_liste = [10, 20, 30, 40]
print(ma_premiere_liste) # Affiche : [10, 20, 30, 40]

Voyons quelques exemples concrets pour bien comprendre la flexibilité des listes.

• Listes de nombres entiers :

  notes = [15, 12, 18, 9, 14]
  print(notes) # Affiche : [15, 12, 18, 9, 14]
  

• Listes de chaînes de caractères :

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

• Listes avec des types de données mélangés (hétérogènes) :

  informations_eleve = ["Alice", 17, 1.65, True] # Nom, âge, taille, est_inscrit
  print(informations_eleve) # Affiche : ['Alice', 17, 1.65, True]
  

• Listes imbriquées : Une liste peut contenir d'autres listes comme éléments. C'est très utile pour représenter des matrices ou des structures complexes.

  matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  print(matrice) # Affiche : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  

  Ici, matrice est une liste qui contient trois autres listes.

Chaque élément dans une liste a une position unique appelée index.

• L'index de début est 0 pour le premier élément.
• Le deuxième élément a l'index 1, le troisième l'index 2, et ainsi de suite.

Python permet aussi d'utiliser des index négatifs :

• L'index -1 fait référence au dernier élément de la liste.
• L'index -2 fait référence à l'avant-dernier élément, etc.

liste_couleurs = ["rouge", "vert", "bleu", "jaune"]
# Indices positifs:   0        1       2       3
# Indices négatifs:  -4       -3      -2      -1

Si vous essayez d'accéder à un index qui n'existe pas (par exemple, un index trop grand ou trop petit), Python lèvera une erreur d'index (IndexError).

Pour accéder à un élément spécifique d'une liste, vous utilisez la syntaxe ma_liste[index].

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

# Accéder au premier élément (index 0)
premier_fruit = fruits[0]
print(f"Le premier fruit est : {premier_fruit}") # Affiche : Le premier fruit est : pomme

# Accéder au troisième élément (index 2)
troisieme_fruit = fruits[2]
print(f"Le troisième fruit est : {troisieme_fruit}") # Affiche : Le troisième fruit est : cerise

# Accéder au dernier élément (index -1)
dernier_fruit = fruits[-1]
print(f"Le dernier fruit est : {dernier_fruit}") # Affiche : Le dernier fruit est : datte

# Accéder à un élément d'une liste imbriquée
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
element_central = matrice[1][1] # Accède à la 2ème liste, puis à son 2ème élément
print(f"L'élément central de la matrice est : {element_central}") # Affiche : L'élément central de la matrice est : 5

Puisque les listes sont mutables, vous pouvez changer la valeur d'un élément existant en utilisant l'index et l'opérateur d'affectation =.

notes = [15, 12, 18, 9, 14]
print(f"Notes initiales : {notes}") # Affiche : Notes initiales : [15, 12, 18, 9, 14]

# Modifier la deuxième note (index 1)
notes[1] = 13
print(f"Notes après modification : {notes}") # Affiche : Notes après modification : [15, 13, 18, 9, 14]

# Modifier le dernier élément
notes[-1] = 16
print(f"Notes après une autre modification : {notes}") # Affiche : Notes après une autre modification : [15, 13, 18, 9, 16]

Il est très courant de vouloir effectuer une action sur chaque élément d'une liste. Pour cela, on utilise des boucles.

1. Boucle for avec in (la plus commune et simple) : Cette méthode parcourt directement les éléments de la liste.

   fruits = ["pomme", "banane", "cerise"]
   for fruit in fruits:
       print(f"J'aime manger des {fruit}s.")
   # Affiche :
   # J'aime manger des pommes.
   # J'aime manger des bananes.
   # J'aime manger des cerises.
   

2. Boucle for avec range(len(liste)) (pour accéder aux indices) : Si vous avez besoin de travailler avec l'index de chaque élément (par exemple, pour modifier l'élément ou accéder à un autre élément en fonction de son index), vous pouvez utiliser range(len(liste)). len(liste) retourne la longueur de la liste.

   notes = [15, 12, 18]
   for i in range(len(notes)):
       print(f"La note à l'index {i} est : {notes[i]}")
       # Si on voulait doubler chaque note :
       # notes[i] = notes[i] * 2
   # Affiche :
   # La note à l'index 0 est : 15
   # La note à l'index 1 est : 12
   # La note à l'index 2 est : 18
   

La fonction intégrée len() (pour "length") vous permet de connaître le nombre d'éléments dans une liste.

courses = ["lait", "pain", "œufs"]
nombre_articles = len(courses)
print(f"Il y a {nombre_articles} articles dans ma liste de courses.") # Affiche : Il y a 3 articles dans ma liste de courses.

liste_vide = []
print(f"La longueur de la liste vide est : {len(liste_vide)}") # Affiche : La longueur de la liste vide est : 0

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

1. Méthode append() : Ajoute un élément à la fin de la liste.

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

2. Méthode insert() : Ajoute un élément à une position spécifique (index). L'élément est inséré avant l'index spécifié, et les éléments existants sont décalés 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
   print(nombres) # Affiche : [5, 10, 20, 30, 40]
   

3. Opérateur + pour la concaténation : Crée une nouvelle liste en combinant deux ou plusieurs listes.

   liste1 = [1, 2]
   liste2 = [3, 4]
   liste_concatenee = liste1 + liste2
   print(liste_concatenee) # Affiche : [1, 2, 3, 4]
   print(f"Liste 1 n'a pas changé : {liste1}") # Affiche : Liste 1 n'a pas changé : [1, 2]
   

   Notez que l'opérateur + ne modifie pas les listes originales, il en crée une nouvelle.

Plusieurs méthodes pour retirer des éléments d'une liste :

1. Instruction del : Supprime un élément par son index.

   planetes = ["Mercure", "Vénus", "Terre", "Mars"]
   del planetes[1] # Supprime "Vénus" (index 1)
   print(planetes) # Affiche : ['Mercure', 'Terre', 'Mars']
   
   del planetes[-1] # Supprime le dernier élément ("Mars")
   print(planetes) # Affiche : ['Mercure', 'Terre']
   

2. Méthode pop() : Supprime et retourne l'élément à un index donné. Si aucun index n'est spécifié, pop() supprime et retourne le dernier élément.

   pile = ["A", "B", "C"]
   element_retire = pile.pop() # Supprime et retourne 'C'
   print(f"Élément retiré : {element_retire}") # Affiche : Élément retiré : C
   print(f"Pile après pop() : {pile}") # Affiche : Pile après pop() : ['A', 'B']
   
   element_specifique = pile.pop(0) # Supprime et retourne 'A' (index 0)
   print(f"Élément retiré : {element_specifique}") # Affiche : Élément retiré : A
   print(f"Pile après pop(0) : {pile}") # Affiche : Pile après pop(0) : ['B']
   

3. Méthode remove() : Supprime la première occurrence d'une valeur spécifiée. Si la valeur n'est pas trouvée, une erreur ValueError est levée.

   couleurs = ["rouge", "vert", "bleu", "vert"]
   couleurs.remove("vert") # Supprime la première occurrence de "vert"
   print(couleurs) # Affiche : ['rouge', 'bleu', 'vert']
   
   # couleurs.remove("jaune") # Ceci provoquerait une erreur ValueError
   

L'opérateur in est utilisé pour vérifier si un élément est présent dans une liste. Il retourne un booléen (True ou False).

etudiants = ["Alice", "Bob", "Charlie"]

if "Bob" in etudiants:
    print("Bob est dans la liste.") # Affiche : Bob est dans la liste.

if "David" not in etudiants: # On peut aussi utiliser 'not in'
    print("David n'est pas dans la liste.") # Affiche : David n'est pas dans la liste.

Le slicing permet de créer une nouvelle liste contenant une séquence d'éléments d'une liste originale. La syntaxe générale est : ma_liste[début:fin:pas].

• début : L'index de départ de la tranche (inclus). Si omis, commence au début de la liste (index 0).
• fin : L'index de fin de la tranche (exclus). L'élément à cet index n'est PAS inclus. Si omis, va jusqu'à la fin de la liste.
• pas : Le pas (ou l'incrément) entre les éléments. Si omis, le pas est de 1.

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

# Tranche simple : éléments de l'index 2 (inclus) à l'index 5 (exclus)
sous_liste_1 = nombres[2:5]
print(sous_liste_1) # Affiche : [2, 3, 4]

L'index de fin est toujours exclus ! C'est une notion clé à retenir pour le slicing.

• Du début à la fin :

  nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  # Du début (omis) à l'index 4 (exclus)
  partie_debut = nombres[:4]
  print(partie_debut) # Affiche : [0, 1, 2, 3]
  
  # De l'index 6 (inclus) à la fin (omis)
  partie_fin = nombres[6:]
  print(partie_fin) # Affiche : [6, 7, 8, 9]
  
  # Copie complète de la liste
  copie_complete = nombres[:]
  print(copie_complete) # Affiche : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  

• Avec un pas :

  nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  # Tous les deux éléments, du début à la fin
  pairs = nombres[::2]
  print(pairs) # Affiche : [0, 2, 4, 6, 8]
  
  # Tous les trois éléments, en commençant à l'index 1
  chaque_trois = nombres[1::3]
  print(chaque_trois) # Affiche : [1, 4, 7]
  
  # Inverser une liste avec un pas négatif
  inverse = nombres[::-1]
  print(inverse) # Affiche : [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  

Lorsque vous assignez une liste à une autre variable comme liste_b = liste_a, vous ne créez PAS une nouvelle liste. Au lieu de cela, liste_b devient une référence à la même liste que liste_a. Toute modification apportée via liste_a affectera liste_b et vice-versa. C'est ce qu'on appelle une copie superficielle par référence.

Pour créer une vraie copie indépendante d'une liste, vous avez deux méthodes principales :

1. Utiliser le slicing [:] : C'est une méthode simple et idiomatique en Python.

   liste_originale = [1, 2, 3]
   copie_par_slice = liste_originale[:]
   print(f"Originale : {liste_originale}")
   print(f"Copie par slice : {copie_par_slice}")
   
   copie_par_slice.append(4)
   print(f"Originale après modif copie : {liste_originale}") # Non modifiée : [1, 2, 3]
   print(f"Copie par slice après modif : {copie_par_slice}") # Modifiée : [1, 2, 3, 4]
   

2. Utiliser la méthode copy() : C'est une méthode plus explicite et souvent préférée pour la lisibilité.

   liste_originale = ["a", "b", "c"]
   copie_par_methode = liste_originale.copy()
   print(f"Originale : {liste_originale}")
   print(f"Copie par méthode : {copie_par_methode}")
   
   copie_par_methode[0] = "z"
   print(f"Originale après modif copie : {liste_originale}") # Non modifiée : ['a', 'b', 'c']
   print(f"Copie par méthode après modif : {copie_par_methode}") # Modifiée : ['z', 'b', 'c']
   

Il existe deux façons principales de trier des listes :

1. Méthode sort() : Trie la liste en place (modifie la liste originale). Elle ne retourne rien.

   nombres = [3, 1, 4, 1, 5, 9, 2]
   nombres.sort() # Trie par défaut en ordre croissant
   print(nombres) # Affiche : [1, 1, 2, 3, 4, 5, 9]
   
   fruits = ["banane", "pomme", "cerise"]
   fruits.sort(reverse=True) # Trie en ordre décroissant
   print(fruits) # Affiche : ['cerise', 'pomme', 'banane']
   

   Attention : sort() modifie la liste directement et ne retourne pas une nouvelle liste.

2. Fonction sorted() : Crée et retourne une nouvelle liste triée, laissant la liste originale inchangée.

   notes = [15, 12, 18, 9]
   notes_triees = sorted(notes)
   print(f"Liste originale : {notes}") # Affiche : Liste originale : [15, 12, 18, 9]
   print(f"Liste triée : {notes_triees}") # Affiche : Liste triée : [9, 12, 15, 18]
   
   # On peut aussi utiliser reverse=True avec sorted()
   notes_triees_decroissant = sorted(notes, reverse=True)
   print(f"Liste triée décroissant : {notes_triees_decroissant}") # Affiche : Liste triée décroissant : [18, 15, 12, 9]
   

Pour inverser l'ordre des éléments d'une liste :

1. Méthode reverse() : Inverse la liste en place (modifie la liste originale).

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

2. Slicing avec un pas négatif [::-1] : Crée une nouvelle liste avec les éléments inversés.

   original = ["A", "B", "C"]
   inversee = original[::-1]
   print(f"Originale : {original}") # Affiche : Originale : ['A', 'B', 'C']
   print(f"Inversée par slicing : {inversee}") # Affiche : Inversée par slicing : ['C', 'B', 'A']
   

La méthode count() permet de connaître le nombre d'apparitions d'un élément spécifique dans une liste.

ma_liste = [1, 2, 2, 3, 1, 2, 4]
nombre_de_1 = ma_liste.count(1)
nombre_de_2 = ma_liste.count(2)
nombre_de_5 = ma_liste.count(5)

print(f"Le nombre 1 apparaît {nombre_de_1} fois.") # Affiche : Le nombre 1 apparaît 2 fois.
print(f"Le nombre 2 apparaît {nombre_de_2} fois.") # Affiche : Le nombre 2 apparaît 3 fois.
print(f"Le nombre 5 apparaît {nombre_de_5} fois.") # Affiche : Le nombre 5 apparaît 0 fois.

La méthode index() retourne l'index de la première occurrence de l'élément spécifié.

couleurs = ["rouge", "vert", "bleu", "vert", "jaune"]
index_vert = couleurs.index("vert")
print(f"Le premier 'vert' est à l'index : {index_vert}") # Affiche : Le premier 'vert' est à l'index : 1

index_jaune = couleurs.index("jaune")
print(f"Le 'jaune' est à l'index : {index_jaune}") # Affiche : Le 'jaune' est à l'index : 4

# Si l'élément n'est pas trouvé, une erreur ValueError est levée.
# index_orange = couleurs.index("orange") # Ceci provoquerait une erreur

Il est judicieux de vérifier la présence de l'élément avec in avant d'utiliser index() pour éviter les erreurs.

if "orange" in couleurs:
    print(f"L'orange est à l'index : {couleurs.index('orange')}")
else:
    print("L'orange n'est pas dans la liste.") # Affiche : L'orange n'est pas dans la liste.