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


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

Encontré el list.remove método, pero dicen 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.


1050
2018-03-09 18:16


origen


Respuestas:


Utilizar 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 rebanadas:

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

aquí es la sección del tutorial.


1211
2018-03-09 18:21



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

488
2018-03-09 18:17



Como otros mencionaron pop y del son el formas eficientes de eliminar un ítem del índice dado. Sin embargo, solo para completar (dado que lo mismo se puede hacer de muchas maneras en Python):

Usar rebanadas (esto no implica la eliminación de un elemento de la lista original):

(También 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 ella (a[:index]) y uno después del índice hasta el último elemento (a[index+1:])) y crea un nuevo objeto de lista al agregar ambos. Esto se reasigna a la variable de la 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 esté 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 la lista original que permanece sin modificar).

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

Esta La respuesta de Stack Overflow explica el concepto de slicing.

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

Mientras se usa con objetos, el __getitem__ método debe haber sido definido y más importante, la __add__ El 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 similar a:

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:

De lejos, el método más eficiente. Funciona todos los objetos que definen una __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 slice y add.

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


96
2018-06-22 15:21



pop también es útil para eliminar y mantener un elemento de una lista. Dónde delen realidad destroza el artículo.

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

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

41
2017-10-19 13:10



En general, estoy usando el siguiente método:

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

12
2017-10-05 12:23



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]

Adicionalmente, del le permite usar sectores (p. ej. del[2:])


10
2017-08-11 00:17



Otra forma más de eliminar un elemento 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 porción de la lista como una lista vacía ([]), esos elementos se eliminan.


6
2017-10-30 09:21