Löschen mehrerer Elemente aus einer Liste

Ist es möglich, mehrere Elemente gleichzeitig aus einer Liste zu löschen? Wenn ich Elemente bei Index 0 und 2 löschen und etwas wie versuchen möchte del somelist[0], gefolgt von del somelist[2], wird die zweite Anweisung tatsächlich gelöscht somelist[3].

Ich denke, ich könnte immer zuerst die höher nummerierten Elemente löschen, aber ich hoffe, es gibt einen besseren Weg.

Wahrscheinlich nicht die beste Lösung für dieses Problem:

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

Aus irgendeinem Grund mag ich keine der Antworten hier. Ja, sie funktionieren, aber genau genommen löschen die meisten von ihnen keine Elemente in einer Liste, oder? (Erstellen Sie jedoch eine Kopie und ersetzen Sie die Originalkopie durch die bearbeitete Kopie.)

Warum nicht einfach zuerst den höheren Index löschen?

Gibt es einen Grund dafür? Ich würde einfach tun:

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

Wenn Sie Elemente wirklich nicht rückwärts löschen möchten, sollten Sie die Indexwerte, die größer als der zuletzt gelöschte Index sind (Sie können nicht denselben Index verwenden, da Sie eine andere Liste haben), einfach inkrementieren oder verwenden eine Kopie der Liste (die nicht "löschen", sondern das Original durch eine bearbeitete Kopie ersetzen würde).

Vermisse ich hier etwas, einen Grund, NICHT in umgekehrter Reihenfolge zu löschen?

Wenn Sie mehrere nicht benachbarte Elemente löschen, ist das, was Sie beschreiben, der beste Weg (und ja, beginnen Sie unbedingt mit dem höchsten Index).

Wenn Ihre Elemente nebeneinander liegen, können Sie die Slice-Zuweisungssyntax verwenden:

a[2:10] = []

Sie können numpy.deletewie folgt verwenden:

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

Wenn es Ihnen nichts ausmacht, numpyam Ende ein Array zu haben, können Sie das weglassen .tolist(). Sie sollten auch einige ziemlich große Geschwindigkeitsverbesserungen sehen, was diese Lösung skalierbarer macht. Ich habe es nicht bewertet, aber numpyOperationen sind kompilierter Code, der entweder in C oder Fortran geschrieben ist.

Als Spezialisierung von Gregs Antwort können Sie sogar die erweiterte Slice-Syntax verwenden. z.B. Wenn Sie die Elemente 0 und 2 löschen möchten:

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

Dies deckt natürlich keine willkürliche Auswahl ab, kann aber durchaus zum Löschen von zwei beliebigen Elementen verwendet werden.

Als eine Funktion:

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

Läuft in n log (n) Zeit, was es zur schnellsten richtigen Lösung machen sollte.

Sie möchten also im Wesentlichen mehrere Elemente in einem Durchgang löschen? In diesem Fall wird die Position des nächsten zu löschenden Elements um die Anzahl der zuvor gelöschten Elemente versetzt.

Unser Ziel ist es, alle Vokale zu löschen, die als Indizes 1, 4 und 7 vorberechnet wurden. Beachten Sie, dass die to_delete-Indizes in aufsteigender Reihenfolge wichtig sind, da sie sonst nicht funktionieren.

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

Es wäre komplizierter, wenn Sie die Elemente in beliebiger Reihenfolge löschen möchten. IMO, das Sortieren ist to_deletemöglicherweise einfacher, als herauszufinden, wann Sie subtrahieren sollten oder nicht index.

Ich bin ein absoluter Anfänger in Python, und meine Programmierung ist im Moment, gelinde gesagt, grob und schmutzig, aber meine Lösung bestand darin, eine Kombination der grundlegenden Befehle zu verwenden, die ich in frühen Tutorials gelernt habe:

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

Dies hat natürlich seine Grenzen, da ein Zeichen zum Löschen markiert werden muss.

Was die Leistung angeht, da die Größe der Liste skaliert, bin ich sicher, dass meine Lösung nicht optimal ist. Es ist jedoch unkompliziert, was hoffentlich andere Anfänger anspricht, und funktioniert in einfachen Fällen, in denen some_listes ein bekanntes Format hat, z. B. immer numerisch ...

Hier ist eine Alternative, bei der enumerate () nicht zum Erstellen von Tupeln verwendet wird (wie in der ursprünglichen Antwort von SilentGhost).

Dies scheint mir lesbarer zu sein. (Vielleicht würde ich mich anders fühlen, wenn ich es gewohnt wäre, Aufzählungen zu verwenden.) CAVEAT: Ich habe die Leistung der beiden Ansätze nicht getestet.

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

HINWEIS: Python 2.7-Syntax. Für Python 3 xrange=>range .

Verwendung:

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

Somelist:

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

