Cómo eliminar un elemento de una lista por índice

Utilice la herramienta del y especifique el índice del elemento que desea eliminar:

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

También admite cortes:

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

Aquí es la sección del tutorial.

Probablemente quieras pop:

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

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

De forma predeterminada, pop sin ningún argumento elimina el último elemento:

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

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

Como otros mencionaron pop y del son al formas eficientes de eliminar un elemento de un índice determinado. Sin embargo, solo por completar (ya que lo mismo se puede hacer de muchas maneras en Python):

Usando porciones (esto no implica la eliminación del artículo de la lista original):

(Además, este será el método menos eficiente cuando se trabaja con la lista de Python, pero esto podría ser útil (pero no eficiente, lo reitero) cuando se trabaja con objetos definidos por el usuario que no admiten pop, pero definen __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: Tenga en cuenta que este método no modifica la lista en su lugar como pop y del. En su lugar, hace dos copias de listas (una desde el principio hasta el índice, pero sin él (a[:index]) y uno después del índice hasta el último elemento (a[index+1:])) y crea un nuevo objeto de lista agregando ambos. Esto luego se reasigna a la variable de lista (a). Por lo tanto, el objeto de la lista anterior se desreferencia y, por lo tanto, se recolecta la basura (siempre que el objeto de la lista original no sea referenciado por ninguna variable que no sea a).

Esto hace que este método sea muy ineficaz y también puede producir efectos secundarios indeseables (especialmente cuando otras variables apuntan al objeto de la lista original que permanece sin modificar).

Gracias a @MarkDickinson por señalar esto ...

Este hermoso tono marrón de medio tono ayuda a definir y delinear tus labios en pigmentos que favorecen a todo tipo de piel, ayudándote a lograr unos labios más llenos que no se desvanecen durante horas. La respuesta de Stack Overflow explica el concepto de rebanar.

También tenga en cuenta que esto solo funciona con índices positivos.

Mientras se usa con objetos, el __getitem__ debe haber sido definido y, lo que es más importante, el __add__ El método debe haber sido definido para devolver un objeto que contenga elementos de ambos operandos.

En esencia, esto funciona con cualquier objeto cuya definición de clase sea 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 )

Esto funciona con list que define __getitem__ y __add__ métodos.

Comparación de las tres formas en términos de eficiencia:

Suponga que lo siguiente está predefinido:

a = range(10)
index = 3

La del object[index] método:

Con mucho, el método más eficaz. Funciona con todos los objetos que definen un __del__ método.

El desmontaje es el siguiente:

Código:

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

Desmontaje:

 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:

Es menos eficiente que el método del y se usa cuando necesita obtener el elemento eliminado.

Código:

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

Desmontaje:

 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

El método de cortar y agregar.

El menos eficiente.

Código:

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

Desmontaje:

 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: En los tres desmontajes ignore las dos últimas líneas que básicamente son return None. Además, las dos primeras líneas están cargando los valores globales. a y index.

pop también es útil para eliminar y mantener un elemento de una lista. Dónde del en realidad, tira el elemento a la papelera.

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

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

Si desea eliminar el elemento de posición específico en una lista, como el 2, 3 y 7. no puedes usar

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

Dado que después de eliminar el segundo elemento, el tercer elemento que elimina en realidad es el cuarto elemento de la lista original. Puede filtrar el elemento 2, 3 y 7 en la lista original y obtener una nueva lista, como a continuación:

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

Generalmente, estoy usando el siguiente método:

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

Depende de lo que quieras hacer.

Si desea devolver el elemento que eliminó, use pop():

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

Sin embargo, si solo desea eliminar un elemento, use del:

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

Además, del le permite utilizar rebanadas (p. ej. del[2:]).

Otra forma más de eliminar un elemento (s) de una 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] apunta a los elementos del índice x a y-1. Cuando declaramos esa parte de la lista como una lista vacía ([]), esos elementos se eliminan.

Ya se ha mencionado cómo eliminar un solo elemento de una lista y qué ventajas tienen los diferentes métodos. Tenga en cuenta, sin embargo, que la eliminación múltiples elementos tiene cierto potencial de errores:

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

Los elementos 3 y 8 (no 3 y 7) de la lista original se han eliminado (ya que la lista se acortó durante el ciclo), lo que podría no haber sido la intención. Si desea eliminar de forma segura varios índices, debe eliminar primero los elementos con el índice más alto, por ejemplo, de esta manera:

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

Simplemente puede buscar el elemento que desea eliminar. Es realmente sencillo. Ejemplo:

    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)

Salida: acde

Utilice el siguiente código para eliminar el elemento de la lista:

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

output = [2, 3, 4]

Si desea eliminar los datos del elemento de índice de la lista, use:

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

Use el del declaración:

del listName[-N]

Por ejemplo, si desea eliminar los últimos 3 elementos, su código debe ser:

del listName[-3:]

Por ejemplo, si desea eliminar los últimos 8 elementos, su código debe ser:

del listName[-8:]

l - lista de valores; tenemos que eliminar los índices de inds2rem lista.

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]

Como se mencionó anteriormente, la mejor práctica es del (); o pop () si necesita conocer el valor.

Una solución alternativa es volver a apilar solo los elementos que desee:

    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 ... no funcionará con valores de índice negativos, reflexionará y actualizará

Supongo

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

lo parchearía ... pero de repente esta idea parece muy frágil. Aunque interesante experimento mental. Parece que debería haber una forma 'adecuada' de hacer esto con append () / list comprehension.

ponderando

No parece que esté trabajando con una lista de listas, así que seré breve. Desea usar pop ya que eliminará elementos, no elementos que sean listas, debe usar del para eso. Para llamar al último elemento en Python es "-1"

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

O si se deben eliminar varios índices:

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

Por supuesto, entonces también podría hacer:

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

Puede usar del o pop para eliminar el elemento de la lista según el índice. Pop imprimirá el miembro que está eliminando de la lista, mientras que la lista eliminará ese miembro sin imprimirlo.

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

Se puede usar del o pop, pero yo prefiero del, ya que puede especificar el índice y los cortes, lo que le da al usuario más control sobre los datos.

Por ejemplo, comenzando con la lista que se muestra, se puede eliminar su último elemento con del como un corte, y luego uno puede eliminar el último elemento del 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]