दिलचस्प पोस्ट
एक जेएसओएन स्ट्रिंग को एक हैशमैप में कनवर्ट करें एंड्रॉइड कैमरा सफ़ल अवलोकन मैं jQuery के साथ एक पृष्ठ कैसे रिफ्रेश कर सकता हूं? Xcode की छिपी हुई विशेषताओं मोबाइल फोन पर किसी वेब पेज में एक लिंक पर क्लिक करते समय एक फ़ोन कॉल ट्रिगर कैसे करें पायथन में एक ऑब्जेक्ट का पूरी तरह से योग्य क्लास का नाम प्राप्त करें पांडस बार की साजिश परिवर्तन दिनांक स्वरूप मैं कैसे एक डाटालेट फ़िल्टर कर सकता हूं? केवल सीएसएस के साथ चिनाई-शैली वाला लेआउट क्या इंप्रेस की तुलना में वास्तव में 1 जोड़ें? x86 उद्देश्य-सी में एक रिक्त स्ट्रिंग की जांच करने का सही तरीका क्या है? जोडा-टाइम: अवधि, अंतराल और अवधि के बीच अंतर क्या है? मैं हार्डवेयर प्रीफेचिंग को प्रोग्रामैटिक रूप से अक्षम कैसे कर सकता हूं? जावास्क्रिप्ट सरणी में निहित सबसे बड़ी संख्या मैं कैसे पा सकता हूं? तारों / चरित्र के एक सदिश को समन्वित करें

अजगर में एक सूची से अद्वितीय मान प्राप्त करें

मैं निम्न सूची से अद्वितीय मान प्राप्त करना चाहता हूं:

[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] 

मुझे जो आउटपुट चाहिए, वह है:

 [u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow'] 

यह कोड काम करता है:

 output = [] for x in trends: if x not in output: output.append(x) print output 

क्या मुझे एक बेहतर समाधान का उपयोग करना चाहिए?

वेब के समाधान से एकत्रित समाधान "अजगर में एक सूची से अद्वितीय मान प्राप्त करें"

पहले अपनी सूची को ठीक से कॉमा से अलग करके घोषित करें। आप एक सेट में सूची को परिवर्तित करके अद्वितीय मूल्य प्राप्त कर सकते हैं।

 mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] myset = set(mylist) print myset 

यदि आप इसे सूची के रूप में और आगे उपयोग करते हैं, तो आपको इसे वापस सूची में परिवर्तित करना चाहिए:

 mynewlist = list(myset) 

एक अन्य संभावना, शायद एक सूची का उपयोग करने के बजाय शुरुआत से एक सेट का उपयोग करने के लिए तेजी से होगा फिर आपका कोड होना चाहिए:

 output = set() for x in trends: output.add(x) print output 

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

इस प्रकार के साथ संगत होने के लिए मैं उपयोग करूंगा:

 mylist = list(set(mylist)) 

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

एक पायथन सूची:

 a = ['a', 'b', 'c', 'd', 'b'] 

अनन्य वस्तुएं प्राप्त करने के लिए, बस इसे एक सेट में बदल दें (जो आपको फिर से सूची में फिर से बदल सकते हैं यदि आवश्यक हो):

 b = set(a) print b >>> set(['a', 'b', 'c', 'd']) 

आपका आउटपुट चर किस प्रकार है?

पायथन सेट हैं जो आपको बस जरूरत है इस तरह आउटपुट की घोषणा करें:

 output = set([]) # initialize an empty set 

और आप output.add (elem) के साथ तत्वों को जोड़ने के लिए तैयार हैं और सुनिश्चित करें कि वे अद्वितीय हैं

चेतावनी: सेट्स सूची के मूल आदेश को संरक्षित नहीं करते हैं।

यदि हमें तत्वों के आदेश को रखने की आवश्यकता है, तो इसके बारे में कैसे:

 used = set() mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] unique = [x for x in mylist if x not in used and (used.add(x) or True)] 

