सूची समझों का उपयोग कर सूची में आसन्न डुप्लिकेट तत्वों को कैसे हटाया जाए?

Question

क्या फ़िल्टर फ़िल्टर से डुप्लीकेट फ़िल्टर करने के लिए पाइथन में सूची समझ का उपयोग करने का कोई तरीका है?

>>> xs = [1,2,2,3] 
>>> print added.reAdj(xs) 
[1,2,3] 

एसई के माध्यम से एक खोज एक समान लेकिन थोड़ा अलग सवाल पूछने एक earlier inquiry पता चला: सभी डुप्लिकेट एक सूची, लेकिन स्पष्ट रूप से नहीं से निकाला जा सकता है कि क्या

यहाँ मैं क्या मतलब का एक उदाहरण है सूची समझने वाले समाधानों के लिए पूछना। सूची समझ का उपयोग करने के लिए प्रेरणा विशेष रूप से their advantages over traditional for loops की पहचान का पालन करती है।

result = [] 
most_recent_elem = None 
for e in xs: 
    if e != most_recent_elem: 
     result.append(e) 
     most_recent_elem = e 

set() सुझाव है, कि गैर आसन्न डुप्लिकेट में काम निकाल दिए जाते हैं पूरा करने में विफल है, जबकि पाश प्रभावी लेकिन वर्बोज़ है: उपयोगकर्ताओं को इस तरह के रूप सेट() फ़ंक्शन या मानक पाशन के उपयोग का सुझाव दिया।

यह एक सूची समझ में अगले तत्व को सुरक्षित रूप से संदर्भित करने का माध्यम लगता है जैसा कि आवश्यक है।

[x for x in xs if x != **x.next()**] 

कोई विचार?

Answer 1

आप @AChampion ने सुझाव दिया समाधान के साथ list comprehension और enumerate इस्तेमाल कर सकते हैं:

xs = [1,2,2,2,1,1] 
In [115]: [n for i, n in enumerate(xs) if i==0 or n != xs[i-1]] 
Out[115]: [1, 2, 1] 

उस सूची में समझ वापसी आइटम अगर यह पहले या निम्न के लिए है अगर यह पिछले के बराबर नहीं है। यह if कथन के आलसी मूल्यांकन के कारण काम करेगा।

Answer 2

आप itertools.groupby उपयोग कर सकते हैं:

>>> import itertools 
>>> [key for key, grp in itertools.groupby([1, 2, 2, 3])] 
[1, 2, 3] 

---

itertools.groupby पुनरावर्तक देता है। इसे पुन: स्थापित करके, आपको एक कुंजी, समूह जोड़े मिलेंगे। (key कोई आइटम नहीं होगा यदि key फ़ंक्शन निर्दिष्ट है, अन्यथा key फ़ंक्शन का वापसी मूल्य)। group पुनरावर्तक जो key समारोह को लागू करने के आधार पर वर्गीकृत किया पैदावार आइटम जाएगा (यदि निर्दिष्ट नहीं है, एक ही मान समूहीकृत किया जाएगा)

>>> import itertools 
>>> it = itertools.groupby([1, 2, 2, 3]) 
>>> it 
<itertools.groupby object at 0x7feec0863048> 
>>> for key, grp in it: 
...  print(key) 
...  print(grp) 
... 
1 
<itertools._grouper object at 0x7feec0828ac8> 
2 
<itertools._grouper object at 0x7feec0828b00> 
3 
<itertools._grouper object at 0x7feec0828ac8> 
>>> it = itertools.groupby([1, 2, 2, 3]) 
>>> for key, grp in it: 
...  print(list(grp)) 
... 
[1] 
[2, 2] 
[3] 

समाधान ऊपर, मैं केवल key इस्तेमाल किया क्योंकि सवाल परवाह नहीं करता कि कितने आइटम निकट हैं।

Answer 3

आप एक कम वर्बोज़ पाश समाधान इस्तेमाल कर सकते हैं:

>>> result = xs[:1] 
>>> for e in xs: 
     if e != result[-1]: 
      result.append(e) 

या:

>>> result = [] 
>>> for e in xs: 
     if e not in result[-1:]: 
      result.append(e) 

Answer 4

(zip_longest के साथ) itertools व्यंजनों से जोड़ो में उपयोग करने से आप अगले तत्व जाँच के लिए एक आसान तरीका देता है:

import itertools as it 

def pairwise(iterable): 
    a, b = it.tee(iterable) 
    next(b, None) 
    return it.zip_longest(a, b, fillvalue=object()) # izip_longest for Py2 

>>> xs = [1,2,2,3] 
>>> [x for x, y in pairwise(xs) if x != y] 
[1, 2, 3] 
>>> xs = [1,2,2,2,2,3,3,3,4,5,6,6] 
>>> [x for x, y in pairwise(xs) if x != y] 
[1, 2, 3, 4, 5, 6] 

Answer 5

कैसे इस बारे में:

>>> l = [1,1,2,3,4,4,4,4,5,6,3,3,5,5,7,8,8,8,9,1,2,3,3,3,10,10] 
>>> 
>>> o = [] 
>>> p = None 
>>> for n in l: 
     if n == p: 
      continue 
     o.append(n) 
     p = n  

>>> o 
[1, 2, 3, 4, 5, 6, 3, 5, 7, 8, 9, 1, 2, 3, 10] 

जाहिर है, इसके बाद के संस्करण समाधान, ओपी की तुलना में अधिक वर्बोज़ है इसलिए यहाँ itertools मॉड्यूल से कि zip_longest उपयोग का एक विकल्प है:

>>> l 
[1, 1, 2, 3, 4, 4, 4, 4, 5, 6, 3, 3, 5, 5, 7, 8, 8, 8, 9, 1, 2, 3, 3, 3, 10, 10] 
>>> from itertools import zip_longest 
>>> o = [p for p,n in zip_longest(l,l[1:]) if p != n] #By default fillvalue=None 
>>> o 
[1, 2, 3, 4, 5, 6, 3, 5, 7, 8, 9, 1, 2, 3, 10]