दिलचस्प पोस्ट
ड्रॉपडाउन तीर को हटाने का चयन करें SASS: बेतरतीब ढंग से एक सूची से पृष्ठभूमि छवि उठाओ एमएस एक्सेल के लिए JSON प्रारूप को सीएसवी प्रारूप में कनवर्ट करें JProgressBar प्रगति नहीं कर रहा है Virtualenv के साथ विभिन्न पायथन संस्करण का उपयोग करें JSP के साथ यूआरएल से मापदंड कैसे प्राप्त करें सीमा-आधारित छोरों में सार्वभौमिक संदर्भों का उपयोग करने का क्या लाभ है? IIS8 में IIS_IUSRS और IUSR अनुमतियाँ एक वाईएक्स कस्टम क्रिया कैसे जोड़ती है जो केवल अनइंस्टॉलन पर होती है (एमएसआई के माध्यम से)? एंड्रॉइड में यूआरआई बिल्डर का प्रयोग करें या चर के साथ यूआरएल बनाएं क्या यह गिनती की तुलना में नीचे गिनती तेज है? जावा में कीवर्ड "यह" का प्रयोग करना विंडोज पर पायथन 2. एक्स में कमांड-लाइन आर्गुमेंट्स से यूनिकोड वर्ण पढ़ें ओपेसीवी में एक छवि कैसे तेज करें? केंद्र क्षैतिज रूप से div के भीतर छवि संरेखित करें

किसी सूची में डुप्लिकेट ढूंढें और सूचीबद्ध करें?

मैं डुप्लिकेट को पायथन सूची में कैसे प्राप्त कर सकता हूं और डुप्लिकेट की दूसरी सूची कैसे बना सकता हूं? सूची केवल पूर्णांक है

वेब के समाधान से एकत्रित समाधान "किसी सूची में डुप्लिकेट ढूंढें और सूचीबद्ध करें?"

डुप्लिकेट निकालने के लिए डुप्लिकेट प्रिंट करने के लिए set(a) उपयोग करें – ऐसा कुछ

 a = [1,2,3,2,1,5,6,5,5,5] import collections print [item for item, count in collections.Counter(a).items() if count > 1] ## [1, 2, 5] 

ध्यान दें कि Counter विशेष रूप से कुशल नहीं है ( समय ) और संभवत: यहाँ एक ओवरकिल, set बेहतर प्रदर्शन करेगा:

 seen = set() uniq = [] for x in a: if x not in seen: uniq.append(x) seen.add(x) 

या, अधिक संक्षिप्त रूप से:

 seen = set() uniq = [x for x in a if x not in seen and not seen.add(x)] 

मैं बाद की शैली की अनुशंसा नहीं करता, क्योंकि यह स्पष्ट नहीं है जो not seen.add(x) कर रहा है (सेट add() विधि हमेशा None रिटर्न None देता है, इसलिए None की आवश्यकता है)।

अगर सूची तत्व हटेबल नहीं हैं, तो आप सेट / डिकट का उपयोग नहीं कर सकते हैं और एक द्विघात समय समाधान का उपयोग कर सकते हैं (प्रत्येक की तुलना करें), उदाहरण के लिए:

 a = [ [1], [2], [3], [1], [5], [3] ] no_dupes = [x for n, x in enumerate(a) if x not in a[:n]] print no_dupes # [[1], [2], [3], [5]] dupes = [x for n, x in enumerate(a) if x in a[:n]] print dupes # [[1], [3]] 
 >>> l = [1,2,3,4,4,5,5,6,1] >>> set([x for x in l if l.count(x) > 1]) set([1, 4, 5]) 

आपको गिनती की ज़रूरत नहीं है, चाहे वह आइटम पहले भी देखा गया था या नहीं। इस समस्या का उत्तर दिया गया है:

 def list_duplicates(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 ) a = [1,2,3,2,1,5,6,5,5,5] list_duplicates(a) # yields [1, 2, 5] 

बस के मामले में गति मामलों, यहाँ कुछ समय हैं:

 # file: test.py import collections def thg435(l): return [x for x, y in collections.Counter(l).items() if y > 1] def moooeeeep(l): 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 l if x in seen or seen_add(x) ) # turn the set into a list (as requested) return list( seen_twice ) def RiteshKumar(l): return list(set([x for x in l if l.count(x) > 1])) def JohnLaRooy(L): seen = set() seen2 = set() seen_add = seen.add seen2_add = seen2.add for item in L: if item in seen: seen2_add(item) else: seen_add(item) return list(seen2) l = [1,2,3,2,1,5,6,5,5,5]*100 

