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

python list to string

Question

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

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

Answer 1

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

Usar rebanadas (esto no hace la eliminación en su lugar del artículo de la lista original):

(También este será el método menos eficiente al trabajar con la lista de Python, pero podría ser útil (pero no eficiente, lo reitero) cuando se trabaja con objetos definidos por el usuario que no admiten pop, pero sí 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, realiza dos copias de listas (una desde el inicio 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 añadiendo ambos. Esto se reasigna a la variable de lista ( a ). Por lo tanto, el objeto de la lista anterior está desreferenciado y, por lo tanto, se recolecta la basura (siempre que el objeto de la lista original no sea referenciado por ninguna variable distinta de 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 ...

This respuesta de Stack Overflow explica el concepto de rebanar.

También tenga en cuenta que esto funciona sólo con índices positivos.

Mientras se usa con objetos, el método __getitem__ debe haberse definido y, lo que es más importante, el método __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 la list que define los métodos __getitem__ y __add__ .

Comparación de las tres formas en términos de eficiencia:

Supongamos que lo siguiente está predefinido:

a = range(10)
index = 3

El método del object[index] :

Con mucho, el método más eficiente. Funciona con todos los objetos que definan un método __del__ .

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

método pop :

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

La rebanada y el método de añadir.

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

Answer 2

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, ponderará y actualizará

supongo

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

lo remendaría ... pero de repente esta idea parece muy frágil. Sin embargo, experimento de pensamiento interesante. Parece que debería haber una forma "adecuada" de hacer esto con append () / list comprensión.

reflexionando

Answer 3

En general, estoy usando el siguiente método:

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

Answer 4

Esto depende de lo que quieras hacer.

Si desea devolver el elemento que quitó, 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, del permite usar segmentos (por ejemplo, del[2:] ).

Answer 5

No suena como si estuvieras trabajando con una lista de listas, así que voy a ser breve. Desea usar pop, ya que eliminará los elementos, no los 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'']

Answer 6

O si se deben eliminar múltiples í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])

Answer 7

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

Answer 8

Probablemente quieras pop

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

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

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

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

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

Answer 9

Puede usar del o pop para eliminar un elemento de la lista según el índice. Pop imprimirá el miembro que está eliminando de la lista, mientras que la lista lo elimina sin imprimirlo.

>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
 3
>>> a
[1, 4, 5]
>>> 

Answer 10

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]

Ya que después de eliminar el segundo elemento, el tercer elemento que realmente elimina es el cuarto elemento en 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]]

Answer 11

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

Answer 12

Simplemente puede utilizar la función de remove de Python. Me gusta esto:

v = [1, 2, 3, 4, 5, 6]
v.remove(v[4]) # I''m removing the number with index 4 of my array
print(v) # If you want verify the process

# It gave me this:
#[1,2,3,4,6]

Answer 13

Uno puede usar del o pop, pero yo prefiero el de, ya que puede especificar el índice y los segmentos, dando al usuario un mayor control sobre los datos.

Por ejemplo, comenzando con la lista que se muestra, uno puede eliminar su último elemento con del como una porción, y luego uno puede eliminar el último elemento del resultado utilizando el pop .

>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]

Answer 14

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 del índice de la lista, utilice:

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

Answer 15

Utilice 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 soporta rebanadas:

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

Here está la sección del tutorial.

Answer 16

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

Answer 17

pop también es útil para eliminar y mantener un elemento de una lista. Donde el en realidad destruye el artículo.

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

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

Answer 18

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]