Comment utiliser la méthode pop() en Python

La méthode pop() est une fonction importante de Python utilisée en manipulation de données pour supprimer et renvoyer un élément spécifié d'une liste ou d'un dictionnaire. Les programmeurs Python apprécient pop() car c'est un moyen particulièrement simple de modifier des structures de données comme les listes et les dictionnaires.

Avant d'aller plus loin, je vous recommande vivement de suivre le cours Introduction to Python de DataCamp pour maîtriser les bases du langage. La feuille de triche Python pour débutants vous aidera également à vous repérer dans la syntaxe et les différentes fonctions de Python.

Réponse rapide : comment utiliser pop() en Python

La méthode pop() s'utilise avec les listes et les dictionnaires pour supprimer des éléments précis et renvoyer leur valeur. Voici un exemple rapide pour chacun. Le premier montre comment supprimer un élément d'une liste avec pop(). Le code suivant affiche 5.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Removes and returns the last element of the list
last_element = my_list.pop()
print(last_element)

L'exemple ci-dessous montre comment utiliser pop() pour supprimer une clé spécifique d'un dictionnaire. Le code suivant affiche 3.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Removes and returns the value associated with the key 'b'
value = my_dict.pop('c')
print(value)

Utiliser pop() avec les listes

La méthode pop() s'utilise avec les listes pour supprimer et renvoyer l'élément spécifié. La syntaxe de pop() avec les listes est la suivante.

list.pop([index])

Avec les listes, pop() peut prendre un paramètre optionnel indiquant l'indice à supprimer. Si aucun paramètre n'est fourni, pop() supprime et renvoie le dernier élément de la liste.

Si, au contraire, vous indiquez explicitement un indice, sachez qu'un IndexError sera levé si l'indice fourni est hors limites. Voyons ci-dessous les différents cas d'usage de pop() avec les listes.

Utiliser pop() pour supprimer par indice

Vous pouvez aussi passer un indice positif ou négatif en argument de pop() pour préciser l'élément à retirer de la liste. En Python, les indices positifs commencent à 0 au début de la liste. Les indices négatifs commencent à -1 à la fin.

Les exemples suivants illustrent trois façons de supprimer des éléments d'une liste. Dans chaque cas, la sortie affichera 5.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Removes and returns the last element of the list
last_element = my_list.pop()
print(last_element)

# Create a list
my_list = [1, 2, 3, 4, 5]

# Remove specific element using negative index
removed_element = my_list.pop(-1) 
print(removed_element)  

# Create  a list
my_list = [1, 2, 3, 4, 5]

# Remove specific element using negative index
removed_element = my_list.pop(4) 
print(removed_element) 

Vous pouvez utiliser pop() dans une boucle pour parcourir la liste et supprimer à chaque fois le dernier élément jusqu'à ce qu'elle soit vide. L'exemple ci-dessous montre comment utiliser pop() dans des boucles. Le code affichera List is now empty.

# Create a list
my_list = [1, 2, 3, 4, 5]

# Create a function to remove items from the list
while my_list:
    element = my_list.pop()
    print(f"Removed element: {element}")
print("List is now empty:", my_list)

Cette technique est utile dans plusieurs situations. Imaginez, par exemple, une liste de tâches à traiter une par une. Avec pop(), vous pouvez retirer chaque tâche une fois terminée et garder la liste centrée sur ce qu'il reste à faire. 

Utiliser pop() avec des listes imbriquées

Vous pouvez employer pop() pour retirer des éléments de listes imbriquées. Cette méthode supprime et renvoie la liste spécifiée au sein de la liste imbriquée. Le code suivant affichera [7, 8, 9].

# Define a nested list
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Pop an element from the outer list
removed_list = nested_list.pop()
print(removed_list)

Si vous souhaitez supprimer un élément précis dans une liste interne, indiquez d'abord l'indice de cette liste imbriquée. Le code ci-dessous affiche 9, qui est le dernier élément de la liste à l'indice 2.

# Define a nested list
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Pop an element from an inner list
removed_element = nested_list[2].pop()
print(removed_element)

Gérer l'erreur "pop() index out of range"

Si vous tentez de retirer un élément avec un indice en dehors des limites de la liste, Python lèvera un IndexError. Pour éviter cette erreur, vérifiez d'abord la longueur de la liste puis fournissez un indice valide. Vous pouvez aussi utiliser un bloc try-except pour intercepter l'erreur. Le code ci-dessous affichera Index out of range dans les deux cas.

# Create a list
my_list = [1, 2, 3]

# Check length before popping
index = 4

# Ensure the index is within the valid range of the list
if 0 <= index < len(my_list):
    # Removes and returns the element at the specified index
    element = my_list.pop(index)  
    print(f"Popped element: {element}")
else:
    print("Index out of range")

# Create a list
my_list = [1, 2, 3]

# Using try-except block to handle out-of-range index
try:
    # Attempt to remove and return the element at index 5
    element = my_list.pop(5)
except IndexError:
    # Catches the IndexError if the index is out of range
    print("Index out of range")

Utiliser pop() avec les dictionnaires

La méthode pop() s'utilise avec les dictionnaires pour supprimer une clé donnée et renvoyer sa valeur. La syntaxe de pop() avec les dictionnaires est la suivante.

dict.pop(key[, default])

On voit que pop(), utilisé avec un dictionnaire, exige une clé en paramètre. pop() renvoie la valeur associée à la clé indiquée et supprime la paire clé-valeur du dictionnaire. 

Vous pouvez également fournir une valeur par défaut à renvoyer si la clé n'existe pas. Si la clé n'est pas trouvée et qu'aucune valeur par défaut n'est fournie, un KeyError est levé. Si une valeur par défaut est fournie, c'est elle qui est renvoyée.