यहां परिणाम दिए गए हैं: (अच्छी तरह से किया @ जॉन रोआय!)

 $ python -mtimeit -s 'import test' 'test.JohnLaRooy(test.l)' 10000 loops, best of 3: 74.6 usec per loop $ python -mtimeit -s 'import test' 'test.moooeeeep(test.l)' 10000 loops, best of 3: 91.3 usec per loop $ python -mtimeit -s 'import test' 'test.thg435(test.l)' 1000 loops, best of 3: 266 usec per loop $ python -mtimeit -s 'import test' 'test.RiteshKumar(test.l)' 100 loops, best of 3: 8.35 msec per loop 

दिलचस्प बात यह है कि समय के अलावा, रैंकिंग में थोड़ा बदलाव होता है जब पीयपी का इस्तेमाल होता है। सबसे दिलचस्प बात, काउंटर-आधारित दृष्टिकोण पीयपी के ऑप्टिमाइज़ेशन से बेहद लाभान्वित करते हैं, जबकि विधि कैशिंग दृष्टिकोण जो मैंने सुझाया है लगभग कोई प्रभाव नहीं लगता है

 $ pypy -mtimeit -s 'import test' 'test.JohnLaRooy(test.l)' 100000 loops, best of 3: 17.8 usec per loop $ pypy -mtimeit -s 'import test' 'test.thg435(test.l)' 10000 loops, best of 3: 23 usec per loop $ pypy -mtimeit -s 'import test' 'test.moooeeeep(test.l)' 10000 loops, best of 3: 39.3 usec per loop 

उपयुक्त रूप से यह प्रभाव इनपुट डेटा के "डुप्लिकेटनेस" से संबंधित है। मैंने l = [random.randrange(1000000) for i in xrange(10000)] सेट किया है और इन परिणामों को प्राप्त किया है:

 $ pypy -mtimeit -s 'import test' 'test.moooeeeep(test.l)' 1000 loops, best of 3: 495 usec per loop $ pypy -mtimeit -s 'import test' 'test.JohnLaRooy(test.l)' 1000 loops, best of 3: 499 usec per loop $ pypy -mtimeit -s 'import test' 'test.thg435(test.l)' 1000 loops, best of 3: 1.68 msec per loop 

मैं इस सवाल पर आया जब कुछ संबंधित में देख रहा था – और आश्चर्य क्यों कोई भी एक जनरेटर आधारित समाधान की पेशकश की? इस समस्या का समाधान करना होगा:

 >>> print list(getDupes_9([1,2,3,2,1,5,6,5,5,5])) [1, 2, 5] 

मुझे स्केलेबिलिटी के बारे में चिंतित था, ऐसे में कई तरीकों का परीक्षण किया गया था, जिसमें छद्म वस्तुओं को शामिल किया गया था, जो छोटी सूचियों पर अच्छी तरह से काम करते हैं, लेकिन बुरी तरह पैमाने पर सूचियों के रूप में बड़ा हो जाता है (नोट- समय का उपयोग करने के लिए बेहतर होता, लेकिन यह स्पष्ट है)।

मैंने तुलना के लिए मोहूईईप को शामिल किया था (यह प्रभावशाली रूप से तेज़ है: अगर इनपुट सूची पूरी तरह से यादृच्छिक होती है तो सबसे तेज़ है) और एक इटरेटोल्स दृष्टिकोण जो अधिकतर सॉर्ट किए गए सूचियों के लिए फिर से तेज़ हो … अब फ्रैंलीएनएक्स से धीमी गति से पंडस दृष्टिकोण शामिल है, लेकिन नहीं बहुत ही, और सरल नोट – सॉर्ट / टी / ज़िप पद्धति मेरे मशीन पर बड़े पैमाने पर अधिकतर क्रमबद्ध सूचियों के लिए सबसे तेज है, मूओइप शफ़ल सूची के लिए सबसे तेज़ है, लेकिन आपका माइलेज अलग-अलग हो सकता है

लाभ

  • एक ही कोड का उपयोग करते हुए 'किसी भी' डुप्लिकेट के लिए परीक्षण करने के लिए बहुत आसान सरल

मान्यताओं

  • डुप्लिकेट केवल एक बार सूचित किए जाने चाहिए
  • डुप्लिकेट ऑर्डर को संरक्षित करने की आवश्यकता नहीं है
  • डुप्लिकेट सूची में कहीं भी हो सकता है

सबसे तेज़ समाधान, 1 एम प्रविष्टियां:

 def getDupes(c): '''sort/tee/izip''' a, b = itertools.tee(sorted(c)) next(b, None) r = None for k, g in itertools.izip(a, b): if k != g: continue if k != r: yield k r = k 

