[Python] सूचियों में डुप्लिकेट को हटा रहा है



Answers

पायथन 2.7 में, मूल क्रम में रखते हुए डुप्लिकेट को पुनरावृत्त करने का नया तरीका यह है:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

पायथन 3.5 में , ऑर्डर्ड डिक्ट के पास सी कार्यान्वयन है। मेरे समय से पता चलता है कि यह अब पाइथन 3.5 के विभिन्न दृष्टिकोणों में से सबसे तेज़ और सबसे छोटा दोनों है।

पायथन 3.6 में , नियमित नियम दोनों आदेश और कॉम्पैक्ट बन गए। (यह सुविधा सीपीथॉन और पीपीपी के लिए है लेकिन अन्य कार्यान्वयन में मौजूद नहीं हो सकती है)। यह हमें आदेश बनाए रखने के दौरान समर्पण का एक नया सबसे तेज़ तरीका देता है:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

पायथन 3.7 में , नियमित निर्देशों को सभी कार्यान्वयन में आदेश दिया गया है। तो, सबसे छोटा और सबसे तेज़ समाधान है:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
Question

मुझे एक प्रोग्राम लिखने की ज़रूरत है कि किसी सूची में कोई डुप्लिकेट है या नहीं और यदि यह करता है तो यह उन्हें हटा देता है और उन आइटम्स के साथ एक नई सूची देता है जो डुप्लिकेट / हटाए जाते हैं। मेरे पास यही है लेकिन ईमानदार होने के लिए मुझे नहीं पता कि क्या करना है।

def remove_duplicates():
    t = ['a', 'b', 'c', 'd']
    t2 = ['a', 'c', 'd']
    for t in t2:
        t.append(t.remove())
    return t



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

def ordered_set(in_list):
    out_list = []
    added = set()
    for val in in_list:
        if not val in added:
            out_list.append(val)
            added.add(val)
    return out_list

दक्षता की तुलना करने के लिए, मैंने 100 पूर्णांक का यादृच्छिक नमूना उपयोग किया - 62 अद्वितीय थे

from random import randint
x = [randint(0,100) for _ in xrange(100)]

In [131]: len(set(x))
Out[131]: 62

माप के परिणाम यहां दिए गए हैं

In [129]: %timeit list(OrderedDict.fromkeys(x))
10000 loops, best of 3: 86.4 us per loop

In [130]: %timeit ordered_set(x)
100000 loops, best of 3: 15.1 us per loop

खैर, समाधान से सेट हटा दिए जाने पर क्या होता है?

def ordered_set(inlist):
    out_list = []
    for val in inlist:
        if not val in out_list:
            out_list.append(val)
    return out_list

परिणाम ऑर्डर्ड डिक्ट के साथ उतना बुरा नहीं है, लेकिन मूल समाधान के 3 गुना से भी अधिक है

In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop



L में डुप्लिकेट के पहले तत्वों के क्रम को बनाए रखने के लिए एक नई सूची बनाने के लिए

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

उदाहरण के लिए if L=[1, 2, 2, 3, 4, 2, 4, 3, 5] तो newlist [1,2,3,4,5]

यह जांचता है कि प्रत्येक नया तत्व इसे जोड़ने से पहले सूची में पहले प्रकट नहीं हुआ है। इसके अलावा इसे आयात की आवश्यकता नहीं है।




सेट का उपयोग करना:

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

अद्वितीय का उपयोग करना:

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a



सूची में डुप्लिकेट हटाने के लिए कोड नीचे सरल है

def remove_duplicates(x):
    a = []
    for i in x:
        if i not in a:
            a.append(i)
    return a

print remove_duplicates([1,2,2,3,3,4])

यह [1,2,3,4] लौटाता है




>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> s = []
>>> for i in t:
       if i not in s:
          s.append(i)
>>> s
[1, 2, 3, 5, 6, 7, 8]



