Recherche de site Web

Comment supprimer les éléments des listes de Python


Supprimer des éléments d'une liste Python est une tâche courante que vous pouvez accomplir avec diverses techniques. Que vous ayez besoin de supprimer un élément en fonction de sa position ou de sa valeur, Python est là pour vous. Dans ce didacticiel, vous explorerez différentes approches pour supprimer des éléments d'une liste, notamment l'utilisation de .pop(), de l'instruction del et de .remove(). .

La méthode .remove() vous permet de supprimer la première occurrence d'une valeur spécifiée, tandis que .pop() peut supprimer un élément par son index et le renvoyer. L'instruction del offre un autre moyen de supprimer des éléments par index, et vous pouvez également l'utiliser pour supprimer des tranches d'une liste. L’approche que vous choisirez dépendra de vos besoins spécifiques.

À la fin de ce tutoriel, vous comprendrez que:

  • Pour supprimer un élément d'une liste dans Python, vous pouvez utiliser diverses approches comme .pop() , del , .remove() , et .clear() .
  • Pour supprimer les éléments d'une certaine position dans une liste, vous utilisez la méthode .pop() .
  • Pour supprimer des éléments et des tranches d'une liste en Python, vous utilisez l'instruction del.
  • Vous utilisez la méthode .remove() pour supprimer la première occurrence d'une valeur spécifiée d'une liste.
  • Pour supprimer tous les éléments d'une liste, vous utilisez .clear() .
  • Vous pouvez également supprimer des éléments en double utilisant une boucle , dictionnaire , ou set .

Pour tirer le meilleur parti de ce didacticiel, vous devriez être familier avec les sujets de base Python Liste comme la création de listes, l'ajout d'éléments à une liste et l'accès aux éléments dans une liste.

Comment supprimer les éléments spécifiques d'une liste

Une opération courante que vous effectuez sur une liste Python consiste à supprimer des éléments de liste spécifiques. Vous devrez peut-être supprimer des éléments en fonction de leur position dans la liste ou de leur valeur.

Pour illustrer comment vous pouvez accomplir cette tâche, supposons que vous créiez un site Web pour une bibliothèque publique. Votre application Web permettra aux utilisateurs d'enregistrer une liste de livres qu'ils souhaitent lire. Il devrait également leur permettre de modifier et de supprimer les livres de la liste, ainsi que de trier la liste.

Vous pouvez utiliser une liste Python pour stocker la liste de lecture de l'utilisateur comme une collection de titres de livres. Par exemple, la liste de lecture peut ressembler à ceci:

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]

Maintenant que vous disposez d’une liste de livres, vous disposez de plusieurs manières pour supprimer un livre spécifique de la liste. Une approche consiste à utiliser la méthode .pop().

Suppression d'éléments à l'aide de la méthode .pop()

Parfois, vous devrez peut-être supprimer des éléments à une certaine position dans une liste. Par exemple, dans une application de bibliothèque publique, les utilisateurs peuvent sélectionner les livres à supprimer en cochant les cases dans l'interface utilisateur. Votre application supprimera chaque élément sélectionné en fonction de son index, qui correspond à la position de l'élément dans la liste.

Si vous connaissez l'index de l'élément que vous souhaitez supprimer, vous pouvez utiliser la méthode .pop(). Cette méthode prend l'index de l'élément comme argument facultatif, puis supprime et renvoie l'élément à cet index. Si vous ne transmettez pas d'argument d'index à l'appel de méthode, alors .pop() supprimera et renverra le dernier élément de la liste.

Notez que les listes Python utilisent une indexation de base zéro pour le positionnement, ce qui signifie que le premier élément d'une liste est à l'index 0, le deuxième élément est à l'index 1, et ainsi de suite. Dans cet esprit, voici un exemple de la façon dont vous pouvez utiliser .pop() pour supprimer et afficher le premier élément de votre liste books :

>>> books.pop(0)
'Dragonsbane'

Vous invoquez la méthode .pop() sur la liste books avec un index de 0 , indiquant le premier élément de la liste. Cet appel supprime le premier titre, dragonsbane , de la liste puis le renvoie.

