Como remover um elemento de uma lista por índice

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.

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.

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

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.

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

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

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:]).

Geralmente, estou usando o seguinte método:

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

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.

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

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]

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

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

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]

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

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]

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

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

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]