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

1827

¿Cómo elimino un elemento de una lista por índice en Python?

Encontré el list.removemétodo, pero digo que quiero eliminar el último elemento, ¿cómo hago esto? Parece que la eliminación predeterminada busca en la lista, pero no quiero que se realice ninguna búsqueda.

7
  • 14
    @smci: la lista de Python se basa en matrices: para eliminar un elemento en el medio, debe mover todos los elementos a la derecha para eliminar el espacio, por eso está O(n)en operación de tiempo. deque()proporciona operaciones eficientes en ambos extremos pero no proporciona O (1) inserciones / búsquedas / eliminaciones en el medio.
    jfs
    8 de septiembre de 2015 a las 0:32
  • @JFSebastian: implementación de cPython, sí, gracias por corregirme. Estrictamente, la especificación del lenguaje no especifica cómo implementar la lista, las implementaciones alternativas podrían optar por usar una lista vinculada.
    smci
    8 de septiembre de 2015 a las 19:35
  • @smci: ninguna implementación práctica de Python usaría el O(n)acceso al índice a[i](debido a las listas vinculadas). Nota: la implementación basada en matrices proporciona O(1)acceso a índices.
    jfs
    23 de febrero de 2016 a las 0:54
  • @JFSebastian: por supuesto. Simplemente noté que la especificación del idioma no define esto , es un problema de implementación. (Me sorprendió descubrir que no era así).
    smci
    27 feb 2016 a las 9:45
  • @smci, si su objetivo es tan amplio, no estoy seguro de cómo puede esperar optimizar algo.
    Nick T
    16 de agosto de 2017 a las 4:28
2122

Utilice dely 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í está la sección del tutorial.

16
  • 64
    Gracias, ¿cuál es la diferencia entre pop y del? 9 mar 09 a las 18:34
  • 41
    del está sobrecargado. Por ejemplo, del a borra toda la lista. 9 de marzo de 2009 a las 18:36
  • 38
    otro ejemplo del a [2: 4], elimina los elementos 2 y 3 9 mar 09 a las 18:37
  • 333
    pop () devuelve el elemento que desea eliminar. del solo elimina es.
    unbeknown
    9 de marzo de 2009 a las 19:14
  • 14
    No puedo ver una prueba de "lista vinculada" allí. Mire svn.python.org/projects/python/trunk/Objects/listobject.c cómo PyList_GetItem()devuelve esencialmente ((PyListObject *)op) -> ob_item[i];: el ielemento número uno de una matriz.
    glglgl
    9 de septiembre de 2013 a las 7:53
754

Probablemente quieras pop:

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

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

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

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

# now a is ['a', 'b', 'c']
8
  • 108
    No olvides pop (-1). Sí, es el predeterminado, pero lo prefiero para no tener que recordar qué end pop usa por defecto.
    S.Lott
    9 mar 09 a las 18:43
  • 320
    Estoy en desacuerdo. Si conoce la etimología del programador de "pop" (es la operación que elimina y devuelve la parte superior de una estructura de datos 'pila'), entonces pop()por sí solo es muy obvio, mientras que pop(-1)es potencialmente confuso precisamente porque es redundante. 22/04/13 a las 22:07
  • a.pop (-1) para eliminar el último?
    zx1986
    30 de julio de 2013 a las 8:56
  • 14
    @ zx1986 a popen la mayoría de los lenguajes de programación generalmente elimina el último elemento, como lo hace en Python. Entonces, ya sea que especifique -1 o nada, es lo mismo.
    Pascal
    2 de agosto de 2013 a las 14:45
  • 36
    Por cierto, pop()devuelve cualquier elemento que eliminó. 30 de enero de 2016 a las 10:03
163

