पायथन में एक सूची (सरणी) से डुप्लिकेट तत्वों को निकालें और निकालें

व्यापार

यह खंड वर्णन करता है कि किसी सूची (सरणी) से डुप्लिकेट तत्वों को हटाकर या निकालकर पायथन में एक नई सूची कैसे बनाई जाए।

निम्नलिखित विवरण यहाँ वर्णित हैं।

  • डुप्लीकेट तत्व हटाएं और नई लिस्टिंग बनाएं
    • मूल लिस्टिंग के क्रम को सुरक्षित न रखें:set()
    • मूल लिस्टिंग के क्रम को सुरक्षित रखता है:dict.fromkeys(),sorted()
    • द्वि-आयामी सरणी (सूचियों की सूची)
  • डुप्लिकेट तत्व निकालें और एक नई सूची बनाएं
    • मूल लिस्टिंग के क्रम को सुरक्षित न रखें
    • मूल लिस्टिंग के क्रम को सुरक्षित रखता है
    • द्वि-आयामी सरणी (सूचियों की सूची)

समान अवधारणा को सूचियों के बजाय टुपल्स पर लागू किया जा सकता है।

के लिए निम्न आलेख देखें

  • यदि आप यह निर्धारित करना चाहते हैं कि किसी सूची या टपल में डुप्लिकेट तत्व हैं या नहीं
  • यदि आप ऐसे तत्वों को निकालना चाहते हैं जो एक लिस्टिंग के बजाय कई लिस्टिंग के बीच सामान्य या सामान्य नहीं हैं

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

डुप्लीकेट तत्व हटाएं और नई लिस्टिंग बनाएं

मूल लिस्टिंग के क्रम को सुरक्षित न रखें:set()

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

सेट प्रकार एक डेटा प्रकार है जिसमें कोई डुप्लिकेट तत्व नहीं होते हैं। जब कोई सूची या अन्य डेटा प्रकार सेट () को पास किया जाता है, तो डुप्लिकेट मानों को अनदेखा कर दिया जाता है और प्रकार सेट की एक वस्तु वापस कर दी जाती है जिसमें केवल अद्वितीय मान तत्व होते हैं।

यदि आप इसे टपल बनाना चाहते हैं, तो टपल () का उपयोग करें।

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

print(set(l))
# {1, 2, 3, 4, 5}

print(list(set(l)))
# [1, 2, 3, 4, 5]

बेशक, इसे सेट के रूप में भी छोड़ा जा सकता है। सेट प्रकार सेट के बारे में अधिक जानकारी के लिए निम्न आलेख देखें।

मूल लिस्टिंग के क्रम को सुरक्षित रखता है:dict.fromkeys(),sorted()

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

dict.fromkeys() एक नया डिक्शनरी ऑब्जेक्ट बनाता है जिसकी कुंजियाँ सूचियाँ, टुपल्स आदि हैं जो तर्कों में निर्दिष्ट हैं। यदि दूसरा तर्क छोड़ा जाता है, तो मान कोई नहीं है।

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

print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}

print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]

पायथन 3.7 (CPython 3.6 है) के बाद से इसकी गारंटी दी गई है कि dict.fromkeys() तर्क अनुक्रम के क्रम को संरक्षित करता है। पहले के संस्करण अंतर्निहित फ़ंक्शन सॉर्टेड () का उपयोग निम्नानुसार करते हैं।

क्रमबद्ध की तर्क कुंजी के लिए सूची टपल विधि अनुक्रमणिका () निर्दिष्ट करें, जो तत्वों की एक क्रमबद्ध सूची देता है।

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

print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]

द्वि-आयामी सरणी (सूचियों की सूची)

द्वि-आयामी सरणियों (सूचियों की सूची) के लिए, set() या dict.fromkeys() का उपयोग करने वाली विधि एक TypeError में परिणाम देती है।

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'

# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'

ऐसा इसलिए है क्योंकि गैर-हैश करने योग्य वस्तुएं जैसे सूचियां प्रकार सेट के तत्व या प्रकार की कुंजी की कुंजी नहीं हो सकती हैं।

