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

C'è qualche differenza tra i tre metodi precedenti per rimuovere un elemento da un elenco?

Sì, removerimuove il primo valore corrispondente , non un indice specifico:

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

del rimuove l'elemento in un indice specifico:

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

e poprimuove l'elemento in un indice specifico e lo restituisce.

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

Anche le loro modalità di errore sono diverse:

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

Utilizzare delper rimuovere un elemento per indice, pop()per rimuoverlo per indice se è necessario il valore restituito e remove()per eliminare un elemento in base al valore. Quest'ultimo richiede la ricerca nell'elenco e genera ValueErrorse tale valore non si verifica nell'elenco.

Quando si elimina l'indice ida un elenco di nelementi, le complessità computazionali di questi metodi sono

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

Poiché nessun altro lo ha menzionato, si noti che del(a differenza pop) consente la rimozione di un intervallo di indici a causa della suddivisione in elenchi:

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

Ciò consente anche di evitare un IndexErrorse l'indice non è nell'elenco:

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

Già risposto abbastanza bene da altri. Questo dalla mia fine :)

Evidentemente, popè l'unico che restituisce il valore ed removeè l'unico che cerca l'oggetto, mentre si dellimita a una semplice eliminazione.

pop: prende l'indice e restituisce valore

rimuovi - Prende valore, rimuove la prima occorrenza e non restituisce nulla

elimina: prende l'indice, rimuove il valore in quell'indice e non restituisce nulla

Molte spiegazioni migliori sono qui, ma farò del mio meglio per semplificare di più.

Tra tutti questi metodi, reverse & pop sono postfix mentre delete è prefisso .

remove (): utilizzato per rimuovere la prima occorrenza dell'elemento

remove(i) => prima occorrenza del valore 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 (): utilizzato per rimuovere l'elemento se:

imprecisato

pop() => dalla fine dell'elenco

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

specificato

pop(index) => dell'indice

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

ATTENZIONE: Metodo pericoloso avanti

delete () : è un metodo prefisso.

Tieni d'occhio due diverse sintassi per lo stesso metodo: [] e (). Possiede il potere di:

1. Elimina indice

del a[index] => utilizzato per eliminare l'indice e il suo valore associato proprio come pop.

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

2. Elimina valori nell'intervallo [indice 1: indice N]

del a[0:3] => valori multipli nell'intervallo

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

3.Ultimo ma non elenco, per eliminare l'intero elenco in un colpo solo

del (a) => come detto sopra.

>>>del (a)
>>>a

Spero che questo chiarisca l'eventuale confusione.

Qualsiasi operazione / funzione su diverse strutture dati è definita per azioni particolari. Qui nel tuo caso, cioè rimuovere un elemento, eliminare, Pop e rimuovere. (Se si considerano i set, aggiungere un'altra operazione - scartare) Altro caso di confusione è durante l'aggiunta. Inserisci / Aggiungi. Per dimostrazione, implementiamo deque. deque è una struttura di dati lineare ibrida, in cui è possibile aggiungere elementi / rimuovere elementi da entrambe le estremità (estremità posteriore e anteriore)

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

Qui, vedi le operazioni:

def deleteFront(self):

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

Le operazioni devono restituire qualcosa. Quindi, pop - Con e senza un indice. Se non voglio restituire il valore: del self.items [0]

Elimina per valore non indice:

• rimuovere:

  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

Resi [1,3,5,7]

consideriamo il caso degli insiemi.

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.

Mentre pop ed delete entrambi prendono gli indici per rimuovere un elemento come indicato nei commenti precedenti. Una differenza fondamentale è la complessità temporale per loro. La complessità temporale per pop () senza indice è O (1) ma non è lo stesso caso per la cancellazione dell'ultimo elemento.

Se il tuo caso d'uso è sempre quello di eliminare l'ultimo elemento, è sempre preferibile usare pop () rispetto a delete (). Per ulteriori spiegazioni sulle complessità temporali, è possibile fare riferimento a https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

All'operazione di rimozione in un elenco viene assegnato un valore da rimuovere. Cerca nell'elenco per trovare un elemento con quel valore ed elimina il primo elemento corrispondente che trova. È un errore se non ci sono elementi corrispondenti, genera 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' istruzione del può essere utilizzata per eliminare un intero elenco. Se hai un elemento dell'elenco specifico come argomento da eliminare (ad es. Nome elenco [7] per fare riferimento in modo specifico all'ottavo elemento nell'elenco), eliminerà semplicemente quell'elemento. È anche possibile eliminare una "fetta" da un elenco. È un errore se l'indice non è compreso nell'intervallo, genera 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

Il solito uso di pop è quello di eliminare l'ultimo elemento da un elenco mentre si utilizza l'elenco come una pila. A differenza di del, pop restituisce il valore che è stato rimosso dall'elenco. Se lo si desidera, è possibile assegnare un valore di indice a pop e pop da una parte diversa dalla fine dell'elenco (ad esempio listname.pop (0) eliminerà il primo elemento dall'elenco e restituirà il primo elemento come risultato). È possibile utilizzare questo per far sì che l'elenco si comporti come una coda, ma sono disponibili routine di libreria che possono fornire alle operazioni delle code prestazioni migliori rispetto a pop (0). È un errore se l'indice non è compreso nell'intervallo, genera 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

Vedi collections.deque per maggiori dettagli.

Rimuovi funziona fondamentalmente sul valore. Elimina e pop il lavoro sull'indice

Rimuovi sostanzialmente rimuove il primo valore corrispondente. Elimina elimina l'elemento da un indice specifico Pop fondamentalmente prende un indice e restituisce il valore in quell'indice. La prossima volta che si stampa l'elenco, il valore non viene visualizzato.

Puoi anche usare Rimuovi per rimuovere anche un valore per indice.

n = [1, 3, 5]

n.remove(n[1])

n farebbe quindi riferimento a [1, 5]