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

¿Hay alguna diferencia entre los tres métodos anteriores para eliminar un elemento de una lista?

Sí, removeelimina el primer valor coincidente , no un índice específico:

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

del elimina el elemento en un índice específico:

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

y popelimina el elemento en un índice específico y lo devuelve.

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

Sus modos de error también son diferentes:

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

Use delpara eliminar un elemento por índice, pop()para eliminarlo por índice si necesita el valor devuelto, y remove()para eliminar un elemento por valor. Esto último requiere buscar en la lista, y aumenta ValueErrorsi no se produce dicho valor en la lista.

Al eliminar el índice ide una lista de nelementos, las complejidades computacionales de estos métodos son

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

Como nadie más lo ha mencionado, tenga en cuenta que del(a diferencia de pop) permite la eliminación de un rango de índices debido al corte de la lista:

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

Esto también permite evitar un IndexErrorsi el índice no está en la lista:

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

Ya respondido bastante bien por otros. Este de mi final :)

Evidentemente, popes el único que devuelve el valor, y removees el único que busca el objeto, mientras que se dellimita a una simple eliminación.

pop: toma el índice y devuelve el valor

remove: toma valor, elimina la primera aparición y no devuelve nada

eliminar: toma el índice, elimina el valor en ese índice y no devuelve nada

Muchas de las mejores explicaciones están aquí, pero haré todo lo posible para simplificar más.

Entre todos estos métodos, reverse & pop son postfix mientras que delete es prefix .

remove (): solía eliminar la primera aparición del elemento

remove(i) => primera aparición del valor 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 (): solía eliminar el elemento si:

sin especificar

pop() => desde el final de la lista

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

especificado

pop(index) => de índice

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

ADVERTENCIA: Método peligroso por delante

delete () : es un método de prefijo.

Observe dos sintaxis diferentes para el mismo método: [] y (). Posee poder para:

1.Borrar índice

del a[index] => se utiliza para eliminar el índice y su valor asociado al igual que pop.

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

2. Eliminar valores en el rango [índice 1: índice N]

del a[0:3] => valores múltiples en rango

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

3.Última pero no lista, para borrar toda la lista de una vez

del (a) => como se dijo anteriormente.

>>>del (a)
>>>a

Espero que esto aclare la confusión si hay alguna.

Cualquier operación / función en diferentes estructuras de datos se define para acciones particulares. Aquí en su caso, es decir, eliminar un elemento, eliminar, Pop y eliminar. (Si considera conjuntos, agregue otra operación - descartar) Otro caso confuso es al agregar. Insertar / Anexar. Para la demostración, implementemos deque. deque es una estructura de datos lineal híbrida, donde puede agregar elementos / eliminar elementos de ambos extremos (extremos trasero y frontal)

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

Aquí, vea las operaciones:

def deleteFront(self):

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

Las operaciones tienen que devolver algo. Entonces, pop: con y sin índice. Si no quiero devolver el valor: del self.items [0]

Eliminar por valor no Índice:

• eliminar :

  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

Devoluciones [1,3,5,7]

Consideremos el caso de los conjuntos.

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.

Mientras pop y delete ambos toman índices para eliminar un elemento como se indica en los comentarios anteriores. Una diferencia clave es la complejidad del tiempo para ellos. La complejidad de tiempo para pop () sin índice es O (1) pero no es el mismo caso para la eliminación del último elemento.

Si su caso de uso es siempre eliminar el último elemento, siempre es preferible usar pop () sobre delete (). Para obtener más explicaciones sobre las complejidades del tiempo, puede consultar https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

La operación de eliminación en una lista tiene un valor para eliminar. Busca en la lista para encontrar un elemento con ese valor y elimina el primer elemento coincidente que encuentra. Es un error si no hay ningún elemento coincidente, 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

La declaración del se puede utilizar para eliminar una lista completa. Si tiene un elemento de lista específico como argumento para del (por ejemplo, nombre de lista [7] para hacer referencia específica al octavo elemento de la lista), simplemente eliminará ese elemento. Incluso es posible eliminar un "segmento" de una lista. Es un error si hay un índice fuera de rango, 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

El uso habitual de pop es eliminar el último elemento de una lista a medida que usa la lista como una pila. A diferencia de del, pop devuelve el valor que salió de la lista. Opcionalmente, puede dar un valor de índice a pop y pop que no sea el final de la lista (por ejemplo, listname.pop (0) eliminará el primer elemento de la lista y devolverá ese primer elemento como resultado). Puede usar esto para hacer que la lista se comporte como una cola, pero hay rutinas de biblioteca disponibles que pueden proporcionar operaciones de cola con un mejor rendimiento que pop (0). Es un error si hay un índice fuera de rango, 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

Ver collections.deque para más detalles.

Eliminar básicamente funciona en el valor. Eliminar y hacer estallar el trabajo en el índice

Eliminar básicamente elimina el primer valor coincidente. Eliminar elimina el elemento de un índice específico Pop básicamente toma un índice y devuelve el valor en ese índice. La próxima vez que imprima la lista, el valor no aparece.

También puede usar remove para eliminar un valor por índice.

n = [1, 3, 5]

n.remove(n[1])

n se referiría a [1, 5]