python - समवर्ती सूची में क्या-क्या शामिल है




सूचियों में डुप्लिकेट को हटा रहा है (20)

अगर आपको आदेश की परवाह नहीं है, तो बस यह करें:

def remove_duplicates(l):
    return list(set(l))

एक set की गारंटी है कि डुप्लिकेट न हो।

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

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

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

>>> 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])

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

चरण 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'}

आप यह भी कर सकते हैं:

>>> t = [1, 2, 3, 3, 2, 4, 5, 6]
>>> s = [x for i, x in enumerate(t) if i == t.index(x)]
>>> s
[1, 2, 3, 4, 5, 6]

उपरोक्त कार्यों का कारण यह है कि index विधि केवल तत्व की पहली अनुक्रमणिका देता है। डुप्लिकेट तत्वों में उच्च सूचकांक होते हैं। here देखें:

list.index (x [, शुरू करें [, अंत]])
पहले आइटम की सूची में शून्य-आधारित इंडेक्स लौटाएं जिसका मान x है। यदि कोई ऐसी वस्तु नहीं है तो एक ValueError उठाता है।


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

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

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

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]

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

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

डुप्लिकेट को हटाने के लिए, इसे एक एसईटी बनाएं और फिर इसे एक सूची बनाएं और प्रिंट करें / इसका उपयोग करें। एक सेट को अद्वितीय तत्व होने की गारंटी है। उदाहरण के लिए :

a = [1,2,3,4,5,9,11,15]
b = [4,5,6,7,8]
c=a+b
print c
print list(set(c)) #one line for getting unique elements of c

आउटपुट निम्नानुसार होगा (पायथन 2.7 में चेक किया गया)

[1, 2, 3, 4, 5, 9, 11, 15, 4, 5, 6, 7, 8]  #simple list addition with duplicates
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 15] #duplicates removed!!

मुझे लगता है कि डुप्लिकेट को हटाने का सबसे आसान तरीका सेट पर कनवर्ट करना है:

list1 = [1,2,1]
list1 = list(set(list1))
print list1

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

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

यदि आप इनबिल्ट सेट, 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]

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

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/


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

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

यहां एक उदाहरण है, आदेश को संरक्षित किए बिना दोबारा मरम्मत सूची। किसी बाहरी आयात की आवश्यकता नहीं है।

def GetListWithoutRepetitions(loInput):
    # return list, consisting of elements of list/tuple loInput, without repetitions.
    # Example: GetListWithoutRepetitions([None,None,1,1,2,2,3,3,3])
    # Returns: [None, 1, 2, 3]

    if loInput==[]:
        return []

    loOutput = []

    if loInput[0] is None:
        oGroupElement=1
    else: # loInput[0]<>None
        oGroupElement=None

    for oElement in loInput:
        if oElement<>oGroupElement:
            loOutput.append(oElement)
            oGroupElement = oElement
    return loOutput

सरल और आसान:

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]

आउटपुट:

>>> cleanlist 
[1, 2, 3, 5, 6, 7, 8]

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

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] लौटाता है


सेट का उपयोग किए बिना

data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
    if dat not in uni_data:
        uni_data.append(dat)

print(uni_data) 

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]

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


पायथन 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']

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




intersection