आप उपयोग कर सकते हैं iteration_utilities.duplicates:
>>> from iteration_utilities import duplicates
>>> list(duplicates([1,1,2,1,2,3,4,2]))
[1, 1, 2, 2]
या यदि आप केवल प्रत्येक डुप्लिकेट में से एक चाहते हैं तो इसे इसके साथ जोड़ा जा सकता है iteration_utilities.unique_everseen:
>>> from iteration_utilities import unique_everseen
>>> list(unique_everseen(duplicates([1,1,2,1,2,3,4,2])))
[1, 2]
यह अस्वास्थ्यकर तत्वों को भी संभाल सकता है (हालांकि प्रदर्शन की कीमत पर):
>>> list(duplicates([[1], [2], [1], [3], [1]]))
[[1], [1]]
>>> list(unique_everseen(duplicates([[1], [2], [1], [3], [1]])))
[[1]]
यह कुछ ऐसा है जो केवल कुछ अन्य दृष्टिकोणों को यहां संभाल सकते हैं।
मानक
मैंने यहां वर्णित दृष्टिकोणों का एक त्वरित बेंचमार्क किया, जिसमें अधिकांश (लेकिन सभी नहीं) थे।
पहले बेंचमार्क में केवल सूची-लंबाई की एक छोटी श्रृंखला शामिल थी क्योंकि कुछ दृष्टिकोणों में O(n**2)व्यवहार होता है।
रेखांकन में y- अक्ष समय का प्रतिनिधित्व करता है, इसलिए कम मूल्य का मतलब बेहतर है। यह लॉग-लॉग भी प्लॉट किया गया है ताकि मूल्यों की विस्तृत श्रृंखला को बेहतर तरीके से देखा जा सके:
O(n**2)एप्रोच को हटाते हुए मैंने एक और बेंचमार्क एक सूची में आधे मिलियन तत्वों तक किया:
जैसा कि आप देख सकते हैं कि iteration_utilities.duplicatesदृष्टिकोण किसी भी अन्य दृष्टिकोण unique_everseen(duplicates(...))से तेज है और यहां तक कि जंजीर अन्य दृष्टिकोणों की तुलना में तेज या समान रूप से तेज है।
यहां ध्यान देने वाली एक और दिलचस्प बात यह है कि छोटी सूचियों के लिए पांडा के दृष्टिकोण बहुत धीमे होते हैं, लेकिन आसानी से लंबी सूची के लिए प्रतिस्पर्धा कर सकते हैं।
हालाँकि जैसा कि ये बेंचमार्क दिखाते हैं कि अधिकांश दृष्टिकोण समान रूप से प्रदर्शन करते हैं, इसलिए यह बहुत ज्यादा मायने नहीं रखता है कि कौन सा उपयोग किया जाता है (3 के अलावा जो O(n**2)रनटाइम था )।
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)))
बेंचमार्क 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()
बेंचमार्क 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()
अस्वीकरण
1 यह एक तीसरे पक्ष के पुस्तकालय से है जिसे मैंने लिखा है iteration_utilities:।