Eliminar múltiples elementos de una lista

¿Es posible eliminar varios elementos de una lista al mismo tiempo? Si quiero eliminar elementos en el índice 0 y 2, e intentar algo como del somelist[0], seguido de del somelist[2], la segunda declaración se eliminará realmente somelist[3].

Supongo que siempre podría eliminar primero los elementos con un número más alto, pero espero que haya una mejor manera.

Puede usar enumeratey eliminar los valores cuyo índice coincide con los índices que desea eliminar:

indices = 0, 2
somelist = [i for j, i in enumerate(somelist) if j not in indices]

Por alguna razón, no me gusta ninguna de las respuestas aquí. Sí, funcionan, pero estrictamente hablando, la mayoría de ellos no están eliminando elementos de una lista, ¿verdad? (Pero haciendo una copia y luego reemplazando la original con la copia editada).

¿Por qué no simplemente eliminar primero el índice más alto?

¿Hay alguna razón para esto? Yo solo haría:

for i in sorted(indices, reverse=True):
    del somelist[i]

Si realmente no desea eliminar elementos al revés, entonces supongo que debería reducir los valores de los índices que son mayores que el último índice eliminado (realmente no puede usar el mismo índice ya que tiene una lista diferente) o usar una copia de la lista (que no estaría 'borrando' sino reemplazando el original con una copia editada).

¿Me falta algo aquí, alguna razón para NO eliminar en el orden inverso?

Si está eliminando varios elementos no adyacentes, entonces lo que describe es la mejor manera (y sí, asegúrese de comenzar desde el índice más alto).

Si sus elementos son adyacentes, puede usar la sintaxis de asignación de divisiones:

a[2:10] = []

Puedes usar numpy.deletelo siguiente:

import numpy as np
a = ['a', 'l', 3.14, 42, 'u']
I = [0, 2]
np.delete(a, I).tolist()
# Returns: ['l', '42', 'u']

Si no le importa terminar con una numpymatriz al final, puede omitir el .tolist(). También debería ver algunas mejoras de velocidad bastante importantes, lo que hace que esta sea una solución más escalable. No lo he comparado, pero las numpyoperaciones son código compilado escrito en C o Fortran.

Como especialización de la respuesta de Greg, incluso puede usar la sintaxis de corte extendida. p.ej. Si desea eliminar los elementos 0 y 2:

>>> a= [0, 1, 2, 3, 4]
>>> del a[0:3:2]
>>> a
[1, 3, 4]

Esto no cubre ninguna selección arbitraria, por supuesto, pero ciertamente puede funcionar para eliminar dos elementos.

Como una función:

def multi_delete(list_, *args):
    indexes = sorted(list(args), reverse=True)
    for index in indexes:
        del list_[index]
    return list_

Se ejecuta en n log (n) tiempo, lo que debería convertirlo en la solución correcta más rápida hasta el momento.

Entonces, ¿esencialmente quieres eliminar varios elementos en una sola pasada? En ese caso, la posición del siguiente elemento a eliminar se compensará con la cantidad que se haya eliminado anteriormente.

Nuestro objetivo es eliminar todas las vocales, que se calculan previamente como índices 1, 4 y 7. Tenga en cuenta que es importante que los índices to_delete estén en orden ascendente, de lo contrario no funcionará.

to_delete = [1, 4, 7]
target = list("hello world")
for offset, index in enumerate(to_delete):
  index -= offset
  del target[index]

Sería más complicado si quisieras eliminar los elementos en cualquier orden. En mi opinión, la clasificación to_deletepodría ser más fácil que averiguar cuándo debería o no restar index.

Soy un principiante total en Python, y mi programación en este momento es cruda y sucia, por decir lo menos, pero mi solución fue usar una combinación de los comandos básicos que aprendí en los primeros tutoriales:

some_list = [1,2,3,4,5,6,7,8,10]
rem = [0,5,7]

for i in rem:
    some_list[i] = '!' # mark for deletion

for i in range(0, some_list.count('!')):
    some_list.remove('!') # remove
print some_list

Obviamente, debido a que tiene que elegir un carácter de "marca para eliminación", esto tiene sus limitaciones.

En cuanto al rendimiento ya que el tamaño de la lista se escala, estoy seguro de que mi solución es subóptima. Sin embargo, es sencillo, lo que espero atraiga a otros principiantes, y funcionará en casos simples en los que some_listsea ​​de un formato conocido, por ejemplo, siempre numérico ...

Aquí hay una alternativa, que no utiliza enumerate () para crear tuplas (como en la respuesta original de SilentGhost).

Esto me parece más legible. (Tal vez me sentiría diferente si tuviera la costumbre de usar enumerar). CAVEAT: No he probado el rendimiento de los dos enfoques.

# Returns a new list. "lst" is not modified.
def delete_by_indices(lst, indices):
    indices_as_set = set(indices)
    return [ lst[i] for i in xrange(len(lst)) if i not in indices_as_set ]

