दिलचस्प पोस्ट
क्या पूरे पांडस सीरीज़ / डेटफ्रेम को प्रिंट करने के लिए कोई रास्ता नहीं है? फ़ायरबसे ऑफ़लाइन क्षमताएं और ऐडलिस्टनरफोरसिंलिंगवैल्यूइवेंट एंड्रॉइड एसडीके में एफएफटी लाइब्रेरी कैसे अनुकूलित / एक UIPopoverController शैली एंड्रॉइड में इनकमिंग कॉल को अस्वीकार करना एक खिड़कियों के कार्यक्रम में WM_QUIT, WM_CLOSE, और WM_DESTROY में क्या अंतर है? आप कैसे बता सकते हैं कि कैप्स लॉक जावास्क्रिप्ट का प्रयोग कर रहा है? चहचहाना बूटस्ट्रैप हिंडोला ऊर्ध्वाधर स्लाइडिंग रनटाइम पर जावा एप्लिकेशन का असली पथ कैसे प्राप्त करें? इसके विपरीत क्या है: हॉवर (माउस छोड़ने पर)? Android एमुलेटर पर रूट एक्सेस कैसे प्राप्त करें? मैं कैसे jasmine.js में एक कल्पना पर ध्यान केंद्रित कर सकता हूं? ओकेएचटीपी का उपयोग करते हुए बहुस्तृत में एक बड़ी फ़ाइल अपलोड करना एंड्रॉइड और पहनें emulators की जोड़ी सीएसएस – क्यों प्रतिशत ऊंचाई काम नहीं करता है?

फ्लैट सूची में डुप्लिकेट की जांच करें

उदाहरण 1

['one', 'two', 'one'] को True वापस करना चाहिए

उदाहरण 2

['one', 'two', 'three'] False वापसी करना चाहिए।

Solutions Collecting From Web of "फ्लैट सूची में डुप्लिकेट की जांच करें"

डुप्लिकेट्स को निकालने के लिए set() करें set() का उपयोग करें यदि सभी मान हैश करने योग्य हैं :

 >>> your_list = ['one', 'two', 'one'] >>> len(your_list) != len(set(your_list)) True 

केवल छोटी सूचियों के लिए अनुशंसित:

 any(thelist.count(x) > 1 for x in thelist) 

लंबी सूची पर उपयोग करें – यह सूची में मदों की संख्या के वर्ग के लिए आनुपातिक लग सकता है!

हैशणीय वस्तुओं (स्ट्रिंग्स, नंबर, और सी) के साथ लंबी सूचियों के लिए:

 def anydup(thelist): seen = set() for x in thelist: if x in seen: return True seen.add(x) return False 

यदि आपके आइटम नहीं हैं (सुब्बलिस्ट्स, डाइक्ट्स, आदि), तो यह बालों वाली हो जाती है, हालांकि यदि वे कम से कम तुलनीय हो तो ओ (एन लॉगएन) प्राप्त करना संभव हो सकता है अन्यथा अगर आपको हेथबल्स के लिए हे (एन) एन (एन लॉग एन) के लिए सबसे अच्छा प्रदर्शन प्राप्त करने के लिए आइटमों की विशेषताओं को जानने या परीक्षण करने की आवश्यकता है (अन्यथा, तुलनीय हो या नहीं), अन्यथा यह ओ (एन स्क्वेर्ड) के नीचे है और इसके बारे में कुछ भी नहीं कर सकता 🙁

यह पुराना है, लेकिन जवाब यहां मुझे थोड़ा अलग हल करने के लिए प्रेरित कर रहे हैं। यदि आप समझों को अपमानित करने के लिए तैयार हैं, तो आप इस तरह से शॉर्ट सर्किट प्राप्त कर सकते हैं।

 xs = [1, 2, 1] s = set() any(x in s or s.add(x) for x in xs) # You can use a similar approach to actually retrieve the duplicates. s = set() duplicates = set(x for x in xs if x in s or s.add(x)) 

यदि आप कार्यात्मक प्रोग्रामिंग शैली के शौकीन हैं, तो यहां एक उपयोगी कार्य, आत्म-दस्तावेज और परीक्षण कोड है जो डूटेस्ट का उपयोग कर रहा है।

 def decompose(a_list): """Turns a list into a set of all elements and a set of duplicated elements. Returns a pair of sets. The first one contains elements that are found at least once in the list. The second one contains elements that appear more than once. >>> decompose([1,2,3,5,3,2,6]) (set([1, 2, 3, 5, 6]), set([2, 3])) """ return reduce( lambda (u, d), o : (u.union([o]), d.union(u.intersection([o]))), a_list, (set(), set())) if __name__ == "__main__": import doctest doctest.testmod() 

वहां से आप एकजुटता की जांच कर सकते हैं कि क्या लौटा जोड़ी का दूसरा तत्व खाली है या नहीं:

 def is_set(l): """Test if there is no duplicate element in l. >>> is_set([1,2,3]) True >>> is_set([1,2,1]) False >>> is_set([]) True """ return not decompose(l)[1] 

ध्यान दें कि यह कुशल नहीं है क्योंकि आप स्पष्ट रूप से अपघटन का निर्माण कर रहे हैं लेकिन कम करने की रेखा के साथ, आप 5 के उत्तर देने के लिए कुछ समान (लेकिन थोड़ा कम कुशल) के लिए आ सकते हैं:

 def is_set(l): try: def func(s, o): if o in s: raise Exception return s.union([o]) reduce(func, l, set()) return True except: return False 

