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

Gibt es einen Unterschied zwischen den oben genannten drei Methoden zum Entfernen eines Elements aus einer Liste?

Ja, removeentfernt den ersten übereinstimmenden Wert , keinen bestimmten Index:

>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]

del Entfernt das Element an einem bestimmten Index:

>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]

und popentfernt das Element an einem bestimmten Index und gibt es zurück.

>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]

Ihre Fehlermodi sind ebenfalls unterschiedlich:

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

Verwenden Sie deldiese Option , um ein Element nach Index pop()zu entfernen, um es nach Index zu entfernen, wenn Sie den zurückgegebenen Wert benötigen, und remove()um ein Element nach Wert zu löschen. Letzteres erfordert das Durchsuchen der Liste und wird ausgelöst, ValueErrorwenn in der Liste kein solcher Wert vorkommt.

Beim Löschen eines Index iaus einer Liste von nElementen sind die rechnerischen Komplexitäten dieser Methoden

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

Da dies von niemand anderem erwähnt wurde, ist zu beachten, dass del(im Gegensatz zu pop) das Entfernen einer Reihe von Indizes aufgrund von Listenaufteilung möglich ist:

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

Dies ermöglicht auch die Vermeidung von a, IndexErrorwenn der Index nicht in der Liste enthalten ist:

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

Schon ganz gut von anderen beantwortet. Dieser von meinem Ende :)

Offensichtlich popist es das einzige, das den Wert zurückgibt, und es removeist das einzige, das das Objekt durchsucht, während es delsich auf ein einfaches Löschen beschränkt.

Viele beste Erklärungen sind hier, aber ich werde mein Bestes geben, um mehr zu vereinfachen.

Unter all diesen Methoden sind Reverse & Pop Postfix, während Delete das Präfix ist .

remove (): Dient zum Entfernen des ersten Auftretens eines Elements

remove(i) => erstes Auftreten des i-Wertes

>>> 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 (): Dient zum Entfernen von Elementen, wenn:

nicht spezifiziert

pop() => vom Ende der Liste

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

spezifizierten

pop(index) => des Index

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

WARNUNG: Gefährliche Methode voraus

delete () : Dies ist eine Präfixmethode.

Behalten Sie zwei verschiedene Syntax für dieselbe Methode im Auge: [] und (). Es besitzt die Macht:

1. Index löschen

del a[index] => wird verwendet, um den Index und den zugehörigen Wert genau wie pop zu löschen.

>>>del a[1]
>>>a
[0, 1, 4, 6, 5]

2. Werte im Bereich löschen [Index 1: Index N]

del a[0:3] => mehrere Werte im Bereich

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

3.Letzte, aber keine Liste, um die gesamte Liste auf einmal zu löschen

del (a) => wie oben gesagt.

>>>del (a)
>>>a

Hoffe, dies klärt die Verwirrung, wenn überhaupt.

pop - Nimmt den Index und gibt den Wert zurück

remove - Nimmt den Wert an, entfernt das erste Vorkommen und gibt nichts zurück

delete - Nimmt den Index, entfernt den Wert an diesem Index und gibt nichts zurück

Jede Operation / Funktion für verschiedene Datenstrukturen ist für bestimmte Aktionen definiert. Hier in Ihrem Fall dh ein Element entfernen, löschen, Pop und entfernen. (Wenn Sie Sätze in Betracht ziehen, fügen Sie eine weitere Operation hinzu - verwerfen Sie) Ein anderer verwirrender Fall ist beim Hinzufügen. Einfügen / Anhängen. Lassen Sie uns zur Demonstration deque implementieren. deque ist eine hybride lineare Datenstruktur, in der Sie Elemente an beiden Enden hinzufügen / entfernen können. (Hinteres und vorderes Ende)

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

Hier sehen Sie die Operationen:

def deleteFront(self):

    return self.items.pop(0)
def deleteRear(self):
    return self.items.pop()

Operationen müssen etwas zurückgeben. Also, Pop - Mit und ohne Index. Wenn ich den Wert nicht zurückgeben möchte: del self.items [0]

Löschen nach Wert nicht Index:

• entfernen :

  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

Rückgabe [1,3,5,7]

Betrachten wir den Fall von Mengen.

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.

Während Pop und Delete beide Indizes verwenden, um ein Element zu entfernen, wie in den obigen Kommentaren angegeben. Ein wesentlicher Unterschied ist die zeitliche Komplexität für sie. Die zeitliche Komplexität für pop () ohne Index ist O (1), ist jedoch nicht der gleiche Fall für das Löschen des letzten Elements.

Wenn Ihr Anwendungsfall immer darin besteht, das letzte Element zu löschen, ist es immer vorzuziehen, pop () gegenüber delete () zu verwenden. Weitere Erläuterungen zu Zeitkomplexitäten finden Sie unter https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

Der Entfernungsvorgang für eine Liste erhält einen zu entfernenden Wert. Es durchsucht die Liste nach einem Element mit diesem Wert und löscht das erste übereinstimmende Element, das es findet. Es ist ein Fehler, wenn kein übereinstimmendes Element vorhanden ist, und löst einen ValueError aus .

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

Mit der del- Anweisung kann eine gesamte Liste gelöscht werden. Wenn Sie ein bestimmtes Listenelement als Argument für del haben (z. B. Listenname [7], um speziell auf das 8. Element in der Liste zu verweisen), wird dieses Element einfach gelöscht. Es ist sogar möglich, ein "Slice" aus einer Liste zu löschen. Es ist ein Fehler, wenn der Index außerhalb des Bereichs liegt und einen IndexError auslöst .

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

Die übliche Verwendung von Pop besteht darin, das letzte Element aus einer Liste zu löschen, während Sie die Liste als Stapel verwenden. Im Gegensatz zu del gibt pop den Wert zurück, den es aus der Liste entfernt hat. Sie können Pop und Pop optional einen anderen Indexwert als das Ende der Liste zuweisen (z. B. listname.pop (0) löscht das erste Element aus der Liste und gibt das erste Element als Ergebnis zurück). Sie können dies verwenden, damit sich die Liste wie eine Warteschlange verhält. Es stehen jedoch Bibliotheksroutinen zur Verfügung, mit denen Warteschlangenoperationen eine bessere Leistung erzielen können als pop (0). Es ist ein Fehler, wenn der Index außerhalb des Bereichs liegt und einen IndexError auslöst .

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

Weitere Informationen finden Sie unter collection.deque .

Entfernen funktioniert grundsätzlich am Wert. Löschen und Pop-Arbeiten am Index

Entfernen entfernt im Grunde den ersten übereinstimmenden Wert. Löschen löscht das Element aus einem bestimmten Index. Pop nimmt grundsätzlich einen Index und gibt den Wert an diesem Index zurück. Wenn Sie das nächste Mal die Liste drucken, wird der Wert nicht angezeigt.

Sie können auch entfernen verwenden, um einen Wert auch nach Index zu entfernen.

n = [1, 3, 5]

n.remove(n[1])

n würde sich dann auf [1, 5] beziehen