Python मधील सूची (अॅरे) मधून डुप्लिकेट घटक काढा आणि काढा

हा विभाग Python मध्ये सूची (अॅरे) मधून डुप्लिकेट घटक काढून किंवा काढून टाकून नवीन सूची कशी तयार करायची याचे वर्णन करतो.

खालील तपशील येथे वर्णन केले आहेत.

• डुप्लिकेट घटक काढा आणि नवीन सूची तयार करा
  • मूळ सूचीचा क्रम जतन करू नका:set()
  • मूळ सूचीचा क्रम जतन करतो:dict.fromkeys(),sorted()
  • द्विमितीय अॅरे (यादींची सूची)
• डुप्लिकेट घटक काढा आणि नवीन सूची तयार करा
  • मूळ सूचीचा क्रम जतन करू नका
  • मूळ सूचीचा क्रम जतन करतो
  • द्विमितीय अॅरे (यादींची सूची)

हीच संकल्पना सूचीऐवजी ट्यूपल्सवर लागू केली जाऊ शकते.

साठी खालील लेख पहा

• सूची किंवा ट्युपलमध्ये डुप्लिकेट घटक आहेत की नाही हे तुम्ही निर्धारित करू इच्छित असल्यास
• तुम्हाला एकाच सूचीऐवजी एकाधिक सूचींमध्ये सामान्य किंवा सामान्य नसलेले घटक काढायचे असल्यास

• संबंधित:Python मध्ये सूची (अॅरे) मध्ये डुप्लिकेट घटक आहेत की नाही हे निर्धारित करणे

लक्षात ठेवा की याद्या विविध प्रकारचे डेटा संचयित करू शकतात आणि अॅरेपेक्षा काटेकोरपणे भिन्न आहेत. मेमरी आकार आणि मेमरी पत्ते किंवा मोठ्या डेटाची संख्यात्मक प्रक्रिया आवश्यक असलेल्या प्रक्रियांमध्ये तुम्हाला अॅरे हाताळायचे असल्यास, अॅरे (मानक लायब्ररी) किंवा 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]

अर्थात, ते सेट म्हणून देखील सोडले जाऊ शकते. संच प्रकार संचाबद्दल अधिक माहितीसाठी पुढील लेख पहा.

• संबंधित:पायथनच्या सेट प्रकारासह ऑपरेशन्स सेट करा (उदा. युनियन सेट, उत्पादन संच आणि उपसंच)

मूळ सूचीचा क्रम जतन करतो:dict.fromkeys(),sorted()

जर तुम्हाला मूळ सूचीचा क्रम जपायचा असेल, तर डिक्शनरी प्रकारातील कीज() क्लास पद्धत किंवा बिल्ट-इन फंक्शन सॉर्टेड() वापरा.

dict.fromkeys() एक नवीन डिक्शनरी ऑब्जेक्ट बनवते ज्याच्या की या आर्ग्युमेंटमध्ये निर्दिष्ट केलेल्या सूची, टपल्स इ. दुसरा युक्तिवाद वगळल्यास, मूल्य काहीही नाही.

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

डिक्शनरी की मध्ये डुप्लिकेट घटक नसल्यामुळे, सेट() प्रमाणे डुप्लिकेट मूल्यांकडे दुर्लक्ष केले जाते. याशिवाय, डिक्शनरी की ज्या घटकांची यादी आहे ती यादी मिळवण्यासाठी एक डिक्शनरी ऑब्जेक्ट list() कडे वितर्क म्हणून पास केला जाऊ शकतो.

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

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

Python 3.7 (CPython 3.6 आहे) पासून याची हमी देण्यात आली आहे की dict.fromkeys() वितर्क क्रमाचा क्रम राखून ठेवते. आधीच्या आवृत्त्यांमध्ये खालीलप्रमाणे बिल्ट-इन फंक्शन सॉर्टेड() वापरतात.

