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

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

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.

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

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.

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

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

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

En general, estoy usando el siguiente método:

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

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.

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

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]

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

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

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]

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

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]

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

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]