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

पायथन एक अंगभूत डेटा प्रकार, सेट प्रदान करतो, जो सेट हाताळतो.

प्रकार संच हा नॉन-डुप्लिकेट घटकांचा संग्रह आहे (समान मूल्य नसलेले घटक, अद्वितीय घटक) आणि ते युनियन सेट, उत्पादन संच आणि फरक संच यांसारख्या सेट ऑपरेशन्स करू शकतात.

• Set Types — set, frozenset — Python 3.10.4 Documentation

या विभागात, सेट-प्रकार सेट ऑपरेशन्समधील मूलभूत ऑपरेशन्स नमुना कोडसह स्पष्ट केले आहेत.

• सेट ऑब्जेक्ट्सची निर्मिती:{},set()
• समावेश नोटेशन सेट करा
• संचातील घटकांची संख्या:len()
• सेटमध्ये एक घटक जोडणे:add()
• सेटमधून एक घटक काढा:discard(),remove(),pop(),clear()

• वासेट (विलीनीकरण, संघ):|ऑपरेटर,union()
• उत्पादन संच (सामान्य भाग, छेदनबिंदू, छेदनबिंदू):& ऑपरेटर,intersection()
• सापेक्ष पूरक:– ऑपरेटर,difference()
• सममिती फरक सेट:^ ऑपरेटर,symmetric_difference()
• उपसंच किंवा नाही:<= ऑपरेटर,issubset()
• वरचा सेट किंवा नाही:>= ऑपरेटर,issuperset()
• ते परस्पर प्रधान आहेत की नाही याचा निर्धार:isdisjoint()

सेट प्रकार हा एक परिवर्तनीय प्रकार आहे जो घटक जोडू आणि हटवू शकतो आणि एक फ्रोझनसेट प्रकार देखील आहे ज्यामध्ये सेट प्रकाराप्रमाणेच सेट ऑपरेशन आणि इतर पद्धती आहेत परंतु ते अपरिवर्तनीय आहे (घटक जोडून, ​​हटवून किंवा अन्यथा बदल करून सुधारित केले जाऊ शकत नाही. ).

सेट ऑब्जेक्टची निर्मिती::{},set()

वेव्ह ब्रॅकेटद्वारे व्युत्पन्न केले {}

ब्रेसेस {} मध्‍ये घटक संलग्न करून प्रकार सेटचे ऑब्जेक्ट तयार केले जाऊ शकतात.

डुप्लिकेट मूल्ये असल्यास, त्याकडे दुर्लक्ष केले जाते आणि केवळ अद्वितीय मूल्ये घटक म्हणून राहतात.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

घटक म्हणून भिन्न प्रकार असणे शक्य आहे. तथापि, अद्ययावत करण्यायोग्य वस्तू जसे की सूची प्रकार नोंदणीकृत होऊ शकत नाहीत. Tuples परवानगी आहे.

तसेच, संच प्रकार अक्रमित असल्याने, ते ज्या क्रमाने तयार केले जातात ते संग्रहित केले जात नाहीत.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

भिन्न प्रकार, जसे की int आणि फ्लोट, त्यांची मूल्ये समतुल्य असल्यास त्यांना डुप्लिकेट मानले जाते.

s = {100, 100.0}

print(s)
# {100}

रिक्त ब्रेस {} हा शब्दकोष प्रकार मानला जात असल्याने, पुढे वर्णन केलेले कन्स्ट्रक्टर वापरून रिक्त सेट प्रकार ऑब्जेक्ट (रिक्त संच) तयार केला जाऊ शकतो.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

कन्स्ट्रक्टर सेट () द्वारे व्युत्पन्न

कन्स्ट्रक्टर सेट() सह टाइप सेटचे ऑब्जेक्ट्स देखील तयार केले जाऊ शकतात.

पुनरावृत्ती करता येण्याजोग्या ऑब्जेक्ट जसे की सूची किंवा ट्यूपल वितर्क म्हणून निर्दिष्ट केल्याने एक सेट ऑब्जेक्ट तयार होतो ज्याचे घटक केवळ अद्वितीय मूल्ये असतात, डुप्लिकेट घटक वगळलेले असतात.

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

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

कन्स्ट्रक्टर फ्रोझनसेट () सह अपरिवर्तनीय फ्रोझनसेट प्रकार तयार केले जातात.

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

वितर्क वगळल्यास, रिक्त सेट-प्रकार ऑब्जेक्ट (रिक्त संच) तयार केला जातो.

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

डुप्लिकेट घटक सूचीमधून काढले जाऊ शकतात किंवा सेट() वापरून टपल केले जाऊ शकतात, परंतु मूळ सूचीचा क्रम जतन केला जात नाही.

सेट प्रकाराला सूची किंवा ट्यूपलमध्ये रूपांतरित करण्यासाठी, list(), tuple() वापरा.

• संबंधित:list(), tuple() लिस्ट मध्ये रुपांतरित करण्यासाठी आणि ट्यूपल एकमेकांना Python मध्ये

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

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

