पायथन सेट ऑपरेशन

सेट क्या है?

गणित में, एक सेट विशिष्ट वस्तुओं का संग्रह है, जिसे अपने आप में एक वस्तु माना जाता है। उदाहरण के लिए, संख्याएं 2, 4, और 6 अलग-अलग मानी जाती हैं, लेकिन जब उन्हें सामूहिक रूप से माना जाता है तो वे आकार तीन का एक सेट बनाते हैं, जिसे {2,4,6} लिखा जाता है।

सेट पर ऑपरेशन

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

सेट के लिए विधियां

add(x) विधि:

यदि आइटम x पहले से मौजूद नहीं है तो उसे सेट में जोड़ता है।

A = {"AA", "BB", "CC"}
A.add("VV")

यह VV को A सेट में जोड़ देगा।

union(s) विधि:

दो सेट का यूनियन लौटाता है। दो मौजूदा सेट के बीच '|' ऑपरेटर का उपयोग करना My_Set1.union(My_Set2) लिखने के समान है।

A = {"AA", "BB", "CC"}
B = {"MM", "NN"}
Z = A.union(B)  # या Z = A|B

सेट Z में A और B दोनों के घटक होंगे।

intersection(s) विधि:

दो दिए गए सेट का इंटरसेक्शन लौटाता है। इस ऑपरेशन में '&' ऑपरेटर का उपयोग किया जा सकता है।

S = A.intersection(B)

सेट S में A और B के सामान्य तत्व होंगे।

difference(s) विधि:

एक सेट लौटाता है जिसमें पहले सेट में मौजूद सभी तत्व होते हैं लेकिन दूसरे सेट में मौजूद नहीं होते। हम यहां '-' ऑपरेटर का उपयोग कर सकते हैं।

W = A.difference(B)  # या S = A - B

सेट W में वे सभी तत्व होंगे जो A में हैं लेकिन B में नहीं।

clear() विधि:

पूरा मौजूदा सेट खाली हो जाएगा।

B.clear()

सेट B साफ हो जाता है।

सेट के लिए ऑपरेटर

सेट और फ्रोजन सेट निम्नलिखित ऑपरेटर का समर्थन करते हैं:

key in s          # सदस्यता जांच
key not in s      # गैर-सदस्यता जांच
s1 == s2          # s1, s2 के बराबर है
s1 != s2          # s1, s2 के बराबर नहीं है
s1 <= s2          # s1, s2 का सबसेट है
s1 < s2           # s1, s2 का उचित सबसेट है
s1 >= s2          # s1, s2 का सुपरसेट है
s1 > s2           # s1, s2 का उचित सुपरसेट है
s1 | s2           # s1 और s2 का यूनियन
s1 & s2           # s1 और s2 का इंटरसेक्शन
s1 - s2           # s1 में लेकिन s2 में नहीं तत्वों का सेट
s1 ^ s2           # s1 या s2 में से ठीक एक में तत्वों का सेट

उदाहरण कोड

# पायथन में सेट के कामकाज को प्रदर्शित करने का प्रोग्राम
# दो सेट बनाएं
My_Set1 = set()
My_Set2 = set()

# My_Set1 में तत्व जोड़ें
for i in range(1, 6):
    My_Set1.add(i)

# My_Set2 में तत्व जोड़ें
for i in range(3, 8):
    My_Set2.add(i)

print("My_Set1 = ", My_Set1)
print("My_Set2 = ", My_Set2)
print()

# My_Set1 और My_Set2 का यूनियन
My_Set3 = My_Set1 | My_Set2  # My_Set1.union(My_Set2)
print("My_Set1 और My_Set2 का यूनियन: My_Set3 = ", My_Set3)

# My_Set1 और My_Set2 का इंटरसेक्शन
My_Set4 = My_Set1 & My_Set2  # My_Set1.intersection(My_Set2)
print("My_Set1 और My_Set2 का इंटरसेक्शन: My_Set4 = ", My_Set4)
print()

# My_Set3 और My_Set4 के बीच संबंध जांचें
if My_Set3 > My_Set4:  # My_Set3.issuperset(My_Set4)
    print("My_Set3, My_Set4 का सुपरसेट है")
elif My_Set3 < My_Set4:  # My_Set3.issubset(My_Set4)
    print("My_Set3, My_Set4 का सबसेट है")
else:
    print("My_Set3, My_Set4 के समान है")

# My_Set4 और My_Set3 के बीच संबंध प्रदर्शित करें
if My_Set4 < My_Set3:  # My_Set4.issubset(My_Set3)
    print("My_Set4, My_Set3 का सबसेट है")
print()

# My_Set3 और My_Set4 के बीच अंतर
My_Set5 = My_Set3 - My_Set4
print("My_Set3 में तत्व और My_Set4 में नहीं: My_Set5 = ", My_Set5)
print()

# जांचें कि My_Set4 और My_Set5 डिस्जॉइंट सेट हैं या नहीं
if My_Set4.isdisjoint(My_Set5):
    print("My_Set4 और My_Set5 में कुछ भी सामान्य नहीं है\n")

# My_Set5 के सभी मान हटाएं
My_Set5.clear()
print("My_Set5 पर क्लियर लागू करने के बाद: ")
print("My_Set5 = ", My_Set5)

आउटपुट

My_Set1 = {1, 2, 3, 4, 5}
My_Set2 = {3, 4, 5, 6, 7}
My_Set1 और My_Set2 का यूनियन: My_Set3 = {1, 2, 3, 4, 5, 6, 7}
My_Set1 और My_Set2 का इंटरसेक्शन: My_Set4 = {3, 4, 5}
My_Set3, My_Set4 का सुपरसेट है
My_Set4, My_Set3 का सबसेट है
My_Set3 में तत्व और My_Set4 में नहीं: My_Set5 = {1, 2, 6, 7}
My_Set4 और My_Set5 में कुछ भी सामान्य नहीं है
My_Set5 पर क्लियर लागू करने के बाद:
My_Set5 = set()