Sie können verwenden iteration_utilities.duplicates
:
>>> from iteration_utilities import duplicates
>>> list(duplicates([1,1,2,1,2,3,4,2]))
[1, 1, 2, 2]
oder, wenn Sie nur ein Duplikat von jedem wünschen, kann dies mit iteration_utilities.unique_everseen
:
>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]
Es kann auch mit nicht verschlüsselbaren Elementen umgehen (allerdings auf Kosten der Leistung):
>>> list(duplicates([[1], [2], [1], [3], [1]]))
[[1], [1]]
>>> list(unique_everseen(duplicates([[1], [2], [1], [3], [1]])))
[[1]]
Das ist etwas, was nur wenige der anderen Ansätze hier leisten können.
Benchmarks
Ich habe einen schnellen Benchmark durchgeführt, der die meisten (aber nicht alle) der hier genannten Ansätze enthält.
Der erste Benchmark umfasste nur einen kleinen Bereich von Listenlängen, da einige Ansätze O(n**2)
Verhalten.
In den Diagrammen stellt die y-Achse die Zeit dar, d. h. ein niedrigerer Wert bedeutet besser. Sie ist auch log-logarithmisch dargestellt, damit die große Bandbreite der Werte besser sichtbar wird:
Das Entfernen der O(n**2)
Ich habe einen weiteren Benchmark mit bis zu einer halben Million Elementen in einer Liste durchgeführt:
Wie Sie sehen können, ist die iteration_utilities.duplicates
Ansatz ist schneller als alle anderen Ansätze und sogar die Verkettung von unique_everseen(duplicates(...))
schneller oder gleich schnell war als die anderen Ansätze.
Interessant ist auch, dass die Pandas bei kleinen Listen sehr langsam sind, bei längeren Listen aber problemlos mithalten können.
Wie diese Benchmarks jedoch zeigen, schneiden die meisten Ansätze in etwa gleich gut ab, so dass es keine große Rolle spielt, welcher Ansatz verwendet wird (mit Ausnahme der 3 Ansätze, bei denen O(n**2)
Laufzeit).
from iteration_utilities import duplicates, unique_everseen
from collections import Counter
import pandas as pd
import itertools
def georg_counter(it):
return [item for item, count in Counter(it).items() if count > 1]
def georg_set(it):
seen = set()
uniq = []
for x in it:
if x not in seen:
uniq.append(x)
seen.add(x)
def georg_set2(it):
seen = set()
return [x for x in it if x not in seen and not seen.add(x)]
def georg_set3(it):
seen = {}
dupes = []
for x in it:
if x not in seen:
seen[x] = 1
else:
if seen[x] == 1:
dupes.append(x)
seen[x] += 1
def RiteshKumar_count(l):
return set([x for x in l if l.count(x) > 1])
def moooeeeep(seq):
seen = set()
seen_add = seen.add
# adds all elements it doesn't know yet to seen and all other to seen_twice
seen_twice = set( x for x in seq if x in seen or seen_add(x) )
# turn the set into a list (as requested)
return list( seen_twice )
def F1Rumors_implementation(c):
a, b = itertools.tee(sorted(c))
next(b, None)
r = None
for k, g in zip(a, b):
if k != g: continue
if k != r:
yield k
r = k
def F1Rumors(c):
return list(F1Rumors_implementation(c))
def Edward(a):
d = {}
for elem in a:
if elem in d:
d[elem] += 1
else:
d[elem] = 1
return [x for x, y in d.items() if y > 1]
def wordsmith(a):
return pd.Series(a)[pd.Series(a).duplicated()].values
def NikhilPrabhu(li):
li = li.copy()
for x in set(li):
li.remove(x)
return list(set(li))
def firelynx(a):
vc = pd.Series(a).value_counts()
return vc[vc > 1].index.tolist()
def HenryDev(myList):
newList = set()
for i in myList:
if myList.count(i) >= 2:
newList.add(i)
return list(newList)
def yota(number_lst):
seen_set = set()
duplicate_set = set(x for x in number_lst if x in seen_set or seen_set.add(x))
return seen_set - duplicate_set
def IgorVishnevskiy(l):
s=set(l)
d=[]
for x in l:
if x in s:
s.remove(x)
else:
d.append(x)
return d
def it_duplicates(l):
return list(duplicates(l))
def it_unique_duplicates(l):
return list(unique_everseen(duplicates(l)))
Zielvorgabe 1
from simple_benchmark import benchmark
import random
funcs = [
georg_counter, georg_set, georg_set2, georg_set3, RiteshKumar_count, moooeeeep,
F1Rumors, Edward, wordsmith, NikhilPrabhu, firelynx,
HenryDev, yota, IgorVishnevskiy, it_duplicates, it_unique_duplicates
]
args = {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(2, 12)}
b = benchmark(funcs, args, 'list size')
b.plot()
Benchmark 2
funcs = [
georg_counter, georg_set, georg_set2, georg_set3, moooeeeep,
F1Rumors, Edward, wordsmith, firelynx,
yota, IgorVishnevskiy, it_duplicates, it_unique_duplicates
]
args = {2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(2, 20)}
b = benchmark(funcs, args, 'list size')
b.plot()
Haftungsausschluss
1 Dies stammt aus einer Bibliothek eines Drittanbieters, die ich geschrieben habe: iteration_utilities
.
2 Stimmen
Mögliche Duplikate von Wie entfernt man Duplikate aus einer Liste in Python unter Beibehaltung der Reihenfolge?
3 Stimmen
Wollen Sie die Duplikate einmalig oder jedes Mal, wenn sie wieder gesehen werden?
0 Stimmen
Ich denke, diese Frage wurde hier bereits sehr viel effizienter beantwortet. stackoverflow.com/a/642919/1748045 Schnittpunkt ist eine eingebaute Methode von set und sollte genau das tun, was erforderlich ist