दृष्टिकोण का परीक्षण

 import itertools import time import random def getDupes_1(c): '''naive''' for i in xrange(0, len(c)): if c[i] in c[:i]: yield c[i] def getDupes_2(c): '''set len change''' s = set() for i in c: l = len(s) s.add(i) if len(s) == l: yield i def getDupes_3(c): '''in dict''' d = {} for i in c: if i in d: if d[i]: yield i d[i] = False else: d[i] = True def getDupes_4(c): '''in set''' s,r = set(),set() for i in c: if i not in s: s.add(i) elif i not in r: r.add(i) yield i def getDupes_5(c): '''sort/adjacent''' c = sorted(c) r = None for i in xrange(1, len(c)): if c[i] == c[i - 1]: if c[i] != r: yield c[i] r = c[i] def getDupes_6(c): '''sort/groupby''' def multiple(x): try: x.next() x.next() return True except: return False for k, g in itertools.ifilter(lambda x: multiple(x[1]), itertools.groupby(sorted(c))): yield k def getDupes_7(c): '''sort/zip''' c = sorted(c) r = None for k, g in zip(c[:-1],c[1:]): if k == g: if k != r: yield k r = k def getDupes_8(c): '''sort/izip''' c = sorted(c) r = None for k, g in itertools.izip(c[:-1],c[1:]): if k == g: if k != r: yield k r = k def getDupes_9(c): '''sort/tee/izip''' a, b = itertools.tee(sorted(c)) next(b, None) r = None for k, g in itertools.izip(a, b): if k != g: continue if k != r: yield k r = k def getDupes_a(l): '''moooeeeep''' seen = set() seen_add = seen.add # adds all elements it doesn't know yet to seen and all other to seen_twice for x in l: if x in seen or seen_add(x): yield x def getDupes_b(x): '''iter*/sorted''' x = sorted(x) def _matches(): for k,g in itertools.izip(x[:-1],x[1:]): if k == g: yield k for k, n in itertools.groupby(_matches()): yield k def getDupes_c(a): '''pandas''' import pandas as pd vc = pd.Series(a).value_counts() i = vc[vc > 1].index for _ in i: yield _ def hasDupes(fn,c): try: if fn(c).next(): return True # Found a dupe except StopIteration: pass return False def getDupes(fn,c): return list(fn(c)) STABLE = True if STABLE: print 'Finding FIRST then ALL duplicates, single dupe of "nth" placed element in 1m element array' else: print 'Finding FIRST then ALL duplicates, single dupe of "n" included in randomised 1m element array' for location in (50,250000,500000,750000,999999): for test in (getDupes_2, getDupes_3, getDupes_4, getDupes_5, getDupes_6, getDupes_8, getDupes_9, getDupes_a, getDupes_b, getDupes_c): print 'Test %-15s:%10d - '%(test.__doc__ or test.__name__,location), deltas = [] for FIRST in (True,False): for i in xrange(0, 5): c = range(0,1000000) if STABLE: c[0] = location else: c.append(location) random.shuffle(c) start = time.time() if FIRST: print '.' if location == test(c).next() else '!', else: print '.' if [location] == list(test(c)) else '!', deltas.append(time.time()-start) print ' -- %0.3f '%(sum(deltas)/len(deltas)), print print 

'सभी डूप्स' टेस्ट के परिणाम संगत थे, "पहले" डुप्लिकेट खोजने के बाद इस सरणी में "सभी" डुप्लिकेट:

 Finding FIRST then ALL duplicates, single dupe of "nth" placed element in 1m element array Test set len change : 500000 - . . . . . -- 0.264 . . . . . -- 0.402 Test in dict : 500000 - . . . . . -- 0.163 . . . . . -- 0.250 Test in set : 500000 - . . . . . -- 0.163 . . . . . -- 0.249 Test sort/adjacent : 500000 - . . . . . -- 0.159 . . . . . -- 0.229 Test sort/groupby : 500000 - . . . . . -- 0.860 . . . . . -- 1.286 Test sort/izip : 500000 - . . . . . -- 0.165 . . . . . -- 0.229 Test sort/tee/izip : 500000 - . . . . . -- 0.145 . . . . . -- 0.206 * Test moooeeeep : 500000 - . . . . . -- 0.149 . . . . . -- 0.232 Test iter*/sorted : 500000 - . . . . . -- 0.160 . . . . . -- 0.221 Test pandas : 500000 - . . . . . -- 0.493 . . . . . -- 0.499 