निम्नलिखित कार्यों को परिभाषित करें मूल सूची का क्रम संरक्षित है और एक-आयामी सूचियों और टुपल्स के लिए काम करता है।

def get_unique_list(seq):
    seen = []
    return [x for x in seq if x not in seen and not seen.append(x)]

print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]

print(get_unique_list(l))
# [3, 2, 1, 5, 4]

सूची बोध संकेतन का उपयोग किया जाता है।

यहाँ, हम निम्नलिखित का उपयोग करते हैं:

  • यदि “एक्स और वाई” में एक्स और ऑपरेटर के शॉर्ट-सर्किट मूल्यांकन में गलत है, तो वाई का मूल्यांकन नहीं किया जाता है (निष्पादित नहीं)।
  • एपेंड () विधि कोई नहीं लौटाती है।

यदि मूल सूची seq के तत्व दृश्य में मौजूद नहीं हैं, तो और बाद में मूल्यांकन किया जाता है।
देखा.एपेंड (x) निष्पादित किया जाता है और तत्व को देखा जाता है।
क्योंकि परिशिष्ट () विधि कोई नहीं लौटाती है और कोई भी गलत नहीं है, देखा नहीं जाता है। संलग्न करें (x) सत्य का मूल्यांकन करता है।
सूची बोध संकेतन में सशर्त अभिव्यक्ति सही हो जाती है और इसे अंतिम उत्पन्न सूची के एक तत्व के रूप में जोड़ा जाता है।

यदि मूल सूची seq के तत्व सीन में मौजूद हैं, तो x नॉट इन सीन गलत है, और लिस्ट कॉम्प्रिहेंशन एक्सप्रेशन के लिए कंडीशनल एक्सप्रेशन गलत है।
इसलिए, उन्हें अंतिम जेनरेट की गई सूची के तत्वों के रूप में नहीं जोड़ा जाता है।

दूसरा तरीका है तर्क अक्ष को NumPy के फ़ंक्शन np.unique() में सेट करना, हालांकि परिणाम को सॉर्ट किया जाएगा।

डुप्लिकेट तत्व निकालें और एक नई सूची बनाएं

मूल लिस्टिंग के क्रम को सुरक्षित न रखें

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

import collections

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

print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})

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

print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]

मूल लिस्टिंग के क्रम को सुरक्षित रखता है

जैसा कि ऊपर के उदाहरण में दिखाया गया है, पायथन 3.7 के बाद से, संग्रह की कुंजी। काउंटर मूल सूची के क्रम को बनाए रखता है और इसी तरह।

पिछले संस्करणों में, सॉर्ट किए गए() के साथ सॉर्ट करना पर्याप्त है, जैसा कि डुप्लिकेट तत्वों को हटा रहा है।

print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]

यदि आप डुप्लिकेट को वैसे ही निकालना चाहते हैं जैसे वे हैं, तो मूल सूची से तत्वों को दो या अधिक की संख्या के साथ छोड़ दें। आदेश भी संरक्षित है।

cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]

द्वि-आयामी सरणी (सूचियों की सूची)

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

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

def get_duplicate_list(seq):
    seen = []
    return [x for x in seq if not seen.append(x) and seen.count(x) == 2]

def get_duplicate_list_order(seq):
    seen = []
    return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]

print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]

print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]

print(get_duplicate_list(l))
# [3, 1, 2]

print(get_duplicate_list_order(l))
# [3, 2, 1]

यदि आप डुप्लिकेट के साथ निकालना चाहते हैं, तो मूल सूची से तत्वों को दो या अधिक की गिनती के साथ छोड़ दें।

print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]

ध्यान दें कि चूंकि गणना () की कम्प्यूटेशनल जटिलता ओ (एन) है, ऊपर दिखाया गया फ़ंक्शन जो बार-बार गिनती () निष्पादित करता है, बहुत अक्षम है। एक होशियार तरीका हो सकता है।

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

# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'