>>> 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]
>>> 

Y a-t-il une différence entre les trois méthodes ci-dessus pour supprimer un élément d'une liste?

Oui, removesupprime la première valeur correspondante , 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 = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]

et popsupprime 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

Permet delde supprimer un élément par index, pop()de le supprimer par index si vous avez besoin de la valeur renvoyée et remove()de supprimer un élément par valeur. Ce dernier nécessite une recherche dans la liste et augmente ValueErrorsi aucune valeur de ce type n'apparaît dans la liste.

Lors de la suppression id'un index d'une liste d' néléments, les complexités de calcul de ces méthodes sont

del     O(n - i)
pop     O(n - i)
remove  O(n)

Étant donné que personne d'autre ne l'a mentionné, notez que del(contrairement à pop) permet la suppression d'une plage d'index en raison du découpage de liste:

>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]

Cela permet également d'éviter un IndexErrorsi 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 d'autres. Celui de ma fin :)

Evidemment, popc'est le seul qui renvoie la valeur, et removec'est le seul qui cherche l'objet, tout en se dellimitant à une simple suppression.

pop - Prend l'indice 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 à cet index et ne renvoie rien

De nombreuses meilleures explications sont ici, mais je ferai de mon mieux pour simplifier davantage.

Parmi toutes ces méthodes, reverse & pop sont des suffixes tandis que delete est un préfixe .

remove (): utilisé pour supprimer la première occurrence de l'élément

remove(i) => première occurrence de la valeur i

>>> 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 l'élément si:

non spécifié

pop() => à partir de la fin de la liste

>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]

spécifié

pop(index) => d'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.Supprimez les valeurs dans la plage [index 1: index N]

del a[0:3] => plusieurs valeurs dans la plage

>>>del a[0:3]
>>>a
[6, 5]

3.Dernière mais pas la liste, pour supprimer toute la liste en une seule fois

del (a) => comme dit ci-dessus.

>>>del (a)
>>>a

J'espère que cela clarifie la confusion, le cas échéant.

Toute opération / fonction sur différentes structures de données est définie pour des actions particulières. Ici, dans votre cas, c'est à dire supprimer un élément, supprimer, Pop et supprimer. (Si vous considérez les ensembles, ajoutez une autre opération - jetez) 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 des éléments / supprimer des éléments aux deux extrémités (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 retourner quelque chose. Alors, pop - Avec et sans index. Si je ne veux pas retourner la valeur: del self.items [0]

Supprimer par valeur et non par 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

Renvoie [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 prennent tous les deux des indices pour supprimer un élément comme indiqué dans les commentaires ci-dessus. Une différence clé est la complexité temporelle pour eux. La complexité temporelle pour pop () sans index est O (1) mais ce n'est pas le même cas pour la suppression du dernier élément.

Si votre cas d'utilisation est toujours de 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 de suppression sur une liste reçoit une valeur à supprimer. Il recherche dans la liste pour trouver un élément avec cette valeur et supprime le premier élément correspondant qu'il trouve. C'est une erreur s'il n'y a pas d'élément correspondant, déclenche une 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 entière. Si vous avez un élément de liste spécifique comme argument à supprimer (par exemple, listname [7] pour référencer spécifiquement le 8ème élément de la liste), il suffit de supprimer cet élément. Il est même possible de supprimer une "tranche" d'une liste. C'est une erreur s'il y a un index hors de portée, déclenche une 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 consiste à supprimer le dernier élément d'une liste lorsque vous utilisez la liste comme une pile. Contrairement à del, pop renvoie la valeur qu'il a extraite de la liste. Vous pouvez éventuellement attribuer une valeur d'index à pop et pop à partir 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 comme résultat). Vous pouvez l'utiliser pour que la liste se comporte comme une file d'attente, mais il existe des routines de bibliothèque qui peuvent fournir des opérations de file d'attente avec de meilleures performances que pop (0). C'est une erreur s'il y a un index hors de portée, déclenche une 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.

Supprimer fonctionne essentiellement sur la valeur. Supprimer et afficher le travail sur l'index

Supprimer supprime essentiellement la première valeur correspondante. Supprimer supprime l'élément d'un index spécifique. Pop prend essentiellement un index et renvoie la valeur à cet index. La prochaine fois que vous imprimerez la liste, la valeur n'apparaîtra pas.

Vous pouvez également utiliser remove pour supprimer également une valeur par index.

n = [1, 3, 5]

n.remove(n[1])

n ferait alors référence à [1, 5]