और अस्थायी used वर्जन के बिना और reduce एक और समाधान

 mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, []) 

अद्यतन – 1 अक्टूबर, 2016

reduce साथ एक और समाधान, लेकिन इस बार बिना .append जो इसे अधिक मानव पठनीय और समझने में आसान बनाता है

 mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, []) #which can also be writed as: unique = reduce(lambda l, x: l if x in l else l+[x], mylist, []) 

नोट: इस बात को ध्यान में रखें कि अधिक मानव-पठनीय हम प्राप्त करते हैं, स्क्रिप्ट बहुत अधिक असंभव है।

 import timeit setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']" #10x to Michael for pointing out that we can get faster with set() timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup) 0.4188511371612549 timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup) 0.8063139915466309 timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup=setup) 2.216820001602173 timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup=setup) 2.948796033859253 timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup=setup) 2.9785239696502686 

उत्तर टिप्पणियाँ

क्योंकि @ मोनिका ने "यह कैसे काम कर रहा है?" के बारे में एक अच्छा सवाल पूछा। सभी समस्याओं के लिए इसे बाहर figuring के लिए बाहर है मैं यह कैसे काम करता है और क्या जादूई यहाँ हो रहा है के बारे में और अधिक गहरा विवरण देने की कोशिश करेंगे;)

तो उसने पहले पूछा:

मैं यह समझने की कोशिश करता हूं कि क्यों unique = [used.append(x) for x in mylist if x not in used] में नहीं है) काम नहीं कर रहा है

