सेट करो

सेट, वैल्यू को जोड़ने, हटाने या उसकी मौजूदगी की जांच करने के लिए, कॉन्स्टेंट-टाइम ऑपरेशन उपलब्ध कराते हैं. सेट को हैश टेबल का इस्तेमाल करके लागू किया जाता है. इसलिए, डिक्शनरी की कुंजियों की तरह ही, सेट के एलिमेंट को हैश किया जा सकता है. किसी वैल्यू को सेट के एलिमेंट के तौर पर तब ही इस्तेमाल किया जा सकता है, जब उसे डिक्शनरी की कुंजी के तौर पर इस्तेमाल किया जा सकता हो.

सेट बनाने के लिए, set() बिल्ट-इन फ़ंक्शन का इस्तेमाल किया जा सकता है. यह फ़ंक्शन, अपने वैकल्पिक आर्ग्युमेंट के यूनीक एलिमेंट वाला एक नया सेट दिखाता है. यह आर्ग्युमेंट, एक बार में कई आइटम प्रोसेस करने वाला होना चाहिए. बिना किसी तर्क के set() को कॉल करने पर, एक खाली सेट बनता है. सेट में कोई लिटरल सिंटैक्स नहीं होता.

in और not in ऑपरेटर यह जांच करते हैं कि कोई वैल्यू किसी सेट में है या नहीं:

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

सेट को दोहराया जा सकता है. इसलिए, इसका इस्तेमाल for लूप, लिस्ट कंप्रीहेंशन, और दोहराए जा सकने वाले आइटम पर काम करने वाले अलग-अलग बिल्ट-इन फ़ंक्शन के ऑपरेंड के तौर पर किया जा सकता है. इसकी लंबाई को len() बिल्ट-इन फ़ंक्शन का इस्तेमाल करके वापस पाया जा सकता है. साथ ही, पुनरावृति का क्रम वही होता है जिसमें एलिमेंट को सेट में पहली बार जोड़ा गया था:

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

बूलियन कॉन्टेक्स्ट में इस्तेमाल किया गया सेट, सिर्फ़ तब सही होता है, जब वह खाली न हो.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

== और != का इस्तेमाल करके, सेट की तुलना की जा सकती है कि वे बराबर हैं या नहीं. एक सेट s, t के बराबर तब होता है, जब t एक ऐसा सेट हो जिसमें s के सभी एलिमेंट शामिल हों. हालांकि, इसमें एलिमेंट के क्रम से कोई फ़र्क़ नहीं पड़ता. खास तौर पर, कोई सेट, उसके एलिमेंट की सूची के बराबर नहीं होता. सेट को दूसरे सेट के हिसाब से क्रम में नहीं लगाया जाता. साथ ही, <, <=, >, >= का इस्तेमाल करके दो सेट की तुलना करने या सेट के क्रम को क्रम से लगाने की कोशिश करने पर, ऐसा नहीं हो पाएगा.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

दो सेट पर | ऑपरेशन करने से, दोनों सेट का यूनीयन मिलता है. यह एक ऐसा सेट होता है जिसमें मूल सेट में से किसी एक या दोनों में मौजूद एलिमेंट शामिल होते हैं.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

दो सेट पर & ऑपरेशन करने से, दोनों सेट का इंटरसेक्शन मिलता है. यह एक ऐसा सेट होता है जिसमें सिर्फ़ वे एलिमेंट होते हैं जो दोनों ओरिजनल सेट में मौजूद होते हैं.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

दो सेट पर - ऑपरेशन करने से, दोनों सेट के बीच का अंतर मिलता है. यह एक ऐसा सेट होता है जिसमें बाईं ओर मौजूद सेट में शामिल एलिमेंट होते हैं, लेकिन दाईं ओर मौजूद सेट में शामिल एलिमेंट नहीं होते.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])

