Şunları kullanabilirsiniz iteration_utilities.duplicates:
>>> from iteration_utilities import duplicates
>>> list(duplicates([1,1,2,1,2,3,4,2]))
[1, 1, 2, 2]
veya her bir kopyadan yalnızca birini istiyorsanız, bu aşağıdakilerle birleştirilebilir iteration_utilities.unique_everseen:
>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]
Ayrıca, paylaşılamayan öğeleri de işleyebilir (ancak performans pahasına):
>>> list(duplicates([[1], [2], [1], [3], [1]]))
[[1], [1]]
>>> list(unique_everseen(duplicates([[1], [2], [1], [3], [1]])))
[[1]]
Bu, buradaki diğer yaklaşımların sadece birkaçının üstesinden gelebileceği bir şey.
Deneyler
Burada bahsedilen yaklaşımların çoğunu (ancak hepsini değil) içeren hızlı bir karşılaştırma yaptım.
İlk karşılaştırma ölçütü sadece küçük bir liste uzunluğu aralığı içermekteydi, çünkü bazı yaklaşımların O(n**2)davranışları vardır.
Grafiklerde y ekseni zamanı temsil eder, bu nedenle daha düşük bir değer daha iyi anlamına gelir. Ayrıca, geniş bir değer aralığı daha iyi görüntülenebilmesi için günlük günlüğü olarak çizilir:
O(n**2)Yaklaşımları kaldırarak bir listede yarım milyon öğeye kadar başka bir karşılaştırma yaptım:
Gördüğünüz gibi iteration_utilities.duplicatesyaklaşım diğer yaklaşımlardan unique_everseen(duplicates(...))daha hızlı ve zincirleme bile diğer yaklaşımlardan daha hızlı veya eşit derecede hızlıydı.
Burada dikkat edilmesi gereken bir başka ilginç şey de panda yaklaşımlarının küçük listeler için çok yavaş olması ancak daha uzun listeler için kolayca rekabet edebilmesidir.
Bununla birlikte, bu kriterler yaklaşımların çoğunun kabaca eşit performans gösterdiğinden, hangisinin kullanıldığının pek önemi yoktur ( O(n**2)çalışma zamanı olan 3 hariç ).
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)))
Deney 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()
Deney 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()
feragat
1 Bu yazdım bir üçüncü taraf kitaplığından geçerli: iteration_utilities.