NOTA: sintaxis de Python 2.7. Para Python 3, xrange=> range.

Uso:

lst = [ 11*x for x in xrange(10) ]
somelist = delete_by_indices( lst, [0, 4, 5])

somelista

[11, 22, 33, 66, 77, 88, 99]

--- BONIFICACIÓN ---

Eliminar múltiples valores de una lista. Es decir, tenemos los valores que queremos eliminar:

# Returns a new list. "lst" is not modified.
def delete__by_values(lst, values):
    values_as_set = set(values)
    return [ x for x in lst if x not in values_as_set ]

Uso:

somelist = delete__by_values( lst, [0, 44, 55] )

somelista

[11, 22, 33, 66, 77, 88, 99]

Esta es la misma respuesta que antes, pero esta vez proporcionamos los VALORES que se eliminarán [0, 44, 55].

Un método alternativo de comprensión de listas que utiliza valores de índice de listas:

stuff = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
index = [0, 3, 6]
new = [i for i in stuff if stuff.index(i) not in index]

Esto devuelve:

['b', 'c', 'e', 'f']

Aquí hay otro método que elimina los elementos en su lugar. Además, si su lista es realmente larga, es más rápida.

>>> a = range(10)
>>> remove = [0,4,5]
>>> from collections import deque
>>> deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)