दो सेट पर ^ ऑपरेशन करने से, दोनों सेट के बीच का सिमेट्रिक अंतर मिलता है. यह एक ऐसा सेट होता है जिसमें वे एलिमेंट शामिल होते हैं जो दोनों ओरिजनल सेट में से सिर्फ़ एक में मौजूद होते हैं, लेकिन दोनों में नहीं.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

ऊपर दी गई हर कार्रवाई में, नतीजे के तौर पर मिले सेट के एलिमेंट, ऑपरेंड के दोनों सेट के क्रम में ही होते हैं. साथ ही, बाईं ओर मौजूद सेट से लिए गए सभी एलिमेंट, दाईं ओर मौजूद सेट में मौजूद एलिमेंट से पहले क्रम में होते हैं.

|=, &=, -=, और ^= जैसे असाइनमेंट ऑपरेटर, बाईं ओर मौजूद सेट में बदलाव करते हैं.

s = set([1, 2])
s |= set([2, 3, 4])     # s now equals set([1, 2, 3, 4])
s &= set([0, 1, 2, 3])  # s now equals set([1, 2, 3])
s -= set([0, 1])        # s now equals set([2, 3])
s ^= set([3, 4])        # s now equals set([2, 4])

Starlark में बदली जा सकने वाली सभी वैल्यू की तरह, सेट को भी फ़्रीज़ किया जा सकता है. फ़्रीज़ करने के बाद, इसे अपडेट करने की कोशिश करने वाले सभी ऑपरेशन पूरे नहीं होंगे.

सदस्य

• जोड़ें
• मिटाएं
• अंतर
• difference_update
• खारिज करें
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• पॉप
• निकालें
• symmetric_difference
• symmetric_difference_update
• union
• अपडेट करें

जोड़ें

None set.add(element)

सेट में पहले से मौजूद वैल्यू को add किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.

अगर आपको किसी सेट में एक से ज़्यादा एलिमेंट जोड़ने हैं, तो update या |= ऑगमेंटेड असाइनमेंट ऑपरेशन देखें.

पैरामीटर

मिटाएं

None set.clear()

अंतर करें

set set.difference(*others)

अगर s और t सेट हैं, तो s.difference(t), s - t के बराबर है. हालांकि, ध्यान दें कि - ऑपरेशन के लिए, दोनों तरफ़ सेट होने चाहिए. वहीं, difference तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

difference को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट की कॉपी मिलती है.

उदाहरण के लिए,

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

पैरामीटर

difference_update

None set.difference_update(*others)

अगर s और t सेट हैं, तो s.difference_update(t), s -= t के बराबर है. हालांकि, ध्यान दें कि -= ऑगमेंटेड असाइनमेंट के लिए, दोनों साइड के सेट होने ज़रूरी हैं. वहीं, difference_update तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

difference_update को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.

उदाहरण के लिए,

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

पैरामीटर

खारिज करें

None set.discard(element)

सेट में मौजूद नहीं है, तो वैल्यू को discard किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता. अगर आपको किसी ऐसे एलिमेंट को हटाने की कोशिश करने पर टेस्ट को फ़ेल करना है जो मौजूद नहीं है, तो remove का इस्तेमाल करें. अगर आपको किसी सेट से एक से ज़्यादा एलिमेंट हटाने हैं, तो difference_update या -= ऑगमेंटेड असाइनमेंट ऑपरेशन देखें.

उदाहरण के लिए,

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

पैरामीटर

इंटरसेक्शन

set set.intersection(*others)

अगर s और t सेट हैं, तो s.intersection(t), s & t के बराबर है. हालांकि, ध्यान दें कि & ऑपरेशन के लिए, दोनों साइड को सेट होना ज़रूरी है. वहीं, intersection तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

intersection को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट की कॉपी मिलती है.

उदाहरण के लिए,

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

पैरामीटर

intersection_update

None set.intersection_update(*others)