Si vous vérifiez le contenu de votre liste après l'exécution de ce code, vous remarquerez que dragonsbane n'est plus là:

>>> books
['The Hobbit', 'Wonder', 'Jaws']

Ici, vous affichez à nouveau la liste des livres après l'appel .pop(). Vous pouvez voir que votre liste est désormais plus courte d'un élément car .pop() a supprimé le premier titre.

Comme vous l'avez appris plus tôt dans le tutoriel, .pop() supprime un élément et renvoie également sa valeur, que vous pouvez ensuite utiliser pour d'autres opérations. Par exemple, supposons que l'application de bibliothèque permet également aux utilisateurs de stocker une liste distincte de livres qu'ils ont lus. Une fois que l'utilisateur a lu un livre, il peut le supprimer de la liste de livres initiale et transférer le titre à la liste de lecture:

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> read_books = []

>>> read = books.pop(0)
>>> read_books.append(read)

>>> read_books
['Dragonsbane']
>>> books
['The Hobbit', 'Wonder', 'Jaws']

Sur la deuxième ligne de l'exemple, vous créez une nouvelle liste vide appelée read_books pour stocker les noms des livres que l'utilisateur a lus. Ensuite, vous utilisez la méthode .pop() pour supprimer le premier titre de la liste de livres originale et le stocker dans une variable. Ensuite, vous utilisez .append() pour ajouter le titre stocké à la liste read_books.

Lorsque vous inspectez le contenu des deux listes, vous constatez que la liste de lecture inclut désormais le premier titre supprimé et que la liste de livres d'origine ne contient plus le titre.

Si vous appelez la méthode .pop() sur une liste vide, la méthode lèvera une exception IndexError :

>>> books.pop()
'Jaws'
>>> books.pop()
'Wonder'
>>> books.pop()
'The Hobbit'

>>> books.pop()
Traceback (most recent call last):
  ...
IndexError: pop from empty list

Dans cet exemple, vous appelez .pop() sur votre liste à plusieurs reprises, en supprimant chaque titre dans la liste. Votre dernier appel à .pop() entraîne une exception indexerror parce que vous appelez la méthode sur une liste vide.

La méthode .pop() générera également une IndexError si vous l'appelez avec un argument d'index plus grand que la taille de la liste moins un :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> books.pop(50)
Traceback (most recent call last):
  ...
IndexError: pop index out of range

Dans cet extrait de code, vous appelez .pop() sur la liste de livres d'origine, qui ne contient que quatre éléments. Vous avez utilisé la méthode .pop() pour l'élément à l'index 50, mais ceci est hors de portée car la liste n'est pas si grande, il soulève donc un indexerror .

Utiliser un index négatif comme argument de .pop() vous permet de supprimer des éléments de la liste de droite à gauche, plutôt que de commencer par le début de la liste. Par exemple, un index -1 accède au dernier élément de la liste, un index -2 accédera à l'avant-dernier élément, et ainsi de suite. Selon ce modèle, books[-len(books)] est un index négatif qui renvoie le premier élément.

L'exemple suivant montre comment utiliser un index négatif avec .pop() pour supprimer le dernier élément d'une liste : :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> books.pop(-1)
'Jaws'

>>> books
['Dragonsbane', 'The Hobbit', 'Wonder']

Vous appelez .pop() sur la liste en utilisant -1 comme argument. Cet index supprime le titre final, Jaws, de la liste. Lorsque vous vérifiez à nouveau le contenu de la liste, vous pouvez voir que le dernier élément a été supprimé. Vous auriez également pu appeler books.pop() sans argument pour obtenir le même effet.

Suppression des éléments avec l'instruction del

Vous pouvez également supprimer les éléments d'un index spécifique avec l'instruction del . Comme la méthode .pop() , del supprime un élément à la position donnée, mais elle ne renvoie pas la valeur.

Pour illustrer, dites que l'utilisateur de votre application de bibliothèque publique a accidentellement ajouté quelques livres à la liste deux fois. L'exemple suivant montre comment utiliser correctement del pour supprimer les titres de livre en double:

>>> >>> books = [
...     "Dragonsbane",
...     "The Hobbit",
...     "Wonder",
...     "Wonder",
...     "Jaws",
...     "Jaws",
... ]

