Ce guide pratique vous initiera à l’utilisation des méthodes de listes en Python. Vous apprendrez à ajouter, modifier et supprimer des éléments au sein de ces structures de données fondamentales.
Lorsque vous faites vos premiers pas dans la programmation avec Python, les listes figurent parmi les premières structures de données intégrées que vous rencontrerez. Nous allons explorer les bases des listes Python et examiner diverses méthodes utiles que vous pourrez employer lors de leur manipulation.
C’est parti !
Présentation des listes Python
En Python, une liste est une collection ordonnée d’éléments. Ces éléments peuvent être de types de données identiques ou différents. Vous pouvez parcourir la liste pour accéder aux éléments à l’aide de boucles `for`.
Comme toutes les structures itérables en Python, les listes utilisent l’indexation basée sur zéro et supportent les opérations de « slicing » (tranchage).
Les listes sont des collections mutables. Cela signifie que vous pouvez les modifier directement, en ajoutant, supprimant ou modifiant leurs éléments. Il est également possible de trier les éléments dans un ordre particulier, d’inverser leur ordre et bien d’autres opérations. Les méthodes intégrées aux listes de Python facilitent ces manipulations.
Découvrons à présent quelques-unes de ces méthodes très pratiques.
Méthodes de liste intégrées en Python
Dans cette partie, nous allons étudier quelques méthodes de liste qui vous seront utiles. Nous illustrerons ces méthodes par des exemples concrets.
Nous utiliserons la liste `pgm_langs` ci-dessous, qui est une liste de chaînes de caractères contenant les noms de langages de programmation populaires.
pgm_langs = ['Python','Go','Rust','JavaScript']
Insertion d’éléments avec `insert()`
Il est parfois nécessaire d’insérer un élément à un emplacement spécifique dans une liste. La méthode `insert()` permet cela. Elle prend deux arguments :
- L’index où l’élément doit être inséré.
- L’élément à insérer.
Insérons `’Scala’` à l’index 1 en utilisant `insert()`.
pgm_langs = ['Python','Go','Rust','JavaScript'] pgm_langs.insert(1,'Scala') print(pgm_langs) # Résultat : ['Python', 'Scala', 'Go', 'Rust', 'JavaScript']
Ajout d’un élément à la fin avec `append()`
Pour ajouter un élément à la fin de la liste, vous pouvez utiliser la méthode `append()`.
Ajoutons la chaîne `’Java’` à la fin de la liste avec `append()`.
pgm_langs.append('Java')
print(pgm_langs)
# Résultat : ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java']
Extension de la liste avec `extend()`
Nous avons vu que `append()` permet d’ajouter un seul élément à la fois. Mais que faire si vous souhaitez ajouter plusieurs éléments en une seule opération, par exemple les éléments d’une autre liste ? La méthode `extend()` vous offre une solution efficace.
Ajoutons les éléments de la liste `more_langs` à `pgm_langs` en utilisant `extend()`.
more_langs = ['C++','C#','C'] pgm_langs.extend(more_langs) print(pgm_langs) # Résultat : ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java', 'C++', 'C#', 'C']
Il serait possible de parcourir la liste des éléments à ajouter et d’utiliser `append()` pour chaque élément. Cependant, `extend()` rend le code plus concis.
for lang in more_langs:
pgm_langs.append(lang)
Inversion de l’ordre des éléments avec `reverse()`
Pour inverser l’ordre des éléments dans une liste, vous pouvez utiliser la méthode `reverse()`.
L’exemple ci-dessous montre que la liste `pgm_langs` a été inversée.
pgm_langs.reverse() print(pgm_langs) # Résultat : ['C', 'C#', 'C++', 'Java', 'JavaScript', 'Rust', 'Go', 'Scala', 'Python']
Tri d’une liste avec `sort()`
La méthode `sort()` permet de trier une liste en place. Comme `pgm_langs` est une liste de chaînes de caractères, le tri se fera par ordre alphabétique.
pgm_langs.sort() print(pgm_langs) # Résultat : ['C', 'C#', 'C++', 'Go', 'Java', 'JavaScript', 'Python', 'Rust', 'Scala']
Pour trier la liste par ordre alphabétique inverse, vous pouvez affecter la valeur `True` au paramètre `reverse` de la méthode `sort()`.
pgm_langs.sort(reverse=True) print(pgm_langs) # Résultat : ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
Pour en savoir plus sur le tri des listes Python, veuillez consulter la documentation officielle.
Création d’une copie superficielle avec `copy()`
Il est parfois utile de travailler sur une copie d’une liste sans modifier l’originale. La méthode `copy()` renvoie une copie superficielle d’une liste Python.
Créons une copie superficielle de `pgm_langs` nommée `pgm_langs_copy`. Modifions ensuite le premier élément de `pgm_langs_copy` en `’Haskell’`.
pgm_langs_copy = pgm_langs.copy() pgm_langs_copy[0]='Haskell'
print(pgm_langs_copy) # Résultat : ['Haskell', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
On constate que `pgm_langs` n’a pas été modifiée. En effet, une copie superficielle permet de travailler sur une instance séparée.
print(pgm_langs) # Résultat : ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
Comptage du nombre d’occurrences avec `count()`
Parfois, il est utile de savoir combien de fois un élément apparaît dans une liste. La méthode `count()` vous donne cette information.
Dans la liste `pgm_langs`, chaque élément apparaît une seule fois. Si nous utilisons `count()` pour rechercher le nombre d’occurrences de `’Go’`, le résultat sera 1, ce qui est correct.
print(pgm_langs.count('Go'))
# Résultat : 1
La méthode `count()` peut également servir pour supprimer les doublons d’une liste Python.
Récupération de l’index d’un élément avec `index()`
Pour trouver l’index d’un élément dans une liste Python, vous pouvez utiliser la méthode `index()`. Supposons que nous voulions connaître l’index de `’C#’` dans `pgm_langs`. L’instruction `assert` permet de vérifier que l’élément à l’index 7 est bien `’C#’`.
print(pgm_langs.index('C#'))
# Résultat : 7
assert pgm_langs[7] == 'C#'
Suppression d’un élément par son index avec `pop()`
Examinons maintenant les méthodes permettant de supprimer des éléments dans une liste. La méthode `pop()` supprime et renvoie l’élément situé à un index spécifique. L’exemple précédent nous indique que `’C#’` se trouve à l’index 7.
Lorsque nous appelons `pop()` sur `pgm_langs` avec l’index 7, la méthode renvoie `’C#’` et le supprime de la liste.
print(pgm_langs.pop(7)) # Résultat : 'C#' print(pgm_langs) # Résultat : ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C']
En résumé, `pop()` supprime et retourne l’élément à l’index spécifié. L’index est optionnel. Si vous ne spécifiez pas d’index, `pop()` supprime et renvoie le dernier élément de la liste.
print(pgm_langs.pop()) # Résultat : 'C' print(pgm_langs) # Résultat : ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++']
Suppression d’éléments par leur valeur avec `remove()`
Si vous connaissez l’élément à supprimer, mais pas son index, vous pouvez utiliser `remove()`. Cette méthode prend en argument la valeur de l’élément à supprimer. Supprimons `’Java’` de la liste `pgm_langs` en utilisant `remove()`.
pgm_langs.remove('Java')
print(pgm_langs)
# Résultat : ['Scala', 'Rust', 'Python', 'JavaScript', 'Go', 'C++']
Suppression de tous les éléments avec `clear()`
Comment supprimer tous les éléments d’une liste Python ? Il est possible de parcourir la liste et de supprimer chaque élément avec `remove()` :
for lang in pgm_langs:
pgm_langs.remove(lang)
Mais il existe une méthode plus directe : `clear()`. Cette méthode supprime tous les éléments de la liste, qui devient alors vide.
pgm_langs.clear() print(pgm_langs) # Résultat : []
Récapitulatif des méthodes de liste Python
Voici un résumé des méthodes que nous avons étudiées :
| Méthode | Syntaxe | Description |
| `insert()` | `list1.insert(index, elt)` | Insère `elt` à l’index spécifié dans `list1` |
| `append()` | `list1.append(elt)` | Ajoute `elt` à la fin de `list1` |
| `extend()` | `list1.extend(list2)` | Ajoute les éléments de `list2` à la fin de `list1` |
| `sort()` | `list1.sort()` | Trie la liste en place |
| `reverse()` | `list1.reverse()` | Inverse l’ordre des éléments de `list1` en place |
| `copy()` | `list1.copy()` | Renvoie une copie superficielle de `list1` |
| `count()` | `list1.count(elt)` | Renvoie le nombre d’occurrences de `elt` dans `list1` |
| `index()` | `list1.index(elt)` | Renvoie l’index de la première occurrence de `elt` dans `list1` |
| `pop()` | `list1.pop(index)` | Supprime et renvoie l’élément à l’index spécifié. Si l’index n’est pas spécifié, supprime et renvoie le dernier élément |
| `remove()` | `list1.remove(elt)` | Supprime la première occurrence de `elt` de `list1` |
| `clear()` | `list1.clear()` | Supprime tous les éléments de `list1` |
Conclusion
J’espère que ce tutoriel vous aura aidé à mieux comprendre les méthodes de manipulation des listes en Python. Pour aller plus loin, vous pouvez explorer les tuples Python et les différences entre les listes et les tuples.
Si vous êtes en phase d’apprentissage de Python, cette liste de ressources d’apprentissage pour débutants peut vous être utile.