मैंने हाल ही में एक संबंधित प्रश्न का उत्तर दिया है कि एक जनरेटर का उपयोग करके सभी डुप्लिकेट्स को सूची में स्थापित किया गया है । इसका फायदा यह है कि यदि 'केवल एक डुप्लिकेट' स्थापित करने के लिए उपयोग किया जाता है तो आपको पहले आइटम प्राप्त करने की आवश्यकता है और बाकी को अनदेखा किया जा सकता है, जो कि अंतिम शॉर्टकट है

यह एक दिलचस्प सेट आधारित दृष्टिकोण है जिसे मैं सीधे मोहोजीप से अनुकूलित करता हूं :

 def getDupes(l): seen = set() seen_add = seen.add for x in l: if x in seen or seen_add(x): yield x 

तदनुसार, dupes की एक पूरी सूची सूची होगी list(getDupes(etc)) । केवल अगर "धोखा" का परीक्षण करने के लिए, इसे नीचे लिपटे जाना चाहिए:

 def hasDupes(l): try: if getDupes(c).next(): return True # Found a dupe except StopIteration: pass return False 

यह तराजू अच्छी तरह से और सूची में मौजूद धोखा जहां भी संगत ऑपरेटिंग समय प्रदान करता है – मैंने 1 एम प्रविष्टियों की सूची के साथ परीक्षण किया। यदि आप डेटा के बारे में कुछ जानते हैं, विशेष रूप से, पहले छमाही में, या अन्य चीजें जो आपको अपनी आवश्यकताओं को तिरछेगी, जैसे वास्तविक डुप्ले प्राप्त करने की ज़रूरत हैं, तो वास्तव में वैकल्पिक दोहरे locators यह बेहतर प्रदर्शन हो सकता है मैं सुझा दो हैं …

सरल शब्दावली आधारित दृष्टिकोण, बहुत पठनीय:

 def getDupes(c): d = {} for i in c: if i in d: if d[i]: yield i d[i] = False else: d[i] = True 

सॉर्ट की गई सूची पर आईटेरोलॉज (अनिवार्य रूप से एक इफिलटर / izip / tee) का लाभ उठाएं, बहुत कुशल अगर आप सभी दांवों को प्राप्त कर रहे हैं, हालांकि केवल पहली बार पाने के लिए उतना जल्दी नहीं है:

 def getDupes(c): a, b = itertools.tee(sorted(c)) next(b, None) r = None for k, g in itertools.ifilter(lambda x: x[0]==x[1], itertools.izip(a, b)): if k != r: yield k r = k 

यह उन शीर्ष निष्पादकों से थे, जिन्हें मैंने पूर्ण धोखा सूची के लिए करने की कोशिश की थी, साथ ही पहले से 1 मीटर तत्व सूची में कहीं से भी बीच में होने वाली सूची में शामिल हो गए थे। यह आश्चर्य की बात थी कि सॉर्ट स्टेप कितना छोटा है। आपका माइलेज भिन्न हो सकता है, लेकिन यहां मेरे विशिष्ट समयबद्ध परिणाम हैं:

 Finding FIRST duplicate, single dupe places "n" elements in to 1m element array Test set len change : 50 - . . . . . -- 0.002 Test in dict : 50 - . . . . . -- 0.002 Test in set : 50 - . . . . . -- 0.002 Test sort/adjacent : 50 - . . . . . -- 0.023 Test sort/groupby : 50 - . . . . . -- 0.026 Test sort/zip : 50 - . . . . . -- 1.102 Test sort/izip : 50 - . . . . . -- 0.035 Test sort/tee/izip : 50 - . . . . . -- 0.024 Test moooeeeep : 50 - . . . . . -- 0.001 * Test iter*/sorted : 50 - . . . . . -- 0.027 Test set len change : 5000 - . . . . . -- 0.017 Test in dict : 5000 - . . . . . -- 0.003 * Test in set : 5000 - . . . . . -- 0.004 Test sort/adjacent : 5000 - . . . . . -- 0.031 Test sort/groupby : 5000 - . . . . . -- 0.035 Test sort/zip : 5000 - . . . . . -- 1.080 Test sort/izip : 5000 - . . . . . -- 0.043 Test sort/tee/izip : 5000 - . . . . . -- 0.031 Test moooeeeep : 5000 - . . . . . -- 0.003 * Test iter*/sorted : 5000 - . . . . . -- 0.031 Test set len change : 50000 - . . . . . -- 0.035 Test in dict : 50000 - . . . . . -- 0.023 Test in set : 50000 - . . . . . -- 0.023 Test sort/adjacent : 50000 - . . . . . -- 0.036 Test sort/groupby : 50000 - . . . . . -- 0.134 Test sort/zip : 50000 - . . . . . -- 1.121 Test sort/izip : 50000 - . . . . . -- 0.054 Test sort/tee/izip : 50000 - . . . . . -- 0.045 Test moooeeeep : 50000 - . . . . . -- 0.019 * Test iter*/sorted : 50000 - . . . . . -- 0.055 Test set len change : 500000 - . . . . . -- 0.249 Test in dict : 500000 - . . . . . -- 0.145 Test in set : 500000 - . . . . . -- 0.165 Test sort/adjacent : 500000 - . . . . . -- 0.139 Test sort/groupby : 500000 - . . . . . -- 1.138 Test sort/zip : 500000 - . . . . . -- 1.159 Test sort/izip : 500000 - . . . . . -- 0.126 Test sort/tee/izip : 500000 - . . . . . -- 0.120 * Test moooeeeep : 500000 - . . . . . -- 0.131 Test iter*/sorted : 500000 - . . . . . -- 0.157