Valeur par défaut dans un dictionnaire Python

Avec les dictionnaires, vous pouvez fournir une valeur par défaut à renvoyer si la clé est absente. Cette approche permet généralement d'éviter le KeyError. Le code ci-dessous affiche Not Found puisque la clé d n'est pas présente.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Remove a specific key and provide default value
value = my_dict.pop('d', 'Not Found')

# Prints the returned value
print(value)

Utiliser pop() avec des dictionnaires imbriqués

Comme avec les listes, vous pouvez utiliser pop() pour retirer des éléments dans des dictionnaires imbriqués, c'est-à-dire des dictionnaires à l'intérieur d'autres dictionnaires. Le code suivant affichera {'x': 7, 'y': 8, 'z': 9}.

# Define a nested dictionary
nested_dict = {
    'a': {'x': 1, 'y': 2, 'z': 3},
    'b': {'x': 4, 'y': 5, 'z': 6},
    'c': {'x': 7, 'y': 8, 'z': 9}
}

# Pop a key-value pair from the outer dictionary
removed_dict = nested_dict.pop('c')
print(removed_dict)

Vous pouvez aussi retirer une valeur interne d'un dictionnaire spécifique en indiquant sa clé. Le code ci-dessous affiche 2.

# Define a nested dictionary
nested_dict = {
    'a': {'x': 1, 'y': 2, 'z': 3},
    'b': {'x': 4, 'y': 5, 'z': 6},
    'c': {'x': 7, 'y': 8, 'z': 9}
}

# Pop a key-value pair from an inner dictionary
popped_inner_value = nested_dict['a'].pop('y')
print(popped_inner_value)

Gérer le KeyError avec un dictionnaire Python

Une autre façon courante de gérer un KeyError de manière plus souple consiste à utiliser un bloc try-except pour intercepter l'erreur. L'exemple suivant illustre l'usage du try-except avec la méthode pop().

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Create the try-except block to catch the error
try:
    value = my_dict.pop('d')
except KeyError:
    print("Key not found")

Vous pouvez aussi utiliser le mot-clé in pour vérifier qu'une clé existe avant de la supprimer. Le code ci-dessous applique cette méthode et renvoie Key not found.

# Create a dictionary
my_dict = {'a': 1, 'b': 2}

# Check key existence before popping
key = 'c'
if key in my_dict:
    value = my_dict.pop(key)
    print(f"Popped value: {value}")
else:
    print("Key not found.")

Considérations de performance

Dans cette section, nous examinons les implications de performance de l'usage de pop() avec les listes et les dictionnaires.

Opérations sur les listes

La complexité temporelle de pop() dans une liste dépend de l'indice de l'élément supprimé. Lorsque vous utilisez pop() sans argument ou avec -1 pour retirer le dernier élément, l'opération est en O(1) car seul le dernier élément est supprimé sans décaler les autres.

Lorsque vous utilisez pop() pour retirer le premier ou tout autre élément, la complexité est O(n) car il faut supprimer l'élément et décaler les autres pour réindexer. Consultez notre tutoriel Analyzing Complexity of Code through Python pour en savoir plus sur la complexité temporelle en Python.

Opérations sur les dictionnaires

La méthode pop() est très efficace avec les dictionnaires grâce à l'implémentation de la table de hachage sous-jacente. Dans ce cas, pop() est généralement une opération en O(1).

Cette complexité vient du fait que le dictionnaire stocke ses clés dans une table de hachage et que les insertions, suppressions et recherches y sont très rapides. Notez aussi que vous devez toujours préciser la clé à supprimer dans un dictionnaire lorsque vous utilisez pop(). Consultez notre tutoriel A Guide to Python Hashmaps pour en savoir plus sur les tables de hachage.

Alternatives à la méthode pop() de Python

Même si pop() est efficace pour supprimer des éléments des listes et des dictionnaires, il existe des alternatives.

Utiliser le mot-clé del

Le mot-clé del permet de supprimer un élément d'une liste en indiquant son indice. Il peut aussi supprimer des paires clé-valeur d'un dictionnaire.  Notez que, contrairement à pop(), del ne renvoie pas l'élément supprimé. 

Les exemples ci-dessous montrent comment utiliser del pour retirer un élément d'une liste et d'un dictionnaire. Après suppression de l'élément à l'indice 2, le code affiche la nouvelle liste [1, 2, 4, 5].

# Initialize a list with integers from 1 to 5
my_list = [1, 2, 3, 4, 5]

# Remove item at index 2
del my_list[2]
print(my_list)

Le code suivant affichera {'a': 1, 'c': 3}.

# Create a dictionary
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Remove the key 'b' and its associated value from the dictionary
del my_dict['b']
print(my_dict)

Utiliser la méthode remove()

La méthode remove() s'applique uniquement aux listes lorsque vous voulez supprimer un élément par sa valeur exacte plutôt que par son indice. Si l'élément apparaît plusieurs fois, seule la première occurrence est supprimée. Le code ci-dessous affiche [1, 3, 4, 5].

# Initialize a list with integers from 1 to 5
my_list = [1, 2, 3, 4, 5]

# Remove the element with the value 2 from the list
my_list.remove(2)
print(my_list)

Conclusion

La méthode pop() est une fonctionnalité à la fois simple et polyvalente de Python pour supprimer des éléments de listes et de dictionnaires, avec de nombreuses applications pratiques en programmation. Elle est particulièrement utile avec les listes et les dictionnaires, car elle renvoie l'élément supprimé — un comportement souvent recherché.

En tant qu'analyste de données, je vous recommande les parcours de compétences Python Fundamentals et Python Programming de DataCamp pour développer vos compétences Python en analyse de données. Consultez également le parcours carrière Data Analyst with Python pour continuer à construire des compétences pratiques et utiles sur le marché.