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


1507

¿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.


10
@smci: la lista de Python está basada en una matriz: para eliminar un elemento en el medio, debe mover todos los elementos a la derecha para eliminar la brecha, por eso está O(n)en operación a tiempo. deque()proporciona operaciones eficientes en ambos extremos, pero no proporciona O (1) inserciones / búsquedas / eliminaciones en el medio.
jfs

@JFSebastian: implementación de cPython, sí, gracias por corregirme. Estrictamente, la especificación del lenguaje no especifica cómo implementar la lista, implementaciones alternativas podrían optar por usar una lista vinculada.
smci

@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 matriz proporciona O(1)acceso al índice.
jfs

@JFSebastian: por supuesto. Simplemente noté que la especificación del lenguaje no define esto , es un problema de implementación. (Me sorprendió descubrir que no fue así)
smci

@smci si está apuntando a eso de manera amplia, no estoy seguro de cómo puede esperar optimizar algo.
Nick T

Respuestas:


1741

Use 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 rodajas:

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

Aquí está la sección del tutorial.


53
Gracias, ¿cuál es la diferencia entre pop y del?
Joan Venge

37
del está sobrecargado. Por ejemplo, del borra toda la lista
Brian R. Bondy

34
otro ejemplo del a [2: 4], elimina los elementos 2 y 3
Brian R. Bondy

307
pop () devuelve el elemento que desea eliminar. del solo elimina es.

13
No puedo ver una prueba de "lista vinculada" allí. Mire svn.python.org/projects/python/trunk/Objects/listobject.c cómo PyList_GetItem()esencialmente regresa ((PyListObject *)op) -> ob_item[i];: el ielemento th de una matriz.
glglgl

649

Probablemente quieras pop:

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

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

Por defecto, popsin ningún argumento elimina el último elemento:

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

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

105
No olvides pop (-1). Sí, es el valor predeterminado, pero lo prefiero para no tener que recordar qué final pop usa de forma predeterminada.
S.Lott

282
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 'apilados'), entonces, pop()por sí mismo, es muy obvio, mientras que pop(-1)es potencialmente confuso precisamente porque es redundante.
coredumperror

a.pop (-1) para eliminar el último?
zx1986

14
@ zx1986 a popen la mayoría de los lenguajes de programación generalmente elimina el último elemento, como lo hace en Python. Entonces, si especifica -1 o nada es igual.
Pascal

30
Por cierto, pop()devuelve cualquier elemento que eliminó.
Bob Stein

136

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

Uso de sectores (esto no elimina en su lugar el elemento 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, 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 las listas (una desde el principio hasta el índice pero sin ella ( 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 lista anterior se desreferencia y, por lo tanto, se recolecta basura (siempre que el objeto de lista original no sea referenciado por ninguna variable que no sea a).

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

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

Esta respuesta de desbordamiento de pila explica el concepto de corte.

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 __add__, 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 eficiente. 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 desmontazos, ignore las dos últimas líneas que básicamente son return None. También las dos primeras líneas están cargando los valores globales ay index.


44
Su método de división no elimina un elemento de una lista: en su lugar, crea un nuevo objeto de lista que contiene todos menos la entrada i-ésima de la lista original. La lista original se deja sin modificar.
Mark Dickinson

@ MarkDickinson Han editado la respuesta para aclarar lo mismo ... Por favor, avíseme si se ve bien ahora.
Raghav RV

66
Tal vez la respuesta no fue del todo sobre 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

66
@ 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 grandes listas. Todos los otros métodos terminaron en un punto muerto. Así que muchas gracias
user3085931

3
De hecho Mark, estás gruñón. 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 división, sí, cree otro objeto, pero ahora está especificado y, a veces, eso es también lo que necesita.
Yohan Obadia

52

popTambién es útil para eliminar y mantener un elemento de una lista. Donde delrealmente destroza el artículo.

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

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

24

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

19

Esto 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 usar sectores (por ejemplo del[2:]).


18

En general, estoy usando el siguiente método:

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

15

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.


14

Simplemente puede buscar el elemento que desea eliminar. Es realmente simple 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


66
Me gusta esta solución, pero por supuesto supone que su lista no tiene duplicados.
tommy.carstensen

11

Use 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 índice de la lista, use:

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

2
Viene con la advertencia de que su lista no puede contener duplicados.
tommy.carstensen

3
Esto no es eliminar por índice, sino eliminar por valor coincidente. Esa podría ser información valiosa para algunas personas que visitan aquí, pero no intenta responder a la pregunta de los OP en absoluto.
Anthon

8

Como se mencionó anteriormente, la mejor práctica es del (); o pop () si necesita saber 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á en valores de índice negativos, reflexionará y actualizará

supongo

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

lo arreglaría ... pero de repente esta idea parece muy frágil. Interesante experimento mental sin embargo. Parece que debería haber una forma 'adecuada' de hacer esto con la comprensión de append () / list.

meditando


1
¿Qué versión de Python tiene una función del()? Para esa función, ¿proporciona la lista como el 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 elimina en su lugar? Sé sobre la deldeclaración, pero no sobre una función con el mismo nombre.
Anthon

8

No parece que estés trabajando con una lista de listas, así que lo mantendré breve. Desea usar pop ya que eliminará elementos, no elementos que son 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
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

8

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]

no funciona, la respuesta es <map at 0x7f4d54109a58>. y l es rango (0,20)
Hitesh

7

Use la función "del" :

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

2
delEs una declaración . Si fuera una función, tendrías que escribirdel(listame[-N])
Anthon

7

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 eliminar varios elementos tiene algún 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 múltiples índices, primero debe eliminar los elementos con el índice más alto, por ejemplo, así:

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

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
¿Por qué no clasifica la lista de índices en orden inverso y luego los elimina uno por uno? De esa manera no tienes que hacer una nueva lista.
Anthon

3

Puede usar del o pop para eliminar elementos de la lista en función del í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]
>>> 

3

Se puede usar del o pop, pero prefiero del, ya que puede especificar índices y sectores, 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 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]
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.