Duplikate aus einer Liste von Listen entfernen

Ich habe eine Liste von Listen in Python:

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

Und ich möchte doppelte Elemente daraus entfernen. War es eine normale Liste, nicht von Listen, die ich verwenden könnte set. Leider ist diese Liste nicht hashbar und kann keine Listen erstellen. Nur von Tupeln. So kann ich alle Listen in Tupel umwandeln und dann set und zurück zu Listen verwenden. Das geht aber nicht schnell.

Wie kann dies am effizientesten erfolgen?

Das Ergebnis der obigen Liste sollte sein:

k = [[5, 6, 2], [1, 2], [3], [4]]

Es ist mir egal, Ordnung zu bewahren.

Hinweis: Diese Frage ist ähnlich, aber nicht ganz das, was ich brauche. SO gesucht, aber kein genaues Duplikat gefunden.

Benchmarking:

import itertools, time


class Timer(object):
    def __init__(self, name=None):
        self.name = name

    def __enter__(self):
        self.tstart = time.time()

    def __exit__(self, type, value, traceback):
        if self.name:
            print '[%s]' % self.name,
        print 'Elapsed: %s' % (time.time() - self.tstart)


k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [5, 2], [6], [8], [9]] * 5
N = 100000

print len(k)

with Timer('set'):
    for i in xrange(N):
        kt = [tuple(i) for i in k]
        skt = set(kt)
        kk = [list(i) for i in skt]


with Timer('sort'):
    for i in xrange(N):
        ks = sorted(k)
        dedup = [ks[i] for i in xrange(len(ks)) if i == 0 or ks[i] != ks[i-1]]


with Timer('groupby'):
    for i in xrange(N):
        k = sorted(k)
        dedup = list(k for k, _ in itertools.groupby(k))

with Timer('loop in'):
    for i in xrange(N):
        new_k = []
        for elem in k:
            if elem not in new_k:
                new_k.append(elem)

"loop in" (quadratische Methode) am schnellsten für kurze Listen. Bei langen Listen ist es schneller als bei allen anderen, außer bei der Groupby-Methode. Macht das Sinn?

Für eine kurze Liste (die im Code) 100000 Iterationen:

[set] Elapsed: 1.3900001049
[sort] Elapsed: 0.891000032425
[groupby] Elapsed: 0.780999898911
[loop in] Elapsed: 0.578000068665

Für eine längere Liste (die im Code wurde 5 Mal dupliziert):

[set] Elapsed: 3.68700003624
[sort] Elapsed: 3.43799996376
[groupby] Elapsed: 1.03099989891
[loop in] Elapsed: 1.85900020599

>>> k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]
>>> import itertools
>>> k.sort()
>>> list(k for k,_ in itertools.groupby(k))
[[1, 2], [3], [4], [5, 6, 2]]

itertoolsoft bietet die schnellsten und leistungsstärksten Lösungen für diese Art von Problemen, und ist gut lohnt sich , mit bestens vertraut! -)