--- BONUS ---

Löschen Sie mehrere Werte aus einer Liste. Das heißt, wir haben die Werte, die wir löschen möchten:

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

Verwendung:

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

Somelist:

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

Dies ist die gleiche Antwort wie zuvor, aber diesmal haben wir die zu löschenden WERTE angegeben [0, 44, 55].

Eine alternative Methode zum Verständnis von Listen, die Listenindexwerte verwendet:

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]

Dies gibt zurück:

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

Hier ist eine andere Methode, mit der die Elemente entfernt werden. Auch wenn Ihre Liste wirklich lang ist, ist sie schneller.

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

Dies wurde erwähnt, aber irgendwie hat es niemand geschafft, es richtig zu machen.

Eine O(n)Lösung wäre:

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

Dies kommt der Version von SilentGhost sehr nahe , fügt jedoch zwei geschweifte Klammern hinzu.

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

Es ist im Grunde das Gleiche wie die am häufigsten gewählte Antwort, nur eine andere Art, sie zu schreiben. Beachten Sie, dass die Verwendung von l.index () keine gute Idee ist, da doppelte Elemente in einer Liste nicht verarbeitet werden können.

Die Methode "Entfernen" führt zu einer starken Verschiebung der Listenelemente. Ich denke, es ist besser, eine Kopie zu machen:

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

Technisch gesehen lautet die Antwort NEIN. Es ist nicht möglich, zwei Objekte gleichzeitig zu löschen. Es ist jedoch möglich, zwei Objekte in einer Zeile schöner Python zu löschen.

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

wird recusrively löschen foo['bar'], dannfoo['baz']

Wir können dies tun, indem wir eine for-Schleife verwenden, die über die Indizes iteriert, nachdem die Indexliste in absteigender Reihenfolge sortiert wurde

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

Für die Indizes 0 und 2 aus Liste A:

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

Für einige zufällige Indizes, die aus listA entfernt werden sollen:

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

Ich wollte einen Weg finden, die verschiedenen Lösungen zu vergleichen, die es einfach machten, die Knöpfe zu drehen.

Zuerst habe ich meine Daten generiert:

import random

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

Dann habe ich meine Funktionen definiert:

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)

Dann habe ich timeitdie Lösungen verglichen:

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)

Ausgabe

set =   1.711
del =   3.450
pop =   3.618

Der Generator mit den Indizes in a setwar also der Gewinner. Und delist dann etwas schneller pop.

Sie können diese Logik verwenden:

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

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

print c

Eine weitere Umsetzung der Idee, aus dem höchsten Index zu entfernen.

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

Ich kann mir zwei Möglichkeiten vorstellen:

1. Schneiden Sie die Liste wie folgt auf (dies löscht das 1., 3. und 8. Element)

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

2. Tun Sie das an Ort und Stelle, aber nacheinander:

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

Sie können dies auf einem Diktat tun, nicht auf einer Liste. In einer Liste sind die Elemente der Reihe nach. In einem Diktat hängen sie nur vom Index ab.

Einfacher Code, um es zu erklären, indem Sie Folgendes tun :

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

Eine Möglichkeit, eine Liste in ein Diktat zu "konvertieren", ist:

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

Das Gegenteil ist:

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

Wie auch immer, ich denke, es ist besser, mit dem Löschen aus dem höheren Index zu beginnen, wie Sie sagten.

Um den Kommentar von @sth zu verallgemeinern . Das Löschen von Elementen in jeder Klasse, die abc.MutableSequence implementiert , und listinsbesondere erfolgt über die __delitem__magische Methode. Diese Methode funktioniert ähnlich wie __getitem__, dh sie kann entweder eine Ganzzahl oder ein Slice akzeptieren. Hier ist ein Beispiel:

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)

Dies wird ausgegeben

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

Das Importieren nur aus diesem Grund ist möglicherweise übertrieben, aber wenn Sie es pandastrotzdem verwenden, ist die Lösung einfach und unkompliziert:

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

Vermeidet das Sortieren von Kosten und das explizite Kopieren der Liste.

Wie wäre es mit einem davon (ich bin sehr neu in Python, aber sie scheinen in Ordnung zu sein):

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)

['Atlantik', 'Pazifik', 'Indianer']

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)

['Atlantik', 'Pazifik', 'Indianer']

Keine der bisher angebotenen Antworten führt das Löschen in O (n) auf der Länge der Liste durch, damit eine beliebige Anzahl von Indizes gelöscht werden kann. Hier ist meine Version:

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]

Sie können auch remove verwenden.

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)

Ich habe alles zu einer list_diffFunktion zusammengefasst, die einfach zwei Listen als Eingaben verwendet und deren Differenz zurückgibt, wobei die ursprüngliche Reihenfolge der ersten Liste beibehalten wird.

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)

Beispielnutzung:

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