python वर्तमान - सूचियों में डुप्लिकेट को हटा रहा है




राज्यसूची 9वी (25)

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

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

Answers

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

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

पांडो और नम्पी का उपयोग कर समाधान भी हैं। वे दोनों numpy सरणी लौटते हैं ताकि आपको फ़ंक्शन का उपयोग करना .tolist() यदि आप एक सूची चाहते हैं।

t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']

पांडस समाधान

पांडस फ़ंक्शन का उपयोग unique() :

import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']

बेवकूफ समाधान

Numpy फ़ंक्शन unique() का उपयोग करना।

import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']

ध्यान दें कि numpy.unique () मानों को भी क्रमबद्ध करता है । तो सूची टी 2 क्रमबद्ध किया गया है। यदि आप इस उत्तर में ऑर्डर संरक्षित उपयोग करना चाहते हैं:

_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']

समाधान दूसरों की तुलना में इतना सुरुचिपूर्ण नहीं है, हालांकि, pandas.unique (), numpy.unique () की तुलना में आप यह भी जांचने की अनुमति देते हैं कि नेस्टेड सरणी एक चयनित अक्ष के साथ अद्वितीय हैं या नहीं।


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

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

print t | t1
print t - t1

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

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

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

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

आदेश देने के साथ संस्करण को कम करें:

मान लें कि हमारे पास सूची है:

l = [5, 6, 6, 1, 1, 2, 2, 3, 4]

संस्करण कम करें (अक्षम):

>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]

5 एक्स तेज लेकिन अधिक परिष्कृत

>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]

स्पष्टीकरण:

default = (list(), set())
# user list to keep order
# use set to make lookup faster

def reducer(result, item):
    if item not in result[1]:
        result[0].append(item)
        result[1].add(item)
    return result

reduce(reducer, l, default)[0]

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

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]

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

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]

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


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

>>> 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 remove_duplicates(A):
   [A.pop(count) for count,elem in enumerate(A) if A.count(elem)!=1]
   return A

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


यह एक लाइनर है: list(set(source_list)) चाल करेगा।

एक set ऐसा कुछ है जो संभवतः डुप्लिकेट नहीं कर सकता है।

अद्यतन: ऑर्डर-संरक्षित दृष्टिकोण दो पंक्तियां है:

from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()

यहां हम इस तथ्य का उपयोग करते हैं कि OrderedDict कुंजी के सम्मिलन क्रम को याद करता है, और जब कोई विशेष कुंजी पर कोई मान अपडेट नहीं किया जाता है तो उसे बदल नहीं आता है। हम मूल्यों के रूप में True डालें, लेकिन हम कुछ भी सम्मिलित कर सकते हैं, मानों का उपयोग नहीं किया जाता है। ( set अनदेखा मूल्यों के साथ एक dict तरह बहुत काम करता है।)


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

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


उत्तर में सूचीबद्ध अन्य लोगों की तुलना में सबसे तेज़ पायथनिक समाधान यहां दिया गया है।

शॉर्ट सर्किट मूल्यांकन के कार्यान्वयन विवरण का उपयोग सूची समझ का उपयोग करने की अनुमति देता है, जो पर्याप्त तेज़ है। visited.add(item) हमेशा परिणाम के रूप में None देता है, जिसका मूल्यांकन False , इसलिए दायीं तरफ or हमेशा ऐसी अभिव्यक्ति का परिणाम होगा।

इसे अपने आप समय दें

def deduplicate(sequence):
    visited = set()
    adder = visited.add  # get rid of qualification overhead
    out = [adder(item) or item for item in sequence if item not in visited]
    return out

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

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

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

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) 

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

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/


मैंने यहां तक ​​कि सभी ऑर्डर-संरक्षित दृष्टिकोणों को अब तक OrderedDicts तुलना (ओ (एन ^ 2) समय-जटिलता के साथ सबसे अच्छा उपयोग किया है) या हेवी-वेट OrderedDicts / set + list संयोजन जो OrderedDicts इनपुट तक सीमित हैं। यहां एक हैश-स्वतंत्र ओ (nlogn) समाधान है:

अद्यतन key तर्क, प्रलेखन और पायथन 3 संगतता जोड़ा गया।

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))] 

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

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

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

करने का एक और तरीका:

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

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

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

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


वस्तुओं का अनूठा संग्रह प्राप्त करने का सामान्य दृष्टिकोण एक set का उपयोग करना set । सेट अलग वस्तुओं के अनियंत्रित संग्रह हैं। किसी भी पुनरावर्तनीय से सेट बनाने के लिए, आप बस इसे अंतर्निहित set() फ़ंक्शन पर पास कर सकते हैं। यदि आपको बाद में एक वास्तविक सूची की आवश्यकता है, तो आप सेट को list() फ़ंक्शन पर भी पास कर सकते हैं।

निम्नलिखित उदाहरण को जो भी आप करने का प्रयास कर रहे हैं उसे कवर करना चाहिए:

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]

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

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

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

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

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


append(object) - किसी ऑब्जेक्ट को सूची में जोड़कर सूची अपडेट करता है।

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - अनिवार्य रूप से दो सूचियों को जोड़ता है।

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]




python algorithm list duplicates intersection