>>> timeit.timeit('[i for j, i in enumerate(a) if j not in remove]', setup='import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.1704120635986328

>>> timeit.timeit('deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)', setup='from collections import deque;import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1)
0.004853963851928711

Esto se ha mencionado, pero de alguna manera nadie logró hacerlo bien.

En O(n)solución sería:

indices = {0, 2}
somelist = [i for j, i in enumerate(somelist) if j not in indices]

Esto está muy cerca de la versión de SilentGhost , pero agrega dos llaves.

l = ['a','b','a','c','a','d']
to_remove = [1, 3]
[l[i] for i in range(0, len(l)) if i not in to_remove])

Básicamente es lo mismo que la respuesta más votada, solo una forma diferente de escribirla. Tenga en cuenta que usar l.index () no es una buena idea, ya que no puede manejar elementos duplicados en una lista.

El método de eliminación provocará muchos cambios en los elementos de la lista. Creo que es mejor hacer una copia:

...
new_list = []
for el in obj.my_list:
   if condition_is_true(el):
      new_list.append(el)
del obj.my_list
obj.my_list = new_list
...

técnicamente, la respuesta es NO, no es posible eliminar dos objetos AL MISMO TIEMPO. Sin embargo, ES posible eliminar dos objetos en una línea de Python hermosa.

del (foo['bar'],foo['baz'])

borrará recusivamente foo['bar'], luegofoo['baz']

podemos hacer esto mediante el uso de un ciclo for iterando sobre los índices después de ordenar la lista de índices en orden descendente

mylist=[66.25, 333, 1, 4, 6, 7, 8, 56, 8769, 65]
indexes = 4,6
indexes = sorted(indexes, reverse=True)
for i in index:
    mylist.pop(i)
print mylist

Para los índices 0 y 2 de la lista A:

for x in (2,0): listA.pop(x)

Para algunos índices aleatorios para eliminar de la lista A:

indices=(5,3,2,7,0) 
for x in sorted(indices)[::-1]: listA.pop(x)

Quería una forma de comparar las diferentes soluciones que facilitaban girar los mandos.

Primero generé mis datos:

import random

N = 16 * 1024
x = range(N)
random.shuffle(x)
y = random.sample(range(N), N / 10)

Luego definí mis funciones:

def list_set(value_list, index_list):
    index_list = set(index_list)
    result = [value for index, value in enumerate(value_list) if index not in index_list]
    return result

def list_del(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        del(value_list[index])

def list_pop(value_list, index_list):
    for index in sorted(index_list, reverse=True):
        value_list.pop(index)

Luego solía timeitcomparar las soluciones:

import timeit
from collections import OrderedDict

M = 1000
setup = 'from __main__ import x, y, list_set, list_del, list_pop'
statement_dict = OrderedDict([
    ('overhead',  'a = x[:]'),
    ('set', 'a = x[:]; list_set(a, y)'),
    ('del', 'a = x[:]; list_del(a, y)'),
    ('pop', 'a = x[:]; list_pop(a, y)'),
])

overhead = None
result_dict = OrderedDict()
for name, statement in statement_dict.iteritems():
    result = timeit.timeit(statement, number=M, setup=setup)
    if overhead is None:
        overhead = result
    else:
        result = result - overhead
        result_dict[name] = result

for name, result in result_dict.iteritems():
    print "%s = %7.3f" % (name, result)

Salida

set =   1.711
del =   3.450
pop =   3.618

Entonces el generador con los índices en a setfue el ganador. Y deles un poco más rápido entonces pop.

Puedes usar esta lógica:

my_list = ['word','yes','no','nice']

c=[b for i,b in enumerate(my_list) if not i in (0,2,3)]

print c

Otra implementación de la idea de eliminar del índice más alto.

for i in range(len(yourlist)-1, -1, -1):
    del yourlist(i)

De hecho, puedo pensar en dos formas de hacerlo:

1. cortar la lista como (esto elimina los elementos primero, tercero y octavo)

   somelist = somelist [1: 2] + somelist [3: 7] + somelist [8:]

2. hacer eso en su lugar, pero uno a la vez:

   somelist.pop (2) somelist.pop (0)

Puedes hacerlo así en un dict, no en una lista. En una lista los elementos están en secuencia. En un dict dependen solo del índice.

Código simple solo para explicarlo haciendo :

>>> lst = ['a','b','c']
>>> dct = {0: 'a', 1: 'b', 2:'c'}
>>> lst[0]
'a'
>>> dct[0]
'a'
>>> del lst[0]
>>> del dct[0]
>>> lst[0]
'b'
>>> dct[0]
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    dct[0]
KeyError: 0
>>> dct[1]
'b'
>>> lst[1]
'c'

Una forma de "convertir" una lista en un dict es:

>>> dct = {}
>>> for i in xrange(0,len(lst)): dct[i] = lst[i]

El inverso es:

lst = [dct[i] for i in sorted(dct.keys())] 

De todos modos, creo que es mejor comenzar a eliminar del índice más alto como dijiste.

Para generalizar el comentario de @sth . La eliminación de elementos en cualquier clase, que implementa abc.MutableSequence , y listen particular, se realiza mediante un __delitem__método mágico. Este método funciona de manera similar __getitem__, lo que significa que puede aceptar un número entero o un segmento. Aquí hay un ejemplo:

class MyList(list):
    def __delitem__(self, item):
        if isinstance(item, slice):
            for i in range(*item.indices(len(self))):
                self[i] = 'null'
        else:
            self[item] = 'null'


l = MyList(range(10))
print(l)
del l[5:8]
print(l)

Esto dará salida

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 'null', 'null', 'null', 8, 9]

Importarlo solo por esta razón puede ser exagerado, pero si de pandastodos modos lo está utilizando , entonces la solución es simple y directa:

import pandas as pd
stuff = pd.Series(['a','b','a','c','a','d'])
less_stuff = stuff[stuff != 'a']  # define any condition here
# results ['b','c','d']

some_list.remove(some_list[max(i, j)])

Evita el costo de clasificación y tener que copiar explícitamente la lista.

¿Qué tal uno de estos (soy muy nuevo en Python, pero parecen estar bien):

ocean_basin = ['a', 'Atlantic', 'Pacific', 'Indian', 'a', 'a', 'a']
for i in range(1, (ocean_basin.count('a') + 1)):
    ocean_basin.remove('a')
print(ocean_basin)

['Atlántico', 'Pacífico', 'Indio']

ob = ['a', 'b', 4, 5,'Atlantic', 'Pacific', 'Indian', 'a', 'a', 4, 'a']
remove = ('a', 'b', 4, 5)
ob = [i for i in ob if i not in (remove)]
print(ob)

['Atlántico', 'Pacífico', 'Indio']

Ninguna de las respuestas ofrecidas hasta ahora realiza la eliminación en su lugar en O (n) en la longitud de la lista para eliminar un número arbitrario de índices, así que aquí está mi versión:

def multi_delete(the_list, indices):
    assert type(indices) in {set, frozenset}, "indices must be a set or frozenset"
    offset = 0
    for i in range(len(the_list)):
        if i in indices:
            offset += 1
        elif offset:
            the_list[i - offset] = the_list[i]
    if offset:
        del the_list[-offset:]

# Example:
a = [0, 1, 2, 3, 4, 5, 6, 7]
multi_delete(a, {1, 2, 4, 6, 7})
print(a)  # prints [0, 3, 5]

Puedes usar remove, también.

delete_from_somelist = []
for i in [int(0), int(2)]:
     delete_from_somelist.append(somelist[i])
for j in delete_from_somelist:
     newlist = somelist.remove(j)

Lo puse todo junto en una list_difffunción que simplemente toma dos listas como entradas y devuelve su diferencia, conservando el orden original de la primera lista.

def list_diff(list_a, list_b, verbose=False):

    # returns a difference of list_a and list_b,
    # preserving the original order, unlike set-based solutions

    # get indices of elements to be excluded from list_a
    excl_ind = [i for i, x in enumerate(list_a) if x in list_b]
    if verbose:
        print(excl_ind)

    # filter out the excluded indices, producing a new list 
    new_list = [i for i in list_a if list_a.index(i) not in excl_ind]
    if verbose:
        print(new_list)

    return(new_list)

Uso de la muestra:

my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
# index = [0, 3, 6]

# define excluded names list
excl_names_list = ['woof', 'c']

list_diff(my_list, excl_names_list)
>> ['a', 'b', 'd', 'e', 'f']