Bearbeiten : Wie ich in einem Kommentar erwähne, konzentrieren sich normale Optimierungsbemühungen auf große Eingaben (der Big-O-Ansatz), da dies so viel einfacher ist, dass es eine gute Rendite bietet. Aber manchmal (im Wesentlichen für "tragisch entscheidende Engpässe" in tiefen inneren Codeschleifen, die die Grenzen von Leistungsgrenzen überschreiten) muss man möglicherweise viel detaillierter vorgehen, Wahrscheinlichkeitsverteilungen bereitstellen und entscheiden, welche Leistungsmaße optimiert werden sollen (möglicherweise die Obergrenze oder Das 90. Zentil ist wichtiger als ein Durchschnitt oder Median, abhängig von den eigenen Apps. Es führt zu Beginn möglicherweise heuristische Überprüfungen durch, um je nach den Eigenschaften der Eingabedaten unterschiedliche Algorithmen auszuwählen.

Sorgfältige Messungen der "Punkt" -Leistung (Code A gegenüber Code B für eine bestimmte Eingabe) sind Teil dieses äußerst kostspieligen Prozesses, und das Standardbibliotheksmodul timeithilft hier. Es ist jedoch einfacher, es an einer Shell-Eingabeaufforderung zu verwenden. Im Folgenden finden Sie ein kurzes Modul, in dem der allgemeine Ansatz für dieses Problem vorgestellt wird. Speichern Sie es wie folgt nodup.py:

import itertools

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

def doset(k, map=map, list=list, set=set, tuple=tuple):
  return map(list, set(map(tuple, k)))

def dosort(k, sorted=sorted, xrange=xrange, len=len):
  ks = sorted(k)
  return [ks[i] for i in xrange(len(ks)) if i == 0 or ks[i] != ks[i-1]]

def dogroupby(k, sorted=sorted, groupby=itertools.groupby, list=list):
  ks = sorted(k)
  return [i for i, _ in itertools.groupby(ks)]

def donewk(k):
  newk = []
  for i in k:
    if i not in newk:
      newk.append(i)
  return newk

# sanity check that all functions compute the same result and don't alter k
if __name__ == '__main__':
  savek = list(k)
  for f in doset, dosort, dogroupby, donewk:
    resk = f(k)
    assert k == savek
    print '%10s %s' % (f.__name__, sorted(resk))

Beachten Sie die Überprüfung der geistigen Gesundheit (wird durchgeführt, wenn Sie dies gerade tun python nodup.py) und die grundlegende Hebetechnik (machen Sie konstante globale Namen für jede Funktion lokal, um die Geschwindigkeit zu erhöhen), um die Dinge gleichberechtigt zu machen.

Jetzt können wir die winzige Beispielliste überprüfen:

$ python -mtimeit -s'import nodup' 'nodup.doset(nodup.k)'
100000 loops, best of 3: 11.7 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.dosort(nodup.k)'
100000 loops, best of 3: 9.68 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.dogroupby(nodup.k)'
100000 loops, best of 3: 8.74 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.donewk(nodup.k)'
100000 loops, best of 3: 4.44 usec per loop

Bestätigung, dass der quadratische Ansatz klein genug ist, um für kleine Listen mit wenigen doppelten Werten attraktiv zu sein. Mit einer kurzen Liste ohne Duplikate:

$ python -mtimeit -s'import nodup' 'nodup.donewk([[i] for i in range(12)])'
10000 loops, best of 3: 25.4 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.dogroupby([[i] for i in range(12)])'
10000 loops, best of 3: 23.7 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.doset([[i] for i in range(12)])'
10000 loops, best of 3: 31.3 usec per loop
$ python -mtimeit -s'import nodup' 'nodup.dosort([[i] for i in range(12)])'
10000 loops, best of 3: 25 usec per loop

Der quadratische Ansatz ist nicht schlecht, aber die Sortierung und die Gruppierung sind besser. Usw. usw.

Wenn sich diese Operation (wie die Besessenheit von der Leistung nahelegt) in einer inneren Kernschleife Ihrer Anwendung zum Überschreiten der Grenzen befindet, lohnt es sich, die gleichen Tests an anderen repräsentativen Eingabebeispielen durchzuführen, um möglicherweise eine einfache Maßnahme zu ermitteln, die Sie heuristisch zulassen könnte Wählen Sie den einen oder anderen Ansatz (aber die Maßnahme muss natürlich schnell sein).

Es lohnt sich auch, eine andere Darstellung beizubehalten k- warum muss es sich überhaupt um eine Liste von Listen und nicht um eine Reihe von Tupeln handeln? Wenn die Aufgabe zum Entfernen von Duplikaten häufig ist und die Profilerstellung zeigt, dass es sich um den Leistungsengpass des Programms handelt, kann es beispielsweise insgesamt schneller sein, ständig eine Reihe von Tupeln beizubehalten und nur dann eine Liste von Listen abzurufen, wenn und wo dies erforderlich ist.

Manuell ausführen, eine neue kListe erstellen und Einträge hinzufügen, die bisher nicht gefunden wurden:

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]
new_k = []
for elem in k:
    if elem not in new_k:
        new_k.append(elem)
k = new_k
print k
# prints [[1, 2], [4], [5, 6, 2], [3]]

Einfach zu verstehen, und Sie behalten die Reihenfolge des ersten Auftretens jedes Elements bei, sollte dies nützlich sein, aber ich denke, die Komplexität ist quadratisch, wenn Sie das gesamte new_kElement nach jedem Element durchsuchen .

>>> k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]
>>> k = sorted(k)
>>> k
[[1, 2], [1, 2], [3], [4], [4], [5, 6, 2]]
>>> dedup = [k[i] for i in range(len(k)) if i == 0 or k[i] != k[i-1]]
>>> dedup
[[1, 2], [3], [4], [5, 6, 2]]

Ich weiß nicht, ob es unbedingt schneller ist, aber Sie müssen Tupel und Sets nicht verwenden.

Für alle setbisherigen Lösungen für dieses Problem muss setvor der Iteration ein Ganzes erstellt werden.

Es ist möglich, dies faul zu machen und gleichzeitig die Reihenfolge beizubehalten, indem die Liste der Listen iteriert und zu einem "Gesehenen" hinzugefügt wird set. Geben Sie dann nur dann eine Liste aus, wenn diese in diesem Tracker nicht gefunden wird set.