Como otros mencionados, pop y del son las 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 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: tenga en cuenta que este método no modifica la lista en su lugar como popy del. En su lugar, hace dos copias de listas (una desde el principio hasta el índice pero sin él ( a[:index]) y otra 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 ...

Esta 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__método debe haberse definido y, lo que es más importante, el __add__método debe haberse 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 lo listque 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

El 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 ay index.

6
  • 5
    Su método de división no elimina un elemento de una lista: en su lugar, crea un nuevo objeto de lista que contiene todas las entradas de la lista original menos la i-ésima. La lista original no se modifica. 22/06/2014 a las 15:28
  • @MarkDickinson He editado la respuesta para aclarar lo mismo ... Por favor, avíseme si se ve bien ahora. 22/06/2014 a las 16:13
  • 7
    Tal vez la respuesta no esté completamente relacionada con el tema, pero el método de indexación es útil si necesita omitir un elemento de un objeto inmutable, como una tupla. pop () y del () no funcionarán en ese caso.
    Caleb
    18 dic '14 a las 17:31
  • 7
    @ rvraghav93 de todos los métodos presentados durante toda la publicación, el a = a[:index] + a[index+1 :]truco fue el más seguro cuando se trata de listas enormes. Todos los demás métodos terminaron en un punto muerto. Así que muchas gracias 4 mar 16 a las 18:38
  • 4
    De hecho, Mark, estás de mal humor. Esta respuesta es la que preferí porque era realmente pedagógica. Aprendí más de esta respuesta y los detalles de desmontaje que se proporcionaron y el impacto en el rendimiento. Además del método de corte, sí, crea otro objeto, pero ahora está especificado y, a veces, eso también es lo que necesitas. 8 de mayo de 2017 a las 7:54
56

poptambién es útil para eliminar y mantener un elemento de una lista. Donde delrealmente tira el artículo a la basura.

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

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

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]]
1
  • Se adapta a mi necesidad. Necesito revisar una lista y eliminar algunos de ellos. Entonces, con este método, simplemente guardaré en otra lista los índices de los elementos que quiero eliminar, y luego, al final, usaré el método que diste para eliminarlos todos a la vez.
    Magnus
    23 jul.20 a las 9:42
24

Ya se ha mencionado cómo eliminar un solo elemento de una lista y qué ventajas tienen los diferentes métodos. Sin embargo, tenga en cuenta que la eliminación de varios elementos puede generar 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]
20

Generalmente, estoy usando el siguiente método:

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

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, le delpermite utilizar porciones (por ejemplo del[2:]).

19

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 xa y-1. Cuando declaramos esa parte de la lista como una lista vacía ( []), esos elementos se eliminan.

0
15

Utilice la deldeclaració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 debería ser:

del listName[-8:]
0
14

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

1
  • 6
    Me gusta esta solución, pero por supuesto asume que su lista no tiene duplicados. 25/08/18 a las 15:39
11

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, utilice:

list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]
2
  • 2
    Viene con la advertencia de que su lista no puede contener duplicados. 25/08/18 a las 15:39
  • 3
    No se trata de eliminar por índice, sino de eliminar por valor coincidente. Esa podría ser información valiosa para algunas personas que visitan aquí, pero no intenta responder la pregunta de OP en absoluto.
    Anthon
    2/12/18 a las 13:34
10

l - lista de valores; tenemos que eliminar los índices de la 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]
1
  • no funciona, la respuesta es <map at 0x7f4d54109a58>. y l es rango (0,20)
    Hitesh
    30 de mayo de 2018 a las 11:03
9

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.

reflexionando

1
  • 1
    ¿Qué versión de Python tiene una función del()? Para esa función, proporcionas la lista como primer argumento para esa función y luego el índice, ¿o el índice primero y luego la lista? ¿Devuelve el argumento de la lista sin el elemento o lo elimina en su lugar? Sé sobre la deldeclaración, pero no sobre una función con el mismo nombre.
    Anthon
    2/12/18 a las 13:40
9

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']
1
  • 1
    pop()y delambos eliminan un elemento en el índice proporcionado, independientemente de si ese elemento es en sí mismo una lista o no.a = [1, [2, 3], 4]; del a[1]; b = [1, [2, 3], 4]; b.pop(1); assert a == b
    Anthon
    2 dic 2018 a las 14:02
7

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])
1
  • 1
    ¿Por qué no ordena la lista de índices en orden inverso y luego los elimina uno por uno? De esa forma, no es necesario que hagas una nueva lista.
    Anthon
    2/12/18 a las 13:53
4

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

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 delcomo un segmento, y luego se 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]