>>> del books[2]
>>> books
['Dragonsbane', 'The Hobbit', 'Wonder', 'Jaws', 'Jaws']

Dans la ligne en surbrillance, vous écrivez d'abord le mot-clé del, puis le nom de votre variable de liste, suivi de l'index souhaité entre crochets.

Tout comme avec la méthode .pop(), vous pouvez également utiliser des valeurs d'index négatives avec l'instruction del pour supprimer des éléments de la fin d'une liste :

>>> del books[-1]

Vous supprimez le dernier élément de la liste avec l'instruction del , mais il ne renvoie pas la valeur. Si vous devez stocker la valeur supprimée pour une raison quelconque, utilisez à la place la méthode .pop() .

Semblable à la méthode .pop(), vous obtiendrez une exception IndexError si vous tentez d'utiliser del sur une liste avec un index non valide. :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> del books[100]
Traceback (most recent call last):
  ...
IndexError: list assignment index out of range

La liste de livres ne contient que quatre éléments, mais vous essayez d'exécuter del sur la liste à l'aide d'un index de 100 . Cet index est hors de portée car il n'y a pas d'élément en position 100 .

Contrairement à .pop() , vous devez fournir une valeur d'index avec une instruction del . Si vous ne le faites pas, le programme augmentera un syntaxerror :

>>> del books[]
  File "<input>", line 1
    del books[]
              ^
SyntaxError: invalid syntax

Vous exécutez l'instruction del sans index, ce qui se traduit par une exception syntaxerror car l'opérateur d'indexation nécessite un index cible. Cette instruction ne supprime pas le dernier élément de la liste comme appelant .pop() sans argument.

Suppression des éléments par valeur avec la méthode .remove()

Supposons que l'application de liste de livres fournit un champ de texte où les utilisateurs peuvent entrer un titre à supprimer de la liste.

Si vous souhaitez supprimer un élément d'une liste par sa valeur plutôt que par son index, vous pouvez utiliser la méthode .remove() . Il nécessite une seule valeur comme argument et supprime le premier élément de la liste qui correspond à cette valeur:

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> books.remove("The Hobbit")
>>> books
['Dragonsbane', 'Wonder', 'Jaws']

Sur la deuxième ligne de cet exemple, vous appelez .remove() pour supprimer Le Hobbit de la liste des livres. Lorsque vous affichez la liste mise à jour, vous voyez que Le Hobbit a été supprimé avec succès.

Si vous appelez .remove() avec une valeur qui ne figure pas dans la liste, la méthode déclenchera une exception ValueError, comme indiqué dans le code suivant :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> books.remove("The Two Towers")
Traceback (most recent call last):
  ...
ValueError: list.remove(x): x not in list

De plus, contrairement à .pop() , vous ne pouvez pas appeler .remove() sans transmettre une valeur:

>>> books.remove()
Traceback (most recent call last):
  ...
TypeError: list.remove() takes exactly one argument (0 given)

Ici, vous appelez .remove() sans lui passer d'argument. Par conséquent, vous recevez un message TypeError expliquant que la méthode nécessite un argument.

Supprimer une partie d'une liste

Votre utilisateur peut devoir supprimer plusieurs éléments d'une liste à la fois. Dites que votre application de bibliothèque publique affiche un certain nombre d'articles par page, similaire à un service de messagerie ou un site de magasinage, et il permet à l'utilisateur de sélectionner et de supprimer tous les éléments de cette page à la fois.

Si la liste affiche 25 éléments par page, il serait plus rapide pour l'utilisateur de supprimer les 25 éléments ensemble en tant que morceau, plutôt que de cliquer sur et de supprimer chacun individuellement.

Vous pouvez effectuer ce type de suppression avec l'instruction del, que vous avez utilisée précédemment pour supprimer des éléments d'un index spécifique. L'instruction del vous permet également de supprimer des tranches de la liste en même temps, donc au lieu de fournir un seul argument d'index, vous transmettez une position de début inclusive et une position de fin exclusive, séparées par deux points.

L'instruction del supprime ensuite tous les éléments de la liste qui se trouvent dans cette plage d'index. Par exemple, supposons que vous souhaitiez supprimer les trois premiers livres de la liste :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws"]
>>> del books[0:3]
>>> books
['Jaws']