Dieses unique_everseenRezept ist in den itertools Dokumenten verfügbar . Es ist auch in der toolzBibliothek von Drittanbietern verfügbar :

from toolz import unique

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

# lazy iterator
res = map(list, unique(map(tuple, k)))

print(list(res))

[[1, 2], [4], [5, 6, 2], [3]]

Beachten Sie, dass eine tupleKonvertierung erforderlich ist, da Listen nicht hashbar sind.

Sogar Ihre "lange" Liste ist ziemlich kurz. Haben Sie sie auch so ausgewählt, dass sie mit den tatsächlichen Daten übereinstimmen? Die Leistung hängt davon ab, wie diese Daten tatsächlich aussehen. Beispielsweise wird eine kurze Liste immer wieder wiederholt, um eine längere Liste zu erstellen. Dies bedeutet, dass die quadratische Lösung in Ihren Benchmarks linear ist, in der Realität jedoch nicht.

Für tatsächlich große Listen ist der festgelegte Code die beste Wahl - er ist linear (obwohl platzhungrig). Die Sortier- und Groupby-Methoden sind O (n log n) und die Schleife in der Methode ist offensichtlich quadratisch, sodass Sie wissen, wie diese skaliert werden, wenn n wirklich groß wird. Wenn dies die tatsächliche Größe der Daten ist, die Sie analysieren, wen interessiert das dann? Es ist winzig.

Übrigens sehe ich eine spürbare Beschleunigung, wenn ich keine Zwischenliste für die Erstellung des Sets bilde, dh wenn ich ersetze

kt = [tuple(i) for i in k]
skt = set(kt)

mit

skt = set(tuple(i) for i in k)

Die wirkliche Lösung kann von weiteren Informationen abhängen: Sind Sie sicher, dass eine Liste von Listen wirklich die Darstellung ist, die Sie benötigen?

Die Liste der Tupel und {} kann verwendet werden, um Duplikate zu entfernen

>>> [list(tupl) for tupl in {tuple(item) for item in k }]
[[1, 2], [5, 6, 2], [3], [4]]
>>> 

Erstellen Sie ein Wörterbuch mit Tupel als Schlüssel und drucken Sie die Schlüssel.

• Erstellen Sie ein Wörterbuch mit Tupel als Schlüssel und Index als Wert
• Liste der Schlüssel des Wörterbuchs drucken

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

dict_tuple = {tuple(item): index for index, item in enumerate(k)}

print [list(itm) for itm in dict_tuple.keys()]

# prints [[1, 2], [5, 6, 2], [3], [4]]

Das sollte funktionieren.

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

k_cleaned = []
for ele in k:
    if set(ele) not in [set(x) for x in k_cleaned]:
        k_cleaned.append(ele)
print(k_cleaned)

# output: [[1, 2], [4], [5, 6, 2], [3]]

Seltsamerweise entfernen die obigen Antworten die 'Duplikate', aber was ist, wenn ich den duplizierten Wert auch entfernen möchte? Das Folgende sollte nützlich sein und erstellt kein neues Objekt im Speicher!

def dictRemoveDuplicates(self):
    a=[[1,'somevalue1'],[1,'somevalue2'],[2,'somevalue1'],[3,'somevalue4'],[5,'somevalue5'],[5,'somevalue1'],[5,'somevalue1'],[5,'somevalue8'],[6,'somevalue9'],[6,'somevalue0'],[6,'somevalue1'],[7,'somevalue7']]


print(a)
temp = 0
position = -1
for pageNo, item in a:
    position+=1
    if pageNo != temp:
        temp = pageNo
        continue
    else:
        a[position] = 0
        a[position - 1] = 0
a = [x for x in a if x != 0]         
print(a)

und das o / p ist:

[[1, 'somevalue1'], [1, 'somevalue2'], [2, 'somevalue1'], [3, 'somevalue4'], [5, 'somevalue5'], [5, 'somevalue1'], [5, 'somevalue1'], [5, 'somevalue8'], [6, 'somevalue9'], [6, 'somevalue0'], [6, 'somevalue1'], [7, 'somevalue7']]
[[2, 'somevalue1'], [3, 'somevalue4'], [7, 'somevalue7']]

Eine andere wahrscheinlich allgemeinere und einfachere Lösung besteht darin, ein Wörterbuch zu erstellen, das von der Zeichenfolgenversion der Objekte verschlüsselt wird, und am Ende die Werte () abzurufen:

>>> dict([(unicode(a),a) for a in [["A", "A"], ["A", "A"], ["A", "B"]]]).values()
[['A', 'B'], ['A', 'A']]

Der Haken ist, dass dies nur für Objekte funktioniert, deren Zeichenfolgendarstellung ein ausreichend eindeutiger Schlüssel ist (was für die meisten nativen Objekte gilt).