पाइथनमा सूची (एरे) बाट नक्कल तत्वहरू हटाउनुहोस् र निकाल्नुहोस्

यो खण्डले सूची (एरे) बाट नक्कल तत्वहरू हटाएर वा निकालेर पाइथनमा कसरी नयाँ सूची सिर्जना गर्ने भनेर वर्णन गर्दछ।

निम्न विवरणहरू यहाँ वर्णन गरिएको छ।

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

एउटै अवधारणा सूचीको सट्टा tuples मा लागू गर्न सकिन्छ।

को लागी निम्न लेख हेर्नुहोस्

• यदि तपाइँ सूची वा टुपलमा नक्कल तत्वहरू छन् कि भनेर निर्धारण गर्न चाहनुहुन्छ भने
• यदि तपाइँ तत्वहरू निकाल्न चाहानुहुन्छ जुन एकल सूचीको सट्टा बहु सूचीहरू बीच साझा वा सामान्य छैन

• सम्बन्धित:पाइथनमा सूची (एरे) डुप्लिकेट तत्वहरू छन् भने निर्धारण गर्दै

नोट गर्नुहोस् कि सूचीहरूले विभिन्न प्रकारका डेटा भण्डारण गर्न सक्छ र एरेहरू भन्दा कडा रूपमा फरक छन्। यदि तपाइँ प्रक्रियाहरूमा एरेहरू ह्यान्डल गर्न चाहनुहुन्छ जुन मेमोरी साइज र मेमोरी ठेगानाहरू वा ठूलो डाटाको संख्यात्मक प्रशोधन आवश्यक पर्दछ, एरे (मानक पुस्तकालय) वा NumPy प्रयोग गर्नुहोस्।

डुप्लिकेट तत्वहरू हटाउनुहोस् र नयाँ सूचीहरू उत्पन्न गर्नुहोस्

मूल सूचीको क्रम सुरक्षित नगर्नुहोस्:set()

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

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

यदि तपाइँ यसलाई टपल बनाउन चाहनुहुन्छ भने, tuple() प्रयोग गर्नुहोस्।

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]

निस्सन्देह, यो पनि सेट रूपमा छोड्न सकिन्छ। सेट प्रकार सेट ’bout थप जानकारीको लागि निम्न लेख हेर्नुहोस्।

• सम्बन्धित:पाइथनको सेट प्रकारको साथ सेट अपरेशनहरू (जस्तै, युनियन सेटहरू, उत्पादन सेटहरू, र उपसेटहरू निर्धारण गर्ने)

मूल सूचीको क्रम सुरक्षित गर्दछ:dict.fromkeys(),sorted()

यदि तपाइँ मूल सूचीको क्रम सुरक्षित गर्न चाहनुहुन्छ भने, शब्दकोष प्रकारको कुञ्जी() वा बिल्ट-इन प्रकार्य क्रमबद्ध () को वर्ग विधि प्रयोग गर्नुहोस्।

dict.fromkeys() ले एउटा नयाँ शब्दकोश वस्तु सिर्जना गर्दछ जसको कुञ्जीहरू तर्कहरूमा निर्दिष्ट गरिएका सूचीहरू, टपल्स, आदि हुन्। यदि दोस्रो तर्क मेटाइयो भने, मान कुनै पनि छैन।

• classmethod fromkeys(iterable[, value]) — Built-in Types — Python 3.10.4 Documentation

शब्दकोश कुञ्जीहरूमा डुप्लिकेट तत्वहरू नभएकोले, नक्कल मानहरूलाई सेट() मा जस्तै बेवास्ता गरिन्छ। थप रूपमा, एक शब्दकोश वस्तुलाई सूची () मा तर्कको रूपमा पास गर्न सकिन्छ जसका तत्वहरू शब्दकोश कुञ्जीहरू हुन्।

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() ले आर्गुमेन्ट अनुक्रमको क्रम सुरक्षित गर्दछ। अघिल्लो संस्करणहरूले निम्नानुसार बिल्ट-इन प्रकार्य क्रमबद्ध () प्रयोग गर्दछ।

क्रमबद्धको आर्गुमेन्ट कुञ्जीका लागि सूची tuple विधि अनुक्रमणिका () निर्दिष्ट गर्नुहोस्, जसले तत्वहरूको क्रमबद्ध सूची फर्काउँछ।

