>>> 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 alguma diferença entre os três métodos acima para remover um elemento de uma lista?

Sim, removeremove o primeiro valor correspondente , não um índice específico:

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

del remove o item em um índice específico:

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

e popremove o item em um índice específico e o retorna.

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

Seus modos de erro também são 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 remover um elemento por índice, pop()para removê-lo por índice, se você precisar do valor retornado, e remove()para excluir um elemento por valor. O último requer pesquisa na lista e aumenta ValueErrorse esse valor não ocorrer na lista.

Ao excluir o índice ide uma lista de nelementos, as complexidades computacionais desses métodos são

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

Como ninguém mais o mencionou, observe que del(ao contrário pop) permite a remoção de um intervalo de índices devido ao fatiamento da lista:

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

Isso também permite evitar um IndexErrorse o índice não estiver na lista:

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

Já respondeu muito bem por outros. Este do meu fim :)

Evidentemente, popé o único que retorna o valor e removeé o único que pesquisa o objeto, enquanto se dellimita a uma simples exclusão.

pop - Pega índice e retorna valor

remove - Pega valor, remove a primeira ocorrência e não retorna nada

delete - pega o índice, remove o valor nesse índice e não retorna nada

Muitas das melhores explicações estão aqui, mas tentarei o meu melhor para simplificar mais.

Entre todos esses métodos, reverse e pop são postfix, enquanto delete é prefixo .

remove (): usado para remover a primeira ocorrência do elemento

remove(i) => primeira ocorrência do 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 (): usado para remover o elemento se:

não especificado

pop() => do fim da lista

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

Especificadas

pop(index) => do índice

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

AVISO: Método perigoso adiante

delete () : é um método de prefixo.

Fique de olho em duas sintaxes diferentes para o mesmo método: [] e (). Possui poder para:

1. índice de exclusão

del a[index] => usado para excluir o índice e seu valor associado, assim como pop.

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

2.Excluir valores no intervalo [índice 1: índice N]

del a[0:3] => vários valores no intervalo

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

3.Última, mas não a lista, para excluir a lista inteira de uma só vez

del (a) => como dito acima.

>>>del (a)
>>>a

Espero que isso esclareça a confusão, se houver.

Qualquer operação / função em diferentes estruturas de dados é definida para ações específicas. Aqui no seu caso, ou seja, removendo um elemento, exclua, pop e remova. (Se você considerar conjuntos, adicione outra operação - descartar). Outro caso confuso é ao adicionar. Inserir / Anexar. Para demonstração, vamos implementar deque. deque é uma estrutura de dados linear híbrida, na qual é possível adicionar elementos / remover elementos de ambas as extremidades.

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

Aqui, veja as operações:

def deleteFront(self):

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

As operações precisam retornar algo. Então, pop - com e sem um índice. Se não quiser retornar o valor: del self.items [0]

Excluir por valor, não índice:

• retirar :

  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

Retornos [1,3,5,7]

vamos considerar o caso dos 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.

Enquanto pop e delete ambos assumem índices para remover um elemento como indicado nos comentários acima. Uma diferença fundamental é a complexidade do tempo para eles. A complexidade de tempo para pop () sem índice é O (1), mas não é o mesmo caso para exclusão do último elemento.

Se o seu caso de uso é sempre para excluir o último elemento, é sempre preferível usar pop () em vez de delete (). Para obter mais explicações sobre a complexidade do tempo, consulte https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

A operação de remoção em uma lista recebe um valor para remover. Ele pesquisa na lista para encontrar um item com esse valor e exclui o primeiro item correspondente encontrado. É um erro se não houver item correspondente, gera um 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

A instrução del pode ser usada para excluir uma lista inteira. Se você tem um item de lista específico como argumento a ser deletado (por exemplo, nome da lista [7] para referenciar especificamente o 8º item da lista), ele simplesmente exclui esse item. É até possível excluir uma "fatia" de uma lista. É um erro se o índice fora do intervalo gerar um 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

O uso usual do pop é excluir o último item de uma lista à medida que você usa a lista como uma pilha. Ao contrário de del, pop retorna o valor que saiu da lista. Opcionalmente, você pode atribuir um valor de índice para pop e pop a partir do final da lista (por exemplo, listname.pop (0) excluirá o primeiro item da lista e retornará esse primeiro item como resultado). Você pode usar isso para fazer a lista se comportar como uma fila, mas existem rotinas de biblioteca disponíveis que podem fornecer operações de fila com melhor desempenho do que o pop (0). É um erro se o índice fora do intervalo gerar um 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

Veja collections.deque para mais detalhes.

Remover basicamente funciona no valor. Excluir e exibir trabalho no índice

Remover basicamente remove o primeiro valor correspondente. Excluir exclui o item de um índice específico. O Pop basicamente pega um índice e retorna o valor nesse índice. Na próxima vez que você imprimir a lista, o valor não aparecerá.

Você também pode usar remove para remover um valor pelo índice também.

n = [1, 3, 5]

n.remove(n[1])

n se referiria a [1, 5]