पायथन के सेट प्रकार के साथ संचालन सेट करें (उदाहरण के लिए, यूनियन सेट, उत्पाद सेट और सबसेट निर्धारित करना)

व्यापार

पायथन एक अंतर्निहित डेटा प्रकार, सेट प्रदान करता है, जो सेट को संभालता है।

प्रकार सेट गैर-डुप्लिकेट तत्वों का संग्रह है (ऐसे तत्व जो समान मान नहीं हैं, अद्वितीय तत्व हैं) और संघ सेट, उत्पाद सेट और अंतर सेट जैसे सेट संचालन कर सकते हैं।

इस खंड में, सेट-टाइप सेट ऑपरेशंस में बेसिक ऑपरेशंस को सैंपल कोड के साथ समझाया गया है।

  • सेट वस्तुओं का निर्माण:{},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'>

तत्वों के रूप में विभिन्न प्रकार होना संभव है। हालाँकि, अद्यतन करने योग्य ऑब्जेक्ट जैसे सूची प्रकार पंजीकृत नहीं किए जा सकते हैं। टुपल्स की अनुमति है।

साथ ही, चूंकि सेट प्रकार अनियंत्रित होते हैं, इसलिए जिस क्रम में वे उत्पन्न होते हैं वह संग्रहीत नहीं होता है।

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

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

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

विभिन्न प्रकार, जैसे कि इंट और फ्लोट, को डुप्लिकेट माना जाता है यदि उनके मान समान हैं।

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

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

किसी सेट प्रकार को सूची या टपल में बदलने के लिए, सूची (), टुपल () का उपयोग करें।

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

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

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

समावेशन संकेतन सेट करें

साथ ही सूची समझ, सेट समझ हैं। सूची बोध में बस वर्ग कोष्ठक [] को ब्रेसिज़ {} से बदलें।

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

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

सूची बोध संकेतन के बारे में अधिक जानकारी के लिए निम्न आलेख देखें।

सेट में तत्वों की संख्या:len()

एक सेट में तत्वों की संख्या बिल्ट-इन फ़ंक्शन लेन () के साथ प्राप्त की जा सकती है।

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

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

यदि आप प्रत्येक सूची में तत्वों की संख्या की गणना करना चाहते हैं जिनमें डुप्लिकेट मान वाले तत्व हैं, आदि, निम्न आलेख देखें।

एक सेट में एक तत्व जोड़ना:add()

एक सेट में एक तत्व जोड़ने के लिए, ऐड () विधि का उपयोग करें।

s = {0, 1, 2}

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

एक सेट से एक तत्व निकालें:discard(),remove(),pop(),clear()

एक सेट से एक तत्व को हटाने के लिए, त्यागें (), निकालें (), पॉप (), और स्पष्ट () विधियों का उपयोग करें।

डिस्कार्ड () विधि तर्क में निर्दिष्ट तत्व को हटा देती है। यदि कोई मान जो सेट में मौजूद नहीं है निर्दिष्ट किया जाता है, तो कुछ भी नहीं किया जाता है।

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

पॉप () विधि एक सेट से तत्वों को हटाती है और उनके मान लौटाती है। यह चुनना संभव नहीं है कि किन मूल्यों को हटाया जाए। एक खाली सेट के परिणामस्वरूप KeyError त्रुटि होगी।

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'

स्पष्ट () विधि सभी तत्वों को हटा देती है और सेट को खाली कर देती है।

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

उत्पाद सेट (सामान्य भाग, चौराहा, और चौराहा) & ऑपरेटर या प्रतिच्छेदन () विधि।

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

सममित अंतर सेट (दो में से केवल एक में निहित तत्वों का सेट) ^ ऑपरेटर या सममित_अंतर () के साथ प्राप्त किया जा सकता है।

लॉजिकल ऑपरेशंस में एक्सक्लूसिव डिसजंक्शन (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
Copied title and URL