जब सूचियों को पहले फेरबदल किया जाता है, तो इस प्रकार की कीमत स्पष्ट हो जाती है – दक्षता का ध्यान आकर्षित हो जाता है और @ एमओइआईपिप दृष्टिकोण हावी हो जाता है, सेट और डिक्ट दृष्टिकोण के समान, लेकिन पट्टादाता कलाकारों के साथ:

 Finding FIRST then ALL duplicates, single dupe of "n" included in randomised 1m element array Test set len change : 500000 - . . . . . -- 0.321 . . . . . -- 0.473 Test in dict : 500000 - . . . . . -- 0.285 . . . . . -- 0.360 Test in set : 500000 - . . . . . -- 0.309 . . . . . -- 0.365 Test sort/adjacent : 500000 - . . . . . -- 0.756 . . . . . -- 0.823 Test sort/groupby : 500000 - . . . . . -- 1.459 . . . . . -- 1.896 Test sort/izip : 500000 - . . . . . -- 0.786 . . . . . -- 0.845 Test sort/tee/izip : 500000 - . . . . . -- 0.743 . . . . . -- 0.804 Test moooeeeep : 500000 - . . . . . -- 0.234 . . . . . -- 0.311 * Test iter*/sorted : 500000 - . . . . . -- 0.776 . . . . . -- 0.840 Test pandas : 500000 - . . . . . -- 0.539 . . . . . -- 0.540 

संग्रह। काउंटर अजगर 2.7 में नया है:

 Python 2.5.4 (r254:67916, May 31 2010, 15:03:39) [GCC 4.1.2 20080704 (Red Hat 4.1.2-46)] on linux2 a = [1,2,3,2,1,5,6,5,5,5] import collections print [x for x, y in collections.Counter(a).items() if y > 1] Type "help", "copyright", "credits" or "license" for more information. File "", line 1, in AttributeError: 'module' object has no attribute 'Counter' >>> 

पहले के संस्करण में आप इसके बजाय एक पारंपरिक शब्दकोश का उपयोग कर सकते हैं:

 a = [1,2,3,2,1,5,6,5,5,5] d = {} for elem in a: if elem in d: d[elem] += 1 else: d[elem] = 1 print [x for x, y in d.items() if y > 1] 

मैं पंडों के साथ ऐसा करूँगा, क्योंकि मैं बहुत कुछ पंडों का उपयोग करता हूं

 import pandas as pd a = [1,2,3,3,3,4,5,6,6,7] vc = pd.Series(a).value_counts() vc[vc > 1].index.tolist() 

देता है

 [3,6] 

शायद बहुत ही कुशल नहीं है, लेकिन अन्य उत्तरों के मुकाबले यह कम से कम कोड है, इसलिए मैंने सोचा कि मैं योगदान करेगा

यहाँ एक साफ और संक्षिप्त समाधान है –

 for x in set(li): li.remove(x) li = list(set(li)) 

पांडा का उपयोग करना:

 >>> import pandas as pd >>> a = [1, 2, 1, 3, 3, 3, 0] >>> pd.Series(a)[pd.Series(a).duplicated()].values array([1, 3, 3]) 

थोड़ा देर हो चुकी है, लेकिन शायद कुछ के लिए उपयोगी हो एक बड़ी सूची के लिए, मैंने पाया कि यह मेरे लिए काम करती है

 l=[1,2,3,5,4,1,3,1] s=set(l) d=[] for x in l: if x in s: s.remove(x) else: d.append(x) d [1,3,1] 

सिर्फ और सभी डुप्लिकेट दिखाता है और ऑर्डर सुरक्षित करता है।

पायथन में एक यात्रा के साथ डुप्ले ढूंढने का बहुत आसान और त्वरित तरीका यह है:

 testList = ['red', 'blue', 'red', 'green', 'blue', 'blue'] testListDict = {} for item in testList: try: testListDict[item] += 1 except: testListDict[item] = 1 print testListDict 

उत्पादन निम्नानुसार होगा:

 >>> print testListDict {'blue': 3, 'green': 1, 'red': 2} 

मेरे ब्लॉग में यह और अधिक http://www.howtoprogramwithpython.com

स्वीकृत उत्तर का तीसरा उदाहरण एक गलत उत्तर देता है और डुप्लिकेट देने का प्रयास नहीं करता है यहां सही संस्करण है:

 number_lst = [1, 1, 2, 3, 5, ...] seen_set = set() duplicate_set = set(x for x in number_lst if x in seen_set or seen_set.add(x)) unique_set = seen_set - duplicate_set 

