Manipulation avancée des listes en Python

Manipulation avancée des listes en Python

Les listes sont l’une des structures de données les plus utilisées en Python. Elles offrent une grande flexibilité grâce à de nombreuses méthodes intégrées. Ce cours détaillé vous guidera à travers les opérations les plus courantes et avancées, en s’appuyant sur les questions d’un quiz typique. Vous apprendrez à ajouter, insérer, supprimer, copier et trier des éléments, tout en comprenant les différences entre les méthodes similaires.

1. Ajouter un élément à la fin d’une liste

La méthode .append() ajoute un seul élément à la fin d’une liste existante sans créer de nouvelle liste. Cette opération est O(1) en complexité temporelle, ce qui la rend très efficace.

• Exemple :

  fruits = ["pomme", "banane"]
  fruits.append("cerise")
  print(fruits)  # ['pomme', 'banane', 'cerise']
  

• Contrairement à .extend(), qui ajoute les éléments d’un itérable (liste, tuple, etc.) un par un, .append() ne prend qu’un seul argument.

2. Insérer un élément à une position précise

La méthode .insert(index, valeur) place valeur à la position index et décale les éléments suivants vers la droite.

• Exemple tiré du quiz :

  a = [1, 2, 3]
  a.insert(1, 5)
  print(a)  # [1, 5, 2, 3]
  

• Notez que l’indice commence à 0. Insérer à l’indice 1 place l’élément entre le premier et le deuxième élément.

3. Supprimer des éléments

Python propose plusieurs façons de supprimer des éléments d’une liste :

• del L[indice] : supprime l’élément à l’indice indiqué sans retourner de valeur.
• L.pop([indice]) : retire l’élément et le renvoie. Si aucun indice n’est fourni, le dernier élément est retiré.
• L.remove(valeur) : supprime la première occurrence de valeur dans la liste.

Dans le quiz, la bonne réponse était del L[2] pour supprimer l’élément d’indice 2.

4. Utiliser .remove() plusieurs fois

La méthode .remove() ne supprime que la première occurrence d’une valeur. Ainsi, lorsqu’on l’appelle deux fois de suite, deux occurrences distinctes sont retirées.

• Exemple :

  a = [1, 2, 3, 4, 3]
  a.remove(3)   # supprime le premier 3
  print(a)      # [1, 2, 4, 3]
  a.remove(3)   # supprime le deuxième 3
  print(a)      # [1, 2, 4]
  

• Après deux appels, la liste devient [1, 2, 4, 3] puis [1, 2, 4]. La réponse du quiz était [1, 2, 4, 3] après le premier appel, mais la question demandait l’état après les deux appels successifs, donc la réponse correcte est [1, 2, 4]. (Dans le quiz fourni, la bonne réponse était [1, 2, 4, 3] ; cela montre l’importance de lire attentivement l’énoncé.)

5. Différence entre list.sort() et sorted()

Ces deux fonctions permettent de trier des éléments, mais elles diffèrent sur deux points essentiels :

• list.sort() trie la liste en place et ne renvoie rien (None). Elle modifie directement l’objet original.
• sorted(iterable) crée une nouvelle liste triée et laisse l’original intact.

Exemple :

nums = [3, 1, 2]
sorted_nums = sorted(nums)   # -> [1, 2, 3]
print(nums)                  # [3, 1, 2] (inchangé)
nums.sort()                  # tri in‑place
print(nums)                  # [1, 2, 3]

Choisir la bonne méthode dépend du besoin : conserver la liste d’origine ou économiser de la mémoire.

6. Slicing (tranchage) de listes

Le slicing permet d’extraire une sous‑liste en spécifiant un indice de début, un indice de fin (exclu) et éventuellement un pas.

• Expression animaux[1:-1] : commence à l’indice 1 (le deuxième élément) et s’arrête avant l’indice -1 (le dernier élément).
• Avec animaux = ["girafe", "tigre", "singe", "souris"], le résultat est ["tigre", "singe"].

7. Copier une liste avec le slicing

Le slicing complet a[:] crée une copie superficielle de la liste. Les deux listes sont indépendantes ; modifier l’une n’affecte pas l’autre.

• Exemple du quiz :

  a = [1, 2, 3]
  b = a[:]   # copie
  a[0] = 99
  print(a)  # [99, 2, 3]
  print(b)  # [1, 2, 3]
  

• Cette technique est souvent préférée à list(a) ou copy.copy(a) pour sa simplicité.

8. Utiliser .pop() sans indice

Lorsque .pop() est appelé sans argument, il retire et renvoie le dernier élément de la liste.

• Exemple :

  a = [5, 6, 7]
  val = a.pop()
  print(val)  # 7
  print(a)    # [5, 6]
  

• C’est une façon rapide d’utiliser une liste comme une pile (structure LIFO).

9. Bonnes pratiques et astuces avancées

Voici quelques conseils pour travailler efficacement avec les listes :

• Éviter les copies inutiles : si vous n’avez pas besoin de conserver l’original, utilisez .sort() plutôt que sorted() pour économiser de la mémoire.
• Utiliser les compréhensions de listes pour créer rapidement des listes filtrées ou transformées.

  squares = [x*x for x in range(10)]
  

• Manipuler plusieurs éléments avec le slicing d’affectation :

  nums = [0,1,2,3,4]
  nums[1:4] = [9,9]
  print(nums)  # [0, 9, 9, 4]
  

• Faire attention aux références : une copie superficielle (a[:] ) duplique la structure, mais les objets mutables contenus restent partagés.

  inner = [1]
  outer = [inner]
  copy = outer[:]
  inner.append(2)
  print(outer)  # [[1, 2]]
  print(copy)   # [[1, 2]]
  

10. Résumé des points clés

Pour récapituler, voici les méthodes et concepts abordés :

• .append() : ajoute un élément à la fin.
• .insert() : insère à une position donnée.
• del et .pop() : suppriment des éléments, le second renvoie la valeur.
• .remove() : supprime la première occurrence d’une valeur.
• .sort() vs sorted() : tri in‑place vs création d’une nouvelle liste.
• Slicing (list[start:stop]) pour extraire ou remplacer des sous‑listes.
• Copie superficielle avec list[:] pour éviter les effets de bord.

Maîtriser ces opérations vous permettra de manipuler les listes de façon fluide, d’optimiser votre code et de résoudre rapidement les problèmes courants rencontrés en programmation Python.