Utilize del Para remover um elemento por índice, pop() para o remover por índice se necessitar do valor devolvido, e remove() Para remover um elemento por valor. Este último requer a pesquisa da lista, e aumenta ValueError Se não ocorrer tal valor na lista.

Ao apagar o índice i de uma lista de n elementos, as complexidades computacionais destes métodos são

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

Uma vez que mais ninguém o mencionou, note que del (ao contrário de pop) permite a remoção de uma gama de índices por causa de corte de listas:

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

Isto também permite evitar um IndexError se 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 lado:

Evidentemente, pop é o único que devolve o valor, e remove é o único que procura o objecto, enquanto del limita-se a uma simples eliminação.

O índice Pop-Takes e devolve o valor

Remove-Takes valor, remove a primeira ocorrência e não devolve nada

Delete-Takes index, remove o valor desse index e não devolve nada

Enquanto pop e delete ambos os índices take 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 a exclusão do último elemento.

Se o seu caso de uso é sempre para apagar o último elemento, é sempre preferível usar pop() sobre delete(). Para mais explicações sobre complexidades de tempo, você pode se referir a https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

Qualquer operação/função em diferentes estruturas de dados é definida para acções específicas. Aqui no seu caso, isto é, remover um elemento, excluir, Pop e remover. (Se você considerar conjuntos, adicione outra operação-descartar) Outro caso confuso é adicionar. Inserir / Adicionar. Para a demonstração, vamos implementar deque. deque é uma estrutura de dados linear híbrida, onde você pode adicionar elementos / remover elementos de ambas as extremidades.(Extremidades traseira e dianteira)

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

def deleteFront(self):

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

Apagar por valor não Índice:

• Remover:

  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
  

Devolve [1, 3, 5, 7]

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.

A operação remover numa lista é dado um valor a remover. Ele procura na lista para encontrar um item com esse valor e apaga o primeiro item correspondente que encontra. É um erro se não houver nenhum item correspondente, aumenta um valor Error .

>>> 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 apagar uma lista inteira. Se você tem um item de lista específica como seu argumento para del (por exemplo, listname[7] para especificamente referenciar o oitavo item da lista), ele apenas irá excluir esse item. É mesmo possível excluir uma "fatia" de uma lista. É um erro se existir um índice fora do intervalo, aumenta 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

A utilização habitual de pop é apagar o último item de uma lista à medida que usa a lista como pilha. Ao contrário do del, o pop devolve o valor que saiu da lista. Você pode, opcionalmente, dar um valor de índice para pop e pop de outro que não o fim da lista (p.ex. listname.o pop (0) irá apagar o primeiro item da lista e devolver esse primeiro item como seu resultado). Você pode usar isso para fazer a lista se comportar como uma fila, mas existem rotinas de bibliotecas disponíveis que podem fornecer operações de fila com melhor desempenho do que pop(0) faz. É um erro se existir um índice fora do intervalo, aumenta 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

Ver colecções.deque para mais detalhes.

Entre todos estes métodos, o reverso & pop São o postfix enquanto o delete é o prefixo .

Remover (): foi 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 (): {[17] } ele usou para remover o elemento se:

não especificado

pop() => a partir do final de list

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

especificado

pop(index) => do Índice

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

Aviso: Método Perigoso à frente

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

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

1.Apagar o índice

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

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

2.Apagar os valores no intervalo [índice 1: índice n]

del a[0:3] => múltiplo valores no intervalo

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

3.Por último, mas não a lista, para apagar a lista inteira numa única fotografia

del (a) => Como disse acima.

>>>del (a)
>>>a

Também pode usar o remove para remover um valor por índice.

n = [1, 3, 5]

n.remove(n[1])

N referiria então a [1, 5]