अगर s और t सेट हैं, तो s.intersection_update(t), s &= t के बराबर है. हालांकि, ध्यान दें कि &= ऑगमेंटेड असाइनमेंट के लिए, दोनों पक्षों का सेट होना ज़रूरी है. वहीं, intersection_update तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

intersection_update को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.

उदाहरण के लिए,

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

पैरामीटर

isdisjoint

bool set.isdisjoint(other)

उदाहरण के लिए,

set([1, 2]).isdisjoint([3, 4])  # True
set().isdisjoint(set())         # True
set([1, 2]).isdisjoint([2, 3])  # False

पैरामीटर

issubset

bool set.issubset(other)

ध्यान दें कि किसी सेट को हमेशा उसका सबसेट माना जाता है.

उदाहरण के लिए,

set([1, 2]).issubset([1, 2, 3])  # True
set([1, 2]).issubset([1, 2])     # True
set([1, 2]).issubset([2, 3])     # False

पैरामीटर

issuperset

bool set.issuperset(other)

ध्यान दें कि किसी सेट को हमेशा खुद का सुपरसेट माना जाता है.

उदाहरण के लिए,

set([1, 2, 3]).issuperset([1, 2])     # True
set([1, 2, 3]).issuperset([1, 2, 3])  # True
set([1, 2, 3]).issuperset([2, 3, 4])  # False

पैरामीटर

पॉप

unknown set.pop()

सेट खाली होने पर, यह फ़ंक्शन काम नहीं करता.

उदाहरण के लिए,

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

कॉन्टेंट हटाना

None set.remove(element)

अगर सेट में एलिमेंट मौजूद नहीं है, तो remove फ़ेल हो जाता है. अगर आपको किसी ऐसे एलिमेंट को हटाने की कोशिश करने पर गड़बड़ी नहीं करनी है जो मौजूद नहीं है, तो इसके बजाय discard का इस्तेमाल करें. अगर आपको किसी सेट से एक से ज़्यादा एलिमेंट हटाने हैं, तो difference_update या -= असाइनमेंट ऑपरेशन देखें.

पैरामीटर

symmetric_difference

set set.symmetric_difference(other)

अगर s और t सेट हैं, तो s.symmetric_difference(t), s ^ t के बराबर है. हालांकि, ध्यान दें कि ^ ऑपरेशन के लिए, दोनों साइड सेट होने चाहिए. वहीं, symmetric_difference तरीके में सीक्वेंस या डिक्शनरी भी स्वीकार की जाती है.

उदाहरण के लिए,

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

पैरामीटर

symmetric_difference_update

None set.symmetric_difference_update(other)

अगर s और t सेट हैं, तो s.symmetric_difference_update(t), `s ^= t; however, note that the ^=` के बराबर है. ऑगमेंटेड असाइनमेंट के लिए, दोनों साइड सेट होने चाहिए. वहीं, symmetric_difference_update तरीके में सीक्वेंस या डिक्शनरी भी स्वीकार की जाती है.

उदाहरण के लिए,

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

पैरामीटर

Union

set set.union(*others)

अगर s और t सेट हैं, तो s.union(t), s | t के बराबर है. हालांकि, ध्यान दें कि | ऑपरेशन के लिए, दोनों तरफ़ सेट होने चाहिए. वहीं, union तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

union को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट की कॉपी मिलती है.

उदाहरण के लिए,

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

पैरामीटर

अपडेट करें

None set.update(*others)

उदाहरण के लिए,

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

अगर s और t सेट हैं, तो s.update(t), s |= t के बराबर है. हालांकि, ध्यान दें कि |= ऑगमेंटेड असाइनमेंट के लिए, दोनों साइड के सेट होने ज़रूरी हैं. वहीं, update तरीके में सीक्वेंस और डिक्शनरी भी स्वीकार की जाती हैं.

update को बिना किसी तर्क के कॉल किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.

पैरामीटर