यदि आपको आदेश की परवाह नहीं है और ऊपर सुझाए गए पाइथोनिक तरीकों से कुछ अलग करना चाहते हैं (यानी, इसका साक्षात्कार में उपयोग किया जा सकता है) तो:

def remove_dup(arr):
    size = len(arr)
    j = 0    # To store index of next unique element
    for i in range(0, size-1):
        # If current element is not equal
        # to next element then store that
        # current element
        if(arr[i] != arr[i+1]):
            arr[j] = arr[i]
            j+=1

    arr[j] = arr[size-1] # Store the last element as whether it is unique or repeated, it hasn't stored previously

    return arr[0:j+1]

if __name__ == '__main__':
    arr = [10, 10, 1, 1, 1, 3, 3, 4, 5, 6, 7, 8, 8, 9]
    print(remove_dup(sorted(arr)))

समय जटिलता: ओ (एन)

सहायक अंतरिक्ष: ओ (एन)

संदर्भ: http://www.geeksforgeeks.org/remove-duplicates-sorted-array/




आप बस सेट का उपयोग कर ऐसा कर सकते हैं।

चरण 1: सूचियों के विभिन्न तत्व प्राप्त करें
चरण 2 सूचियों के सामान्य तत्व प्राप्त करें
चरण 3 उन्हें संयोजित करें

In [1]: a = ["apples", "bananas", "cucumbers"]

In [2]: b = ["pears", "apples", "watermelons"]

In [3]: set(a).symmetric_difference(b).union(set(a).intersection(b))
Out[3]: {'apples', 'bananas', 'cucumbers', 'pears', 'watermelons'}



यदि आप इनबिल्ट सेट, dict.keys, uniqify, काउंटर का उपयोग किए बिना डुप्लीकेट (नई सूची लौटने के बजाए जगह संपादित करें) को हटाना चाहते हैं, तो इसे जांचें

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> for i in t:
...     if i in t[t.index(i)+1:]:
...         t.remove(i)
... 
>>> t
[3, 1, 2, 5, 6, 7, 8]



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

In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']



आजकल आप काउंटर क्लास का उपयोग कर सकते हैं:

>>> import collections
>>> c = collections.Counter([1, 2, 3, 4, 5, 6, 1, 1, 1, 1])
>>> c.keys()
dict_keys([1, 2, 3, 4, 5, 6])



यह बिना किसी परेशानी के ऑर्डर के बारे में परवाह करता है (ऑर्डरडिक्ट और अन्य)। शायद सबसे पाइथोनिक तरीका नहीं, न ही सबसे छोटा रास्ता, लेकिन चाल है:

def remove_duplicates(list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list



सेट का उपयोग करने का प्रयास करें:

import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])

print t | t1
print t - t1



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

def uniqify(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

यह जनरेटर / इटरेटर देता है, ताकि आप इसे कहीं भी इस्तेमाल कर सकें जिसे आप एक इटरेटर का उपयोग कर सकते हैं।

for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
    print(unique_item, end=' ')

print()

आउटपुट:

1 2 3 4 5 6 7 8

यदि आप एक list चाहते हैं, तो आप यह कर सकते हैं:

unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))

print(unique_list)

आउटपुट:

[1, 2, 3, 4, 5, 6, 7, 8]



मेरी सूची में मेरा एक निर्देश था, इसलिए मैं उपर्युक्त दृष्टिकोण का उपयोग नहीं कर सका। मुझे त्रुटि मिली:

TypeError: unhashable type:

तो यदि आप आदेश के बारे में परवाह करते हैं और / या कुछ आइटम अचूक हैं । फिर आपको यह उपयोगी मिल सकता है:

def make_unique(original_list):
    unique_list = []
    [unique_list.append(obj) for obj in original_list if obj not in unique_list]
    return unique_list

कुछ अच्छे दुष्प्रभाव नहीं होने के लिए साइड इफेक्ट के साथ सूची समझ पर विचार कर सकते हैं। यहां एक विकल्प है:

def make_unique(original_list):
    unique_list = []
    map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list)
    return unique_list





Links