वैसे यह वास्तव में काम कर रहा है

 >>> used = [] >>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] >>> unique = [used.append(x) for x in mylist if x not in used] >>> print used [u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow'] >>> print unique [None, None, None, None, None] 

समस्या यह है कि हम unique चर में वांछित परिणाम नहीं प्राप्त कर रहे हैं, लेकिन केवल used चर के भीतर। इसका कारण यह है कि सूची की समझ के दौरान .append को संशोधित करता है और None रिटर्न None देता।

तो परिणाम को unique चर में प्राप्त करने के लिए, और अभी भी उसी तर्क का उपयोग .append(x) if x not in used , तो हमें इसे स्थानांतरित करने की आवश्यकता है। सूची के दाईं ओर .append कॉल को .append और बस x बाईं तरफ।

लेकिन अगर हम बहुत भोले हैं और केवल साथ जाएं:

 >>> unique = [x for x in mylist if x not in used and used.append(x)] >>> print unique [] 

हमें बदले में कुछ नहीं मिलेगा

दोबारा, यह इसलिए है क्योंकि। .append विधि None रिटर्न None देता, और यह हमारे तार्किक अभिव्यक्ति को निम्नलिखित रूप से दिखाता है:

 x not in used and None 

यह मूल रूप से हमेशा होता है:

  1. जब x used , तो False मूल्यांकन करता है,
  2. x में used नहीं किया used है जब None मूल्यांकन करता है

और दोनों मामलों में ( False / None ), इसे False मूल्य के रूप में माना जाएगा और परिणामस्वरूप हम एक खाली सूची प्राप्त करेंगे।

लेकिन जब यह used में None तो यह क्यों किसी का मूल्यांकन करता है? कोई पूछ सकता है

वैसे यह इसलिए है क्योंकि यह है कि पायथन के शॉर्ट-सर्किट ऑपरेटर्स कैसे काम करते हैं ।

अभिव्यक्ति x and y पहले एक्स का मूल्यांकन करता है; अगर एक्स गलत है, तो इसका मूल्य वापस आ जाएगा; अन्यथा, y का मूल्यांकन किया जाता है और परिणामस्वरूप मूल्य वापस किया जाता है।

इसलिए जब x में प्रयोग नहीं किया जाता है (यानी जब यह True ) अगले भाग या अभिव्यक्ति का मूल्यांकन किया जाएगा ( used.append(x) किया। used.append(x) ) और उसके मूल्य ( None ) वापस किया जाएगा।

लेकिन डुप्लिकेट के साथ एक सूची से अद्वितीय तत्व प्राप्त करने के लिए हम चाहते हैं कि हम चाहते हैं। उन्हें एक नई सूची में शामिल करें, जब वे मुट्ठी के समय के लिए आए।

इसलिए हम वास्तव में used used.append(x) का मूल्यांकन करना चाहते हैं, जब x में used नहीं किया used , हो सकता है कि अगर कोई इसे बदलने का कोई रास्ता None used.append(x) में नहीं हो हम ठीक हो जाएंगे?

ठीक है, हाँ और यहां वह है जहां short-circuit ऑपरेटरों का दूसरा प्रकार खेलने के लिए आते हैं।

अभिव्यक्ति x or y पहले एक्स का मूल्यांकन करता है; यदि x सच है, तो इसका मूल्य वापस आ जाता है; अन्यथा, y का मूल्यांकन किया जाता है और परिणामस्वरूप मूल्य वापस किया जाता है।

हम जानते हैं कि। .append(x) हमेशा .append(x) होगा, इसलिए यदि हम सिर्फ एक or उसके बगल में जोड़ते हैं, तो हम हमेशा अगले भाग प्राप्त करेंगे। यही कारण है कि हम लिखते हैं:

 x not in used and (used.append(x) or True) 

इसलिए हम used.append(x) मूल्यांकन कर सकते हैं और एक परिणाम के रूप में True हो सकते हैं, केवल जब अभिव्यक्ति का पहला भाग (x not in used) True

इसी तरह की विधि विधि को reduce साथ दूसरे दृष्टिकोण में देखी जा सकती है।

 (l.append(x) or l) if x not in l else l #similar as the above, but maybe more readable #we return l unchanged when x is in l #we append x to l and return l when x is not in l l if x in l else (l.append(x) or l) 

हम कहाँ:

  1. x को l जोड़ें और उस l लौटें जब x l में न हो। or बयान के लिए धन्यवाद। .append का मूल्यांकन किया जाता है और उसके बाद लौटा जाता है l
  2. जब l वापस अछूता हूँ

सेट – अद्वितीय तत्वों का संग्रह unordered सेट की कन्स्ट्रक्टर को तत्वों की सूची सेट कर सकते हैं। इसलिए, डुप्लिकेट तत्वों के साथ सूची को पास करें, हम अनूठे तत्वों के साथ सेट करते हैं और इसे सूची में वापस परिवर्तित कर देते हैं तो अद्वितीय तत्वों के साथ सूची प्राप्त करें। मैं प्रदर्शन और स्मृति ओवरहेड के बारे में कुछ भी नहीं कह सकता, लेकिन मुझे आशा है कि छोटी सूची के साथ यह इतना महत्वपूर्ण नहीं है।

 list(set(my_not_unique_list)) 

बस और छोटी

केवल एक सूची संपीड़न का उपयोग करके एक ही क्रम अनन्य सूची।

 > my_list = [1, 2, 1, 3, 2, 4, 3, 5, 4, 3, 2, 3, 1] > unique_list = [ > e > for i, e in enumerate(my_list) > if my_list.index(e) == i > ] > unique_list [1, 2, 3, 4, 5] 

enumerates करता है कि सूचकांक i और तत्व e को tuple रूप में tuple

my_list.index e के पहले सूचकांक देता है यदि पहले सूचकांक नहीं है तो i वर्तमान पुनरावृत्ति की सूची में पहले e नहीं है।

संपादित करें

मुझे ध्यान देना चाहिए कि यह करने का एक अच्छा तरीका नहीं है, प्रदर्शन-वार। यह सिर्फ एक तरीका है जो इसे केवल एक सूची संपीड़न का उपयोग करके प्राप्त करता है।

यदि आप अपने कोड में numpy का उपयोग कर रहे हैं (जो बड़ी मात्रा में डेटा के लिए एक अच्छा विकल्प हो सकता है), numpy.unique देखें :

 >>> import numpy as np >>> wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] >>> np.unique(wordsList) array([u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'], dtype='<U10') 

( http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html )

जैसा कि आप देख सकते हैं, numpy समर्थन न केवल संख्यात्मक डेटा, स्ट्रिंग सरणियों को भी संभव है। बेशक, नतीजा एक नुकीला सरणी है, लेकिन इससे कोई फर्क नहीं पड़ता, क्योंकि यह अभी भी अनुक्रम की तरह व्यवहार करता है:

 >>> for word in np.unique(wordsList): ... print word ... PBS debate job nowplaying thenandnow 

यदि आप वास्तव में एक वैनिला अजगर सूची वापस करना चाहते हैं, तो आप हमेशा सूची कॉल कर सकते हैं ()।

हालांकि, परिणाम को स्वचालित रूप से सॉर्ट किया गया है, जैसा कि आप ऊपर कोड के टुकड़ों से देख सकते हैं। सूची के क्रम को बनाए रखने की आवश्यकता होती है, तो बिना किसी क्रम के अद्वितीय अद्वितीय देखें।

पहली बात, आपके द्वारा दिया जाने वाला उदाहरण वैध सूची नहीं है।

 example_list = [u'nowplaying',u'PBS', u'PBS', u'nowplaying', u'job', u'debate',u'thenandnow'] 

मान लीजिए कि उपरोक्त उदाहरण सूची है। तब आप निम्नलिखित नुस्खा का उपयोग कर सकते हैं जैसे itertools उदाहरण डॉक्टर दे कि अद्वितीय मूल्यों को वापस कर सकते हैं और आदेश की रक्षा के रूप में आपको लगता है की आवश्यकता होती है। यहाँ इरेरेबल example_list है

 from itertools import ifilterfalse def unique_everseen(iterable, key=None): "List unique elements, preserving order. Remember all elements ever seen." # unique_everseen('AAAABBBCCDAABBB') --> ABCD # unique_everseen('ABBCcAD', str.lower) --> ABCD seen = set() seen_add = seen.add if key is None: for element in ifilterfalse(seen.__contains__, iterable): seen_add(element) yield element else: for element in iterable: k = key(element) if k not in seen: seen_add(k) yield element 
 def get_distinct(original_list): distinct_list = [] for each in original_list: if each not in distinct_list: distinct_list.append(each) return distinct_list 
 def setlist(lst=[]): return list(set(lst)) 

एक बोनस के रूप में, Counter प्रत्येक मान के लिए अद्वितीय मूल्यों और गणना दोनों प्राप्त करने का एक आसान तरीका है:

 from collections import Counter l = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] c = Counter(l) 

पिछले उत्तर के अलावा, जो कहते हैं कि आप अपनी सूची को सेट करने के लिए परिवर्तित कर सकते हैं, आप इस तरीके से भी इस प्रकार कर सकते हैं

 mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenadnow'] mylist = [i for i in set(mylist)] 

उत्पादन होगा

 [u'nowplaying', u'job', u'debate', u'PBS', u'thenadnow'] 

हालांकि आदेश संरक्षित नहीं किया जाएगा।

एक और सरल उत्तर हो सकता है (सेट्स का उपयोग किए बिना)

 >>> t = [v for i,v in enumerate(mylist) if mylist.index(v) == i] [u'nowplaying', u'PBS', u'job', u'debate', u'thenadnow'] 

यदि आपको व्यवस्था बनाए रखने की आवश्यकता है, तो यहां एक-लाइनर है:

 [x for i, x in enumerate(array) if x not in array[0:i]] 

संपादित करें: इस एक लाइनर का उपयोग करने के आदेश को बनाए रखने की लागत अधिक है …

 array = [round(random.random()*10) for _ in range(100000)] # maintain order [x for i, x in enumerate(array) if x not in array[0:i]] #=> --- 14.416885137557983 seconds --- uniq = [] [uniq.append(x) for x in array if x not in uniq] uniq #=> --- 0.011909008026123047 seconds --- # doesn't maintain order list(set(array)) #=> --- 0.003480195999145508 seconds --- 
  1. आपके कोड की शुरुआत में सिर्फ अपनी आउटपुट सूची को रिक्त घोषित करें: output=[]
  2. आपके कोड के बजाय आप इस कोड के trends=list(set(trends)) उपयोग कर सकते हैं

नीचे अपनी सूची उपयोग कोड से अद्वितीय मान प्राप्त करने के लिए:

 trends = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] output = set(trends) output = list(output) 