index() एक विधि हो जसले मूल्यको अनुक्रमणिका (सूचीमा तत्वको संख्या) फर्काउँछ, जुन मूल सूचीको क्रमको आधारमा सूची क्रमबद्ध गर्न sorted() को कुञ्जीको रूपमा निर्दिष्ट गर्न सकिन्छ। आर्गुमेन्ट कुञ्जीलाई कल गर्न मिल्ने (कल गर्न मिल्ने) वस्तुको रूपमा निर्दिष्ट गरिएको छ, त्यसैले () नलेख्नुहोस्।

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

दुई-आयामी एरे (सूचीहरूको सूची)

दुई-आयामी एरेहरूका लागि (सूचीहरूको सूची), सेट() वा 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'

यो ’cause गैर-ह्यास गर्न मिल्ने वस्तुहरू जस्तै सूचीहरू प्रकार सेटको तत्वहरू वा टाइप डिक्टको कुञ्जीहरू हुन सक्दैनन्।

निम्न प्रकार्यहरू परिभाषित गर्नुहोस् मूल सूचीको क्रम सुरक्षित गरिएको छ र एक-आयामी सूचीहरू र टुपलहरूको लागि काम गर्दछ।

• python – How do you remove duplicates from a list whilst preserving order? – Stack Overflow

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]

सूची समझ संकेतन प्रयोग गरिन्छ।

• सम्बन्धित:पाइथन सूची समझ कसरी प्रयोग गर्ने

यहाँ, हामी निम्न प्रयोग गर्दछौं

• यदि “X र Y” मा X र अपरेटरको छोटो-सर्किट मूल्याङ्कनमा गलत छ भने, Y मूल्याङ्कन हुँदैन (कार्यान्वयन गरिएको छैन)।
• append() विधिले कुनै पनि फर्काउँदैन।

यदि मूल सूची seq को तत्वहरू देखिएकामा अवस्थित छैनन् भने, त्यसपछि र पछि मूल्याङ्कन गरिन्छ।
see.append(x) लाई कार्यान्वयन गरिएको छ र तत्व देखाइएकोमा थपिएको छ।
’cause append() विधिले None फर्काउँछ र None False, not देखीएको छ। append(x) ले True मा मूल्याङ्कन गर्छ।
सूची बुझ्ने सङ्केतमा सशर्त अभिव्यक्ति True हुन्छ र अन्तिम उत्पन्न सूचीको तत्वको रूपमा थपिन्छ।

यदि मूल सूची seq को तत्वहरू देखा परेका छन् भने, x नदेखेको False हो, र सूची समझ अभिव्यक्तिको लागि सशर्त अभिव्यक्ति False हो।
त्यसकारण, तिनीहरू अन्तिम उत्पन्न सूचीको तत्वहरूको रूपमा थपिएका छैनन्।

अर्को विधि 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]

मूल सूचीको क्रम सुरक्षित गर्दछ

माथिको उदाहरणमा देखाइए अनुसार, पाइथन ३.७ देखि, सङ्कलनका कुञ्जीहरू। काउन्टरले मूल सूचीको क्रम कायम राख्छ र यस्तै।

अघिल्लो संस्करणहरूमा, क्रमबद्ध () सँग क्रमबद्ध गर्न पर्याप्त छ, जस्तै डुप्लिकेट तत्वहरू मेटाउने।

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]

दुई-आयामी एरे (सूचीहरूको सूची)

दुई-आयामी arrays (सूचीहरूको सूची) को लागि, निम्न प्रकार्यहरू सम्भव छन् जब मूल सूचीको क्रम राखिएको छैन र जब यसलाई क्रमशः राखिएको छ। यो एक-आयामी सूची र tuples को लागी पनि काम गर्दछ।

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

नोट गर्नुहोस् कि काउन्ट() को कम्प्युटेसनल जटिलता O(n) भएकोले, माथि देखाइएको प्रकार्य जसले बारम्बार count() लाई कार्यान्वयन गर्छ धेरै अप्रभावी छ। त्यहाँ एक स्मार्ट तरिका हुन सक्छ।

counter

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