Solución:
Usar 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í 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, 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 los 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 un __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 …
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__ El método 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
los 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.