महत्वपूर्ण: उपरोक्त दृष्टिकोण काम नहीं करेगा अगर सूची में से कोई भी वस्तु नहीं है जो कि अस्थिर प्रकारों का मामला है, उदाहरण के लिए सूची या शब्दकोश

 trends = [{'super':u'nowplaying'}, u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'] output = set(trends) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'dict' 

इसका मतलब है कि आपको यह सुनिश्चित करना होगा कि trends सूची में हमेशा ही संभवनीय आइटम शामिल होंगे अन्यथा आपको अधिक परिष्कृत कोड का उपयोग करना होगा:

 from copy import deepcopy try: trends = [{'super':u'nowplaying'}, [u'PBS',], [u'PBS',], u'nowplaying', u'job', u'debate', u'thenandnow', {'super':u'nowplaying'}] output = set(trends) output = list(output) except TypeError: trends_copy = deepcopy(trends) while trends_copy: trend = trends_copy.pop() if trends_copy.count(trend) == 0: output.append(trend) print output 

आप सेट का उपयोग कर सकते हैं बस स्पष्ट होने के लिए, मैं यह समझा रहा हूं कि एक सूची और एक सेट के बीच अंतर क्या है। सेट अद्वितीय तत्वों का संग्रह नहीं है। सूची तत्वों का संग्रह का आदेश दिया जाता है। इसलिए,

  unicode_list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow'] list_unique=list(set(unicode_list)) print list_unique [u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow'] 