कैसे घटनाओं की संख्या की जांच करके सूची में प्रत्येक तत्व के माध्यम से केवल पाश के बारे में, फिर एक सेट में जोड़कर जो फिर डुप्लिकेट को प्रिंट करेगा। उम्मीद है कि इससे वहां किसी को मदद मिलेगी।

 myList = [2 ,4 , 6, 8, 4, 6, 12]; newList = set() for i in myList: if myList.count(i) >= 2: newList.add(i) print(list(newList)) ## [4 , 6] 

हम उन सभी वस्तुओं को ढूंढने के लिए itertools.groupby का उपयोग कर सकते हैं itertools.groupby पास dups हैं:

 from itertools import groupby myList = [2, 4, 6, 8, 4, 6, 12] # when the list is sorted, groupby groups by consecutive elements which are similar for x, y in groupby(sorted(myList)): # list(y) returns all the occurences of item x if len(list(y)) > 1: print x 

आउटपुट होगा:

 4 6 
 list2 = [1, 2, 3, 4, 1, 2, 3] lset = set() [(lset.add(item), list2.append(item)) for item in list2 if item not in lset] print list(lset) 

एक पंक्ति समाधान:

 set([i for i in list if sum([1 for a in list if a == i]) > 1]) 

यहां बहुत सारे उत्तर दिए गए हैं, लेकिन मुझे लगता है कि यह अपेक्षाकृत एक पठनीय और समझने में आसान तरीका है:

 def get_duplicates(sorted_list): duplicates = [] last = sorted_list[0] for x in sorted_list[1:]: if x == last: duplicates.append(x) last = x return set(duplicates) 

टिप्पणियाँ:

  • यदि आप दोहराव की गणना को संरक्षित करना चाहते हैं, तो पूरी सूची प्राप्त करने के लिए नीचे 'सेट' पर डाली से छुटकारा दें
  • यदि आप जनरेटर का उपयोग करना पसंद करते हैं, तो डुप्लिकेट्स.एपेंड (एक्स) को उपज एक्स और नीचे दिए गए विवरण के साथ बदलें (आप बाद में सेट कर सकते हैं)

यहां एक तेज़ जनरेटर है जो प्रत्येक तत्व को बूलियन मान के साथ एक कुंजी के रूप में संग्रहीत करने के लिए एक डिक्ट का उपयोग करता है, यह जांचने के लिए कि क्या डुप्लिकेट आइटम पहले ही प्राप्त हो चुका है।

सभी तत्वों के साथ सूचियों के लिए जो हैशनीय प्रकार हैं:

 def gen_dupes(array): unique = {} for value in array: if value in unique and unique[value]: unique[value] = False yield value else: unique[value] = True array = [1, 2, 2, 3, 4, 1, 5, 2, 6, 6] print(list(gen_dupes(array))) # => [2, 1, 6] 

सूचियों के लिए जिनकी सूची हो सकती है:

 def gen_dupes(array): unique = {} for value in array: is_list = False if type(value) is list: value = tuple(value) is_list = True if value in unique and unique[value]: unique[value] = False if is_list: value = list(value) yield value else: unique[value] = True array = [1, 2, 2, [1, 2], 3, 4, [1, 2], 5, 2, 6, 6] print(list(gen_dupes(array))) # => [2, [1, 2], 6] 

आप 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] 

1 यह मैंने लिखा है कि एक तीसरी पार्टी पुस्तकालय से है: iteration_utilities

 def removeduplicates(a): seen = set() for i in a: if i not in seen: seen.add(i) return seen print(removeduplicates([1,1,2,2])) 

इस तरह से मुझे ऐसा करना पड़ा क्योंकि मैंने खुद को अन्य विधियों का उपयोग न करने का चुनौती दी:

 def dupList(oldlist): if type(oldlist)==type((2,2)): oldlist=[x for x in oldlist] newList=[] newList=newList+oldlist oldlist=oldlist forbidden=[] checkPoint=0 for i in range(len(oldlist)): #print 'start i', i if i in forbidden: continue else: for j in range(len(oldlist)): #print 'start j', j if j in forbidden: continue else: #print 'after Else' if i!=j: #print 'i,j', i,j #print oldlist #print newList if oldlist[j]==oldlist[i]: #print 'oldlist[i],oldlist[j]', oldlist[i],oldlist[j] forbidden.append(j) #print 'forbidden', forbidden del newList[j-checkPoint] #print newList checkPoint=checkPoint+1 return newList 

इसलिए आपका नमूना निम्नानुसार काम करता है:

 >>>a = [1,2,3,3,3,4,5,6,6,7] >>>dupList(a) [1, 2, 3, 4, 5, 6, 7] 

sort() फ़ंक्शन का उपयोग करें डुप्लिकेट को इस पर लूपिंग करके और l1[i] == l1[i+1]