Différence entre les listes del, remove et pop on
>>> a=[1,2,3]
>>> a.remove(2)
>>> a
[1, 3]
>>> a=[1,2,3]
>>> del a[1]
>>> a
[1, 3]
>>> a= [1,2,3]
>>> a.pop(1)
2
>>> a
[1, 3]
>>>
Existe-t-il une différence entre les trois méthodes ci-dessus pour supprimer un élément d'une liste?
Oui, remove supprime le premier correspondance valeur , pas un index spécifique:
>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]
del supprime l'élément à un index spécifique:
>>> a = [3, 2, 2, 1]
>>> del a[1]
>>> a
[3, 2, 1]
et pop supprime l'élément à un index spécifique et le renvoie.
>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]
Leurs modes d'erreur sont également différents:
>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
Utilisez del pour supprimer un élément par index, pop() pour le supprimer par index si vous avez besoin de la valeur renvoyée et remove() pour supprimer un élément par valeur. Ce dernier nécessite une recherche dans la liste et soulève ValueError si aucune valeur de ce type n'apparaît dans la liste.
Lorsque vous supprimez index i d'une liste d'éléments n, les complexités de calcul de ces méthodes sont les suivantes:
del O(n - i)
pop O(n - i)
remove O(n)
Comme personne d'autre ne l'a mentionné, notez que del (contrairement à pop) permet de supprimer une plage d'index en raison du découpage en tranches de liste:
>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]
Cela permet également d'éviter une IndexError si l'index n'est pas dans la liste:
>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]
Déjà bien répondu par les autres. Celui-ci de ma fin :)
Evidemment, pop est le seul à renvoyer la valeur, et remove est le seul à rechercher l’objet, alors que del se limite à une simple suppression.
pop - Prend l'index et renvoie la valeur
remove - Prend de la valeur, supprime la première occurrence et ne renvoie rien
delete - Prend l'index, supprime la valeur de cet index et ne renvoie rien
Les meilleures explications sont ici, mais je vais essayer de mon mieux pour simplifier davantage.
Parmi toutes ces méthodes, reverse & pop sont postfix alors que delete est prefix .
remove (): Utilisé pour supprimer la première occurrence de element
remove(i) => première occurrence de i value
>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2) # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]
pop (): Utilisé pour supprimer un élément si:
non spécifié
pop() => depuis la fin de la liste
>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]
spécifié
pop(index) => of index
>>>a.pop(2)
>>>a
[0, 3, 1, 4, 6, 5]
AVERTISSEMENT: méthode dangereuse à venir
delete () : C'est une méthode de préfixe.
Gardez un œil sur deux syntaxes différentes pour la même méthode: [] et (). Il possède le pouvoir de:
1. Supprimer l'index
del a[index] => utilisé pour supprimer l'index et sa valeur associée comme pop.
>>>del a[1]
>>>a
[0, 1, 4, 6, 5]
2. Supprimer les valeurs de la plage [index 1: index N]
del a[0:3] => plusieurs valeurs dans la plage
>>>del a[0:3]
>>>a
[6, 5]
3.Last mais pas liste, pour supprimer la liste entière en un seul coup
del (a) => comme dit ci-dessus.
>>>del (a)
>>>a
J'espère que cela clarifie la confusion éventuelle.
Toute opération/fonction sur différentes structures de données est définie pour des actions particulières. Dans votre cas, c’est-à-dire supprimer un élément, supprimer, Pop et supprimer. (Si vous considérez des ensembles, ajoutez une autre opération - rejetez) Un autre cas déroutant est lors de l'ajout. Insérer/ajouter. Pour démonstration, implémentons deque. deque est une structure de données linéaire hybride, dans laquelle vous pouvez ajouter/supprimer des éléments aux deux extrémités (arrière et avant).
class Deque(object):
def __init__(self):
self.items=[]
def addFront(self,item):
return self.items.insert(0,item)
def addRear(self,item):
return self.items.append(item)
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
def returnAll(self):
return self.items[:]
Ici, voir les opérations:
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
Les opérations doivent renvoyer quelque chose. Donc, pop - Avec et sans index. Si je ne veux pas renvoyer la valeur: Del self.items [0]
Supprimer par valeur et non index:
retirer :
list_ez=[1,2,3,4,5,6,7,8] for i in list_ez: if i%2==0: list_ez.remove(i) print list_ez
Retours [1,3,5,7]
considérons le cas des ensembles.
set_ez=set_ez=set(range(10))
set_ez.remove(11)
# Gives Key Value Error.
##KeyError: 11
set_ez.discard(11)
# Does Not return any errors.
Tandis que pop et delete les deux prennent des index pour supprimer un élément comme indiqué dans les commentaires ci-dessus. Une différence clé est la complexité du temps pour eux. La complexité temporelle de pop () sans index est O(1), mais ce n'est pas le cas pour la suppression du dernier élément.
Si votre cas d'utilisation consiste toujours à supprimer le dernier élément, il est toujours préférable d'utiliser pop () plutôt que delete (). Pour plus d'explications sur les complexités temporelles, vous pouvez vous référer à https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
L'opération remove sur une liste se voit attribuer une valeur à supprimer. Il recherche dans la liste un élément avec cette valeur et supprime le premier élément correspondant trouvé. C'est une erreur s'il n'y a pas d'élément correspondant, déclenche un ValueError .
>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[7]
IndexError: list assignment index out of range
L'instruction del peut être utilisée pour supprimer une liste complète. Si vous avez un élément de liste spécifique comme argument de del (par exemple, listname [7] pour référencer spécifiquement le 8ème élément de la liste), il ne fera que supprimer cet élément. Il est même possible de supprimer une "tranche" d'une liste. Il s’agit d’une erreur si l’index est en dehors de la plage, déclenche un IndexError .
>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[4]
IndexError: list assignment index out of range
L’utilisation habituelle de pop est de supprimer le dernier élément d’une liste lorsque vous utilisez la liste comme une pile. Contrairement à del, pop renvoie la valeur extraite de la liste. Vous pouvez éventuellement attribuer une valeur d'index à une pop-up différente de la fin de la liste (par exemple, listname.pop (0) supprimera le premier élément de la liste et renverra ce premier élément en tant que résultat). Vous pouvez utiliser ceci pour que la liste se comporte comme une file d'attente, mais il existe des routines de bibliothèque disponibles qui peuvent fournir des opérations de file d'attente plus performantes que pop (0). Il s’agit d’une erreur si l’index est en dehors de la plage, déclenche un IndexError .
>>> x = [1, 2, 3]
>>> x.pop(2)
3
>>> x
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
x.pop(4)
IndexError: pop index out of range
Voir collections.deque pour plus de détails.