लेकिन: चर का नामकरण करने में सूची / सेट का उपयोग न करें। यह त्रुटि का कारण होगा: EX: उपरोक्त एक में यूनिकोड की सूची के बजाय उपयोग सूची के बजाय

 list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow'] list_unique=list(set(list)) print list_unique list_unique=list(set(list)) TypeError: 'list' object is not callable 

मुझे आश्चर्य है कि अब तक कोई भी सीधे आदेश नहीं दे रहा है।

 def unique(sequence): """Generate unique items from sequence in the order of first occurrence.""" seen = set() for value in sequence: if value in seen: continue seen.add(value) yield value 

यह मूल्य उत्पन्न करेगा, इसलिए यह सिर्फ सूचियों से अधिक के साथ काम करता है, जैसे unique(range(10)) । एक सूची प्राप्त करने के लिए, बस कॉल list(unique(sequence)) , इस तरह से:

 >>> list(unique([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'])) [u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow'] 

इसमें इसकी आवश्यकता है कि प्रत्येक वस्तु हठनीय है और न केवल तुलनीय है, लेकिन पायथन में अधिकांश चीजें हैं और यह ओ (एन) है और ओ (एन ^ 2) नहीं है, इसलिए यह एक लंबी सूची के साथ ठीक काम करेगा।

सेट ऑर्डर किए गए और अद्वितीय तत्वों का एक संग्रह है इसलिए, आप अनन्य सूची प्राप्त करने के लिए नीचे सेट का उपयोग कर सकते हैं:

 unique_list = list(set([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow'])) 

मुझे पता है यह एक पुराना सवाल है, लेकिन यहां मेरा अनूठा समाधान है: वर्ग उत्तराधिकार!

 class UniqueList(list): def appendunique(self,item): if item not in self: self.append(item) return True return False 

फिर, अगर आप किसी सूची में विशिष्ट रूप से आइटम जोड़ना चाहते हैं तो आप केवल एक अनन्य सूची पर ऐपेंड्यूनिक को कॉल करते हैं। क्योंकि यह एक सूची से मिला है, यह मूल रूप से एक सूची की तरह काम करता है, ताकि आप इंडेक्स () आदि जैसे फ़ंक्शन का उपयोग कर सकते हैं। और क्योंकि यह सही या गलत देता है, आप यह पता लगा सकते हैं कि सफल होने के बाद (अनन्य आइटम) या असफल (पहले से ही सूची)।

किसी सूची से आइटम्स की एक अनूठी सूची प्राप्त करने के लिए, एक अनन्य सूची में आइटम संलग्न करने के लिए लूप का उपयोग करें (फिर सूची में प्रतिलिपि करें)।

उदाहरण उपयोग कोड:

 unique = UniqueList() for each in [1,2,2,3,3,4]: if unique.appendunique(each): print 'Uniquely appended ' + str(each) else: print 'Already contains ' + str(each) 

प्रिंटों:

 Uniquely appended 1 Uniquely appended 2 Already contains 2 Uniquely appended 3 Already contains 3 Uniquely appended 4 

सूची में कॉपी करना:

 unique = UniqueList() for each in [1,2,2,3,3,4]: unique.appendunique(each) newlist = unique[:] print newlist 

प्रिंटों:

 [1, 2, 3, 4] 

विशिष्टता की सामग्री की जांच करने के लिए मेरा समाधान, लेकिन मूल आदेश को संरक्षित करें:

 def getUnique(self): notunique = self.readLines() unique = [] for line in notunique: # Loop over content append = True # Will be set to false if line matches existing line for existing in unique: if line == existing: # Line exists ? do not append and go to the next line append = False break # Already know file is unique, break loop if append: unique.append(line) # Line not found? add to list return unique 

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

लंबे सरणियों के लिए

 s = np.empty(len(var)) s[:] = np.nan for x in set(var): x_positions = np.where(var==x) s[x_positions[0][0]]=x sorted_var=s[~np.isnan(s)] 

यदि आप एक सूची से अद्वितीय तत्व प्राप्त करना चाहते हैं और अपने मूल क्रम को बनाए रखना चाहते हैं, तो आप पायथन की मानक लाइब्रेरी से OrderedDict डेटा संरचना को नियोजित कर सकते हैं:

 from collections import OrderedDict def keep_unique(elements): return list(OrderedDict.fromkeys(elements).keys()) elements = [2, 1, 4, 2, 1, 1, 5, 3, 1, 1] required_output = [2, 1, 4, 5, 3] assert keep_unique(elements) == required_output 

वास्तव में, यदि आप पायथन 3.6 का प्रयोग कर रहे हैं, तो आप इसके लिए सादे dict उपयोग कर सकते हैं:

 def keep_unique(elements): return list(dict.fromkeys(elements).keys()) 

दिशानिर्देशों के "कॉम्पैक्ट" प्रतिनिधित्व की शुरूआत के बाद यह संभव हो गया है इसे यहाँ देखें यद्यपि यह "एक कार्यान्वयन विवरण माना जाता है और उस पर निर्भर नहीं होना चाहिए"

निम्न फ़ंक्शन का उपयोग करें:

 def uniquefy_list(input_list): """ This function takes a list as input and return a list containing only unique elements from the input list """ output_list=[] for elm123 in input_list: in_both_lists=0 for elm234 in output_list: if elm123 == elm234: in_both_lists=1 break if in_both_lists == 0: output_list.append(elm123) return output_list 

इस फ़ंक्शन का प्रयास करें, यह आपके कोड के समान है लेकिन यह एक गतिशील श्रेणी है।

 def unique(a): k=0 while k < len(a): if a[k] in a[k+1:]: a.pop(k) else: k=k+1 return a