सॉर्टेडच्या आर्ग्युमेंट कीसाठी लिस्ट ट्यूपल मेथड इंडेक्स () निर्दिष्ट करा, जी घटकांची क्रमवारी लावलेली सूची मिळवते.

index() ही एक पद्धत आहे जी मूल्याची अनुक्रमणिका (सूचीमधील घटकांची संख्या) परत करते, जी मूळ सूचीच्या क्रमानुसार सूची क्रमवारी लावण्यासाठी sorted() ची की म्हणून निर्दिष्ट केली जाऊ शकते. आर्ग्युमेंट की कॉल करण्यायोग्य (कॉल करण्यायोग्य) ऑब्जेक्ट म्हणून निर्दिष्ट केली आहे, म्हणून () लिहू नका.

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'

याचे कारण असे आहे की नॉन-हॅश करण्यायोग्य वस्तू जसे की सूची प्रकार सेटचे घटक किंवा टाइप डिक्टच्या की असू शकत नाहीत.

खालील कार्ये परिभाषित करा मूळ सूचीचा क्रम जतन केला जातो आणि एक-आयामी सूची आणि ट्यूपल्ससाठी कार्य करतो.

• 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) कार्यान्वित केले जाते आणि घटक पाहिलेला जोडला जातो.
कारण append() पद्धत काहीही नाही आणि None is False, not seen.append(x) चे मूल्यमापन खरे ठरते.
सूची आकलन नोटेशनमधील सशर्त अभिव्यक्ती सत्य बनते आणि अंतिम व्युत्पन्न सूचीचा घटक म्हणून जोडली जाते.

जर मूळ सूची अनुक्रमाचे घटक पाहिलेले असतील, तर x न पाहिलेला असत्य असेल आणि सूची आकलन अभिव्यक्तीसाठी सशर्त अभिव्यक्ती असत्य असेल.
म्हणून, ते अंतिम व्युत्पन्न केलेल्या सूचीचे घटक म्हणून जोडले जात नाहीत.

दुसरी पद्धत म्हणजे NumPy च्या फंक्शन np.unique() मध्ये वितर्क अक्ष सेट करणे, जरी निकाल क्रमवारी लावला जाईल.

डुप्लिकेट घटक काढा आणि नवीन सूची तयार करा

मूळ सूचीचा क्रम जतन करू नका

मूळ सूचीमधून फक्त डुप्लिकेट घटक काढण्यासाठी, collections.Counter() वापरा.
एक संग्रह मिळवते. काउंटर (शब्दकोशाचा एक उपवर्ग) की म्हणून घटक आणि मूल्ये म्हणून घटकांची संख्या.

• संबंधित:Python’s Counter सह सूचीतील प्रत्येक घटकाच्या घटनांची संख्या मोजणे

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]

मूळ सूचीचा क्रम जतन करतो

वरील उदाहरणात दाखवल्याप्रमाणे, Python 3.7 पासून, collections.Counter च्या की मूळ यादीचा क्रम कायम ठेवतात आणि असेच.

पूर्वीच्या आवृत्त्यांमध्ये, डुप्लिकेट घटक हटवण्याप्रमाणे, sorted() सह क्रमवारी लावणे पुरेसे आहे.

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

लक्षात घ्या की count() ची संगणकीय जटिलता O(n) असल्याने, वर दर्शविलेले फंक्शन जे वारंवार काउंट() कार्यान्वित करते ते फारच अकार्यक्षम आहे. एक हुशार मार्ग असू शकतो.

काउंटर हा शब्दकोषाचा उपवर्ग आहे, त्यामुळे तुम्ही सूची किंवा ट्यूपल ज्याचे घटक सूची आहेत किंवा इतर नॉन-हॅश करण्यायोग्य वस्तू आहेत संग्रह. काउंटर() मध्ये पास केल्यास एक त्रुटी येईल आणि तुम्ही ते वापरू शकणार नाही.

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