ऑर्डर जतन करताना डुप्लिकेट घटक काढून टाकणे, केवळ डुप्लिकेट घटक काढणे आणि द्वि-आयामी अॅरेमध्ये डुप्लिकेट घटकांवर प्रक्रिया करणे (यादींची सूची) माहितीसाठी पुढील लेख पहा.

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

समावेश नोटेशन सेट करा

सूची आकलनांप्रमाणेच, निश्चित आकलन देखील आहेत. फक्त चौकोनी कंस [] ब्रेसेस {} सह सूचीच्या आकलनात बदला.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

सूची आकलन नोटेशनबद्दल अधिक माहितीसाठी खालील लेख पहा.

• संबंधित:पायथन सूची आकलन कसे वापरावे

संचातील घटकांची संख्या:len()

बिल्ट-इन फंक्शन len() सह सेटमधील घटकांची संख्या मिळवता येते.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

डुप्लिकेट व्हॅल्यू इ. असलेले घटक असलेल्या प्रत्येक यादीतील घटकांची संख्या तुम्हाला मोजायची असल्यास, पुढील लेख पहा.

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

सेटमध्ये एक घटक जोडणे:add()

सेटमध्ये घटक जोडण्यासाठी, add() पद्धत वापरा.

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

सेटमधून एक घटक काढा:discard(),remove(),pop(),clear()

संचातून घटक काढून टाकण्यासाठी, discard(), remove(), pop(), आणि clear() पद्धती वापरा.

discard() पद्धत आर्ग्युमेंटमध्ये नमूद केलेले घटक हटवते. सेटमध्ये अस्तित्वात नसलेले मूल्य निर्दिष्ट केले असल्यास, काहीही केले जात नाही.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

रिमूव्ह() पद्धत आर्ग्युमेंटमध्ये निर्दिष्ट केलेले घटक देखील काढून टाकते, परंतु सेटमध्ये अस्तित्वात नसलेले मूल्य निर्दिष्ट केल्यास त्रुटी KeyError दिली जाते.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

pop() पद्धत सेटमधून घटक काढून टाकते आणि त्यांची मूल्ये परत करते. कोणती मूल्ये काढायची ते निवडणे शक्य नाही. रिकाम्या संचामुळे की-एरर त्रुटी येईल.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

clear() पद्धत सर्व घटक काढून टाकते आणि सेट रिक्त करते.

s = {0, 1, 2}

s.clear()
print(s)
# set()

वासेट (विलीनीकरण, संघ):|ऑपरेटर,union()

युनियन सेट (विलीनीकरण, युनियन) | सह मिळू शकते ऑपरेटर किंवा युनियन() पद्धत.

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

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

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

उत्पादन संच (सामान्य भाग, छेदनबिंदू, छेदनबिंदू):& ऑपरेटर,intersection()

उत्पादन संच (सामान्य भाग, छेदनबिंदू आणि छेदनबिंदू) & ऑपरेटर किंवा intersection() पद्धत.

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

सापेक्ष पूरक:– ऑपरेटर,difference()

फरक संच – ऑपरेटर किंवा फरक() पद्धतीने मिळवता येतो.

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

सममिती फरक सेट:^ ऑपरेटर,symmetric_difference()

सममितीय फरक संच (दोनपैकी फक्त एकामध्ये समाविष्ट असलेल्या घटकांचा संच) ^ ऑपरेटर किंवा symmetric_difference() सह मिळवता येतो.

तार्किक ऑपरेशन्समध्ये अनन्य डिजंक्शन (XOR) च्या समतुल्य.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

उपसंच किंवा नाही:<= ऑपरेटर,issubset()

संच दुसर्‍या संचाचा उपसंच आहे की नाही हे निर्धारित करण्यासाठी, <= ऑपरेटर किंवा issubset() पद्धत वापरा.

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

<= ऑपरेटर आणि issubset() पद्धती दोन्ही समतुल्य संचांसाठी सत्य परत करतात.

तो खरा उपसंच आहे की नाही हे निर्धारित करण्यासाठी, <= ऑपरेटर वापरा, जो समतुल्य संचांसाठी असत्य दर्शवितो.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

वरचा सेट किंवा नाही:>= ऑपरेटर,issuperset()

एक संच दुसऱ्याचा सुपरसेट आहे की नाही हे निर्धारित करण्यासाठी, >= ऑपरेटर किंवा issuperset() वापरा.

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

>= ऑपरेटर आणि issuperset() पद्धती दोन्ही समतुल्य संचांसाठी सत्य परत करतात.

तो खरा सुपरसेट आहे की नाही हे निर्धारित करण्यासाठी, >= ऑपरेटर वापरा, जो समतुल्य सेटसाठी असत्य परत करतो.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

ते परस्पर प्रधान आहेत की नाही याचा निर्धार:isdisjoint()

दोन संच एकमेकांसाठी प्राइम आहेत की नाही हे निर्धारित करण्यासाठी, isdisjoint() पद्धत वापरा.

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True