Dans la deuxième ligne, vous invoquez l'instruction del qui supprime la tranche de liste. Ensuite, vous affichez la liste mise à jour, qui montre que les trois premiers éléments ont été supprimés. N'oubliez pas que les valeurs d'index commencent à index 0 et passez à ne pas inclure index 3 . Donc, dans le code, vous avez supprimé les trois premiers titres de la liste.

Vous pouvez également utiliser des valeurs d'index négatives avec del pour supprimer une plage d'éléments de liste, comme indiqué dans l'exemple ci-dessous:

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws", "It"]
>>> del books[-3:-1]
>>> books
['Dragonsbane', 'The Hobbit', 'It']

Dans cet exemple, sur la deuxième ligne, vous supprimez les livres à partir de l'index -3 (l'entrée Wonder ), et jusqu'à, mais sans l'inclure l'élément à l'index -1 ( it ). N'oubliez pas qu'avec des indices négatifs, vous comptez les éléments à l'envers à partir de la fin de la liste. Par exemple, l'instruction del [-3: -1] est équivalente aux livres del [2: 4] dans ce cas.

Effacer tous les éléments d'une liste

Supposons que votre utilisateur souhaite effacer complètement la liste des livres. Vous pouvez supprimer tous les éléments d'une liste en utilisant la méthode .clear(). Voici comment cela fonctionne :

>>> books = ["Dragonsbane", "The Hobbit", "Wonder", "Jaws", "It"]
>>> books.clear()
>>> books
[]

Dans la première ligne, vous appelez la méthode .clear() , qui ne prend aucun argument et supprime tous les éléments de la liste. Vous inspectez ensuite des livres dans le shell Python après l'opération .clear() , ce qui confirme que la liste est désormais vide.

Supprimer les doublons avec une boucle

Supposons que vous travaillez sur une application qui autorise les entrées en double dans une liste. Par exemple, une application de carnet de contacts peut autoriser plusieurs contacts avec le même numéro de téléphone mais des noms différents. Dans ce cas, vous risquez de rencontrer une liste contenant des numéros de téléphone en double.

Pour supprimer les doublons de la liste, vous pouvez utiliser une combinaison de boucles et de méthodes de liste. Cette approche consiste à itération de la liste et à supprimer chaque instance d'une valeur lorsqu'il y a plus d'une occurrence de cette valeur.

Plus tôt, vous avez vu comment la méthode .remove() supprime uniquement la première instance d'un élément qui correspond à l'argument value. Maintenant, vous allez voir comment l’utiliser en boucle.

Pour plus de simplicité, imaginez que votre application de carnet de contacts soit utilisée dans un pays avec des numéros de téléphone courts comprenant un code de pays initial à deux chiffres. Supposons également que l’ordre des nombres dans la liste soit important. Votre liste de contacts pourrait ressembler à ceci :

>>> phone_numbers = ["54123", "54123", "54456", "54789", "54789", "54123"]

Tout d'abord, vous devez déterminer combien de fois un nombre apparaît dans la liste. Python fournit la méthode .Count() , qui renvoie le nombre d'occurrences d'une valeur spécifiée dans la liste.

Par exemple, vous pouvez utiliser .count() pour déterminer combien de fois le numéro 54123 apparaît dans la liste de contacts :

>>> phone_numbers.count("54123")
3

L'appel à .Count() renvoie 3 , vous permettant de savoir combien d'instances du numéro de téléphone sont dans la liste. Ensuite, il est temps de créer la boucle pour supprimer les doublons. Vous pouvez créer une boucle qui vérifie pour voir s'il y a plus d'une instance du numéro, puis supprime chaque double jusqu'à ce qu'un seul numéro soit laissé.

En utilisant la méthode .Count() et une boucle, vous pouvez itérer via la liste de contacts, et pour chaque numéro, tant que le nombre est supérieur à un, supprimez l'une des instances:

>>> phone_numbers = ["54123", "54123", "54456", "54789", "54789", "54123"]

>>> for phone_number in phone_numbers[:]:
...     while phone_numbers.count(phone_number) > 1:
...         phone_numbers.remove(phone_number)
...

>>> phone_numbers
['54456', '54789', '54123']

Dans cet exemple, vous voyez la liste des numéros de téléphone avec des doublons. Sur la deuxième ligne, vous configurez une boucle for qui examinera chaque numéro, un à la fois. Tant que le nombre d'un nombre est supérieur à un, vous appelez .remove() sur la liste avec le nombre comme argument. Une fois la boucle terminée, vous aurez une liste sans aucun doublon. Notez que l'ordre dans la liste finale est basé sur la dernière occurrence de chaque élément.

Pour une manière plus concise de supprimer les doublons, vous pouvez également utiliser un dictionnaire. Un dictionnaire est un type de données Python qui représente une collection associative de clés uniques mappées à des valeurs. Puisque les dictionnaires ne peuvent pas contenir de clés en double, vous pouvez utiliser la méthode .fromkeys() pour supprimer les copies de votre liste :

>>> phone_numbers = ["54123", "54123", "54456", "54789", "54789", "54123"]

>>> phone_numbers = list(dict.fromkeys(phone_numbers))

>>> phone_numbers
['54123', '54456', '54789']

Vous utilisez la méthode .fromkeys() pour convertir votre liste en un dictionnaire sans clés en double. Ensuite, vous convertissez le dictionnaire en une liste qui a maintenant supprimé les doublons. Les dictionnaires gardent leur ordre d'insertion, vous êtes donc garanti que les éléments de votre liste dédupliquée sont commandés comme dans l'original. Avec cette méthode, l'ordre final correspond à l'ordre de la première occasion de chaque élément.

Utiliser un ensemble pour supprimer les doublons

Dans l’exemple précédent du carnet de contacts, l’ordre des numéros dans la liste importait. Cependant, si vous souhaitez supprimer les éléments en double dans une liste et que vous ne vous souciez pas de l'ordre des éléments, envisagez d'utiliser un ensemble au lieu d'une liste. Un set est un type de collection intégré à Python qui n'autorise pas les éléments en double.

L'exemple ci-dessous montre comment convertir une liste en un ensemble de numéros de téléphone uniques :

>>> phone_numbers = ["54123", "54123", "54456", "54789", "54789", "54123"]

>>> set(phone_numbers)
{'54123', '54789', '54456'}

Sur la ligne en surbrillance, vous utilisez set() pour convertir la liste en un ensemble, supprimant toutes les entrées en double. Notez que les ensembles sont des collections non ordonnées, ils ne garantissent donc pas que vos éléments de liste seront organisés dans leur commande d'origine. En raison de ce comportement, un ensemble peut ne pas être le bon type de données à utiliser si votre projet nécessite que les éléments restent commandés.

Cependant, les ensembles peuvent être triés dans une liste, ce qui constitue souvent une exigence importante pour les listes de contacts et autres applications similaires. Ils prennent également en charge des tests d'adhésion efficaces, vous permettant de vérifier rapidement si une valeur existe dans la collection.

Conclusion

Vous avez appris diverses techniques pour supprimer les éléments d'une liste Python , que ce soit par position ou valeur. Vous avez exploré des méthodes comme .pop() , .remove() et .clear() . Vous avez également appris l'instruction del . Chacun de ces outils offre une approche unique pour lister la manipulation. De plus, vous avez exploré la suppression des doublons à l'aide d'autres approches, telles que des boucles, des dictionnaires et des ensembles.

L'apprentissage de la manipulation de listes est essentiel pour un développeur Python, car les listes sont un type de données fondamental en Python.

Dans ce didacticiel, vous avez appris à :

  • Supprimez un élément d'une liste par index en utilisant .pop() et del
  • Utilisez la méthode .remove() pour supprimer la première occurrence d'une valeur spécifiée.
  • Supprimer tranches ou portions d'une liste avec l'instruction del
  • Effacer tous les éléments à partir d'une liste à l'aide de la méthode .clear()
  • Retirez des éléments en double avec une boucle , dictionnaire , ou set

Ces compétences vous permettront de manipuler efficacement les listes dans vos projets Python, ce qui rend votre code plus robuste et adaptable à divers besoins de traitement des données.