Como remover um elemento de uma lista por índice


1506

Como faço para remover um elemento de uma lista por índice em Python?

Encontrei o list.removemétodo, mas digamos que quero remover o último elemento, como faço para fazer isso? Parece que a remoção padrão pesquisa na lista, mas não quero que nenhuma pesquisa seja realizada.


10
@smci: A lista Python é baseada em array: para excluir um item no meio, você deve mover todos os itens à direita para remover a lacuna e é por isso que está O(n)em operação no tempo. deque()fornece operações eficientes em ambas as extremidades, mas não fornece O (1) inserções / pesquisas / exclusões no meio.
jfs

@ JFSebastian: implementação cPython, sim, obrigado por me corrigir. Estritamente, a especificação de idioma não especifica como implementar a lista; implementações alternativas podem optar por usar uma lista vinculada.
smci 8/09/15

@smci: nenhuma implementação prática do Python usaria o O(n)acesso ao índice a[i](devido a listas vinculadas). Nota: a implementação baseada em matriz fornece O(1)acesso ao índice.
jfs

@ JFSebastian: é claro. Eu apenas observei que a especificação da linguagem não define isso , é um problema de implementação. (Fiquei surpreso ao descobrir que ele não o fez.)
SMCI

@smci, se você está direcionando isso amplamente, não sei como você pode otimizar alguma coisa.
Nick T

Respostas:


1741

Use dele especifique o índice do elemento que você deseja excluir:

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[-1]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]

Também suporta fatias:

>>> del a[2:4]
>>> a
[0, 1, 4, 5, 6, 7, 8, 9]

Aqui está a seção do tutorial.


53
Obrigado, qual é a diferença entre pop e del?
Joan Venge

37
del está sobrecarregado. Por exemplo del A exclui toda a lista
Brian R. Bondy

34
outro exemplo del a [2: 4] exclui os elementos 2 e 3
Brian R. Bondy

307
pop () retorna o elemento que você deseja remover. del apenas exclui é.

13
Não consigo ver uma prova de "lista vinculada" lá. Veja svn.python.org/projects/python/trunk/Objects/listobject.c como PyList_GetItem()essencialmente retorna ((PyListObject *)op) -> ob_item[i];- o iésimo elemento de uma matriz.
glglgl

649

Você provavelmente quer pop:

a = ['a', 'b', 'c', 'd']
a.pop(1)

# now a is ['a', 'c', 'd']

Por padrão, popsem argumentos, remove o último item:

a = ['a', 'b', 'c', 'd']
a.pop()

# now a is ['a', 'b', 'c']

105
Não se esqueça de pop (-1). Sim, é o padrão, mas eu prefiro que não precise me lembrar de qual pop final usa por padrão.
315/09 S.Lott

282
Discordo. Se você conhece a etimologia do "pop" do programador (é a operação que remove e retorna o topo de uma estrutura de dados da 'pilha'), então, pop()por si só, é muito óbvio, enquanto pop(-1)é potencialmente confuso precisamente porque é redundante.
Coredumperror

a.pop (-1) para remover o último?
Zx1986

14
@ zx1986 a popna maioria das linguagens de programação geralmente remove o último item, como acontece no Python. Portanto, se você especificar -1 ou nada é o mesmo.
Pascal

30
A propósito, pop()retorna qualquer elemento que ele removeu.
Bob Stein

136

Como outros mencionados, pop e del são as maneiras eficientes de remover um item de um determinado índice. No entanto, apenas para fins de conclusão (já que a mesma coisa pode ser feita de várias maneiras no Python):

Usando fatias (isso não remove o item da lista original):

(Além disso, este será o método menos eficiente ao trabalhar com a lista Python, mas isso pode ser útil (mas não eficiente, reitero) ao trabalhar com objetos definidos pelo usuário que não suportam pop, mas definem a __getitem__):

>>> a = [1, 2, 3, 4, 5, 6]
>>> index = 3 # Only positive index

>>> a = a[:index] + a[index+1 :]
# a is now [1, 2, 3, 5, 6]

Nota: Observe que este método não modifica a lista no local como pope del. Em vez disso, ele faz duas cópias das listas (uma desde o início até o índice, mas sem ela ( a[:index]) e uma após o índice até o último elemento ( a[index+1:])) e cria um novo objeto de lista adicionando ambas. Isso é reatribuído à variável da lista ( a). Portanto, o objeto de lista antigo é desreferenciado e, portanto, coletado de lixo (desde que o objeto de lista original não seja referenciado por nenhuma variável que não seja a).

Isso torna esse método muito ineficiente e também pode produzir efeitos colaterais indesejáveis ​​(especialmente quando outras variáveis ​​apontam para o objeto de lista original que permanece inalterado).

Obrigado a @MarkDickinson por apontar isso ...

Esta resposta de estouro de pilha explica o conceito de fatiar.

Observe também que isso funciona apenas com índices positivos.

Ao usar com objetos, o __getitem__método deve ter sido definido e, mais importante, o __add__método deve ter sido definido para retornar um objeto contendo itens de ambos os operandos.

Em essência, isso funciona com qualquer objeto cuja definição de classe seja como:

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Isso funciona com o listqual define __getitem__e __add__métodos.

Comparação das três formas em termos de eficiência:

Suponha que o seguinte seja predefinido:

a = range(10)
index = 3

O del object[index]método:

De longe, o método mais eficiente. Funciona com todos os objetos que definem um __del__método.

A desmontagem é a seguinte:

Código:

def del_method():
    global a
    global index
    del a[index]

Desmontagem:

 10    0 LOAD_GLOBAL     0 (a)
       3 LOAD_GLOBAL     1 (index)
       6 DELETE_SUBSCR   # This is the line that deletes the item
       7 LOAD_CONST      0 (None)
      10 RETURN_VALUE
None

pop método:

É menos eficiente que o método del e é usado quando você precisa obter o item excluído.

Código:

def pop_method():
    global a
    global index
    a.pop(index)

Desmontagem:

 17     0 LOAD_GLOBAL     0 (a)
        3 LOAD_ATTR       1 (pop)
        6 LOAD_GLOBAL     2 (index)
        9 CALL_FUNCTION   1
       12 POP_TOP
       13 LOAD_CONST      0 (None)
       16 RETURN_VALUE

A fatia e o método add.

O menos eficiente.

Código:

def slice_method():
    global a
    global index
    a = a[:index] + a[index+1:]

Desmontagem:

 24     0 LOAD_GLOBAL    0 (a)
        3 LOAD_GLOBAL    1 (index)
        6 SLICE+2
        7 LOAD_GLOBAL    0 (a)
       10 LOAD_GLOBAL    1 (index)
       13 LOAD_CONST     1 (1)
       16 BINARY_ADD
       17 SLICE+1
       18 BINARY_ADD
       19 STORE_GLOBAL   0 (a)
       22 LOAD_CONST     0 (None)
       25 RETURN_VALUE
None

Nota: Nas três desmontagens, ignore as duas últimas linhas que basicamente são return None. Além disso, as duas primeiras linhas estão carregando os valores globais ae index.


4
Seu método de fatiar não remove um elemento de uma lista: em vez disso, cria um novo objeto de lista contendo todos, exceto a i-ésima entrada da lista original. A lista original é deixada sem modificações.
Mark Dickinson

@ MarkDickinson Editou a resposta para esclarecer o mesmo ... Informe-me se parece bom agora?
Raghav RV

6
Talvez a resposta não estivesse inteiramente relacionada ao tópico, mas o método de indexação é útil se você precisar omitir um item de um objeto imutável, como uma tupla. pop () e del () não funcionarão nesse caso.
Caleb

6
@ rvraghav93 de todos os métodos apresentados durante todo o post, o a = a[:index] + a[index+1 :]-trick foi o mais sábio, quando se trata de listas enormes. Todos os outros métodos acabaram em um impasse. Então, muito obrigado
#

3
Na verdade, Mark, você é mal-humorado. Essa resposta é a que eu preferi porque era realmente pedagógica. Aprendi muito com essa resposta e com os detalhes da desmontagem que foram fornecidos e o impacto no desempenho. Além do método de fatiamento, sim, crie outro objeto, mas agora ele é especificado e, às vezes, também é o que você precisa.
Yohan Obadia

52

poptambém é útil para remover e manter um item de uma lista. Onde delrealmente destrói o item.

>>> x = [1, 2, 3, 4]

>>> p = x.pop(1)
>>> p
    2

24

Se você deseja remover o elemento de posição específico em uma lista, como os 2º, 3º e 7º. você não pode usar

del my_list[2]
del my_list[3]
del my_list[7]

Desde que você exclui o segundo elemento, o terceiro elemento que você exclui é o quarto elemento na lista original. Você pode filtrar o 2º, 3º e 7º elemento da lista original e obter uma nova lista, como abaixo:

new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]

19

Isso depende do que você quer fazer.

Se você deseja retornar o elemento que removeu, use pop():

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

No entanto, se você deseja excluir um elemento, use del:

>>> l = [1, 2, 3, 4, 5]
>>> del l[2]
>>> l
[1, 2, 4, 5]

Além disso, delpermite usar fatias (por exemplo del[2:]).


18

Geralmente, estou usando o seguinte método:

>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]

15

Outra maneira de remover um elemento (s) de uma lista por índice.

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove the element at index 3
a[3:4] = []
# a is now [0, 1, 2, 4, 5, 6, 7, 8, 9]

# remove the elements from index 3 to index 6
a[3:7] = []
# a is now [0, 1, 2, 7, 8, 9]

a [x: y] aponta para os elementos do índice xpara y-1. Quando declaramos essa parte da lista como uma lista vazia ( []), esses elementos são removidos.


14

Você pode simplesmente procurar o item que deseja excluir. É realmente simples. Exemplo:

    letters = ["a", "b", "c", "d", "e"]
    letters.remove(letters[1])
    print(*letters) # Used with a * to make it unpack you don't have to (Python 3.x or newer)

Saída: acde


6
Eu gosto dessa solução, mas é claro que ela assume que sua lista não possui duplicatas.
tommy.carstensen

11

Use o código a seguir para remover o elemento da lista:

list = [1, 2, 3, 4]
list.remove(1)
print(list)

output = [2, 3, 4]

Se você deseja remover os dados do elemento de índice da lista, use:

list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]

2
Vem com a ressalva de que sua lista não pode conter duplicatas.
tommy.carstensen

3
Isso não está removendo pelo índice, mas removendo pelo valor correspondente. Isso pode ser uma informação valiosa para algumas pessoas que visitam aqui, mas não tenta responder à pergunta dos OPs.
Anthon

8

Como mencionado anteriormente, a melhor prática é del (); ou pop () se você precisar conhecer o valor.

Uma solução alternativa é empilhar novamente apenas os elementos que você deseja:

    a = ['a', 'b', 'c', 'd'] 

    def remove_element(list_,index_):
        clipboard = []
        for i in range(len(list_)):
            if i is not index_:
                clipboard.append(list_[i])
        return clipboard

    print(remove_element(a,2))

    >> ['a', 'b', 'd']

eta: hmm ... não funcionará em valores de índice negativos, ponderará e atualizará

Eu suponho

if index_<0:index_=len(list_)+index_

iria consertá-lo ... mas de repente essa idéia parece muito quebradiça. Experiência de pensamento interessante embora. Parece que deve haver uma maneira 'apropriada' de fazer isso com a compreensão append () / list.

ponderando


1
Qual versão do Python tem uma função del()? Para essa função, você fornece a lista como o primeiro argumento dessa função e depois o índice, ou o índice primeiro e depois a lista? Ele retorna o argumento da lista sem o item ou faz a exclusão no local. Eu sei sobre a deldeclaração, mas não sobre uma função com o mesmo nome.
Anthon

8

Não parece que você está trabalhando com uma lista de listas, então vou manter isso breve. Você deseja usar o pop, pois ele removerá elementos e não elementos que são listas; você deve usar del para isso. Para chamar o último elemento em python, é "-1"

>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']

1
pop()e delambos removem um elemento no índice fornecido, independentemente de esse elemento ser uma lista ou não. a = [1, [2, 3], 4]; del a[1]; b = [1, [2, 3], 4]; b.pop(1); assert a == b
Anthon

8

l - lista de valores; temos que remover índices da lista inds2rem .

l = range(20)
inds2rem = [2,5,1,7]
map(lambda x: l.pop(x), sorted(inds2rem, key = lambda x:-x))

>>> l
[0, 3, 4, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

não está funcionando, a resposta é <map at 0x7f4d54109a58>. e l é o intervalo (0,20)
Hitesh 30/05

7

Use a função "del" :

del listName[-N]

Por exemplo, se você deseja remover os três últimos itens, seu código deve ser:

del listName[-3:]

Por exemplo, se você deseja remover os últimos 8 itens, seu código deve ser:

del listName[-8:]

2
delé uma afirmação . Se fosse uma função, você teria que escrever #del(listame[-N])
Anthon

7

Já foi mencionado como remover um único elemento de uma lista e quais as vantagens dos diferentes métodos. Observe, no entanto, que a remoção de vários elementos tem algum potencial para erros:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in indices:
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 7, 9]

Os elementos 3 e 8 (não 3 e 7) da lista original foram removidos (como a lista foi reduzida durante o loop), o que pode não ter sido a intenção. Se você deseja remover com segurança vários índices, exclua primeiro os elementos com o índice mais alto, por exemplo:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in sorted(indices, reverse=True):
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 8, 9]

4

Ou se vários índices devem ser removidos:

print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

Claro que também poderia fazer:

print([v for i,v in enumerate(your_list) if i != unwanted_index])

1
Por que você não apenas classifica a lista de índices na ordem inversa e depois os exclui um por um? Dessa forma, você não precisa fazer uma nova lista.
Anthon

3

Você pode usar del ou pop para remover o elemento da lista com base no índice. O pop imprimirá o membro que está removendo da lista, enquanto a lista exclui esse membro sem imprimi-lo.

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

3

Pode-se usar del ou pop, mas eu prefiro del, já que você pode especificar índice e fatias, dando ao usuário mais controle sobre os dados.

Por exemplo, começando com a lista mostrada, é possível remover o último elemento com deluma fatia e, em seguida, remover o último elemento do resultado usando pop.

>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.