डिवाइस में पहले से मौजूद सेट टाइप. सेट, यूनीक वैल्यू का ऐसा कलेक्शन होता है जिसे बदला जा सकता है और जिसमें वैल्यू को क्रम से लगाया जा सकता है. ये वैल्यू, सेट के एलिमेंट होते हैं. किसी सेट का टाइप का नाम "set" है.
सेट में, वैल्यू को डालने, हटाने या उसकी मौजूदगी की जांच करने के लिए, एक ही समय में कई कार्रवाइयां की जा सकती हैं. सेट, हैश टेबल का इस्तेमाल करके लागू किए जाते हैं. इसलिए, डिकशनरी की कुंजियों की तरह ही, सेट के एलिमेंट भी हैश किए जा सकने चाहिए. किसी वैल्यू का इस्तेमाल सेट के एलिमेंट के तौर पर तब ही किया जा सकता है, जब उसका इस्तेमाल किसी डिक्शनरी की कुंजी के तौर पर किया जा सकता हो.
सेट बनाने के लिए, 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
- difference_update
- खारिज करें
- intersection
- intersection_update
- isdisjoint
- issubset
- issuperset
- pop
- निकालें
- symmetric_difference
- symmetric_difference_update
- union
- अपडेट करें
जोड़ें
None set.add(element)सेट में पहले से मौजूद वैल्यू को add किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.
अगर आपको किसी सेट में एक से ज़्यादा एलिमेंट जोड़ने हैं, तो update या |= ऑगमेंटेड असाइनमेंट ऑपरेशन देखें.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है जोड़ने के लिए एलिमेंट. |
मिटाएं
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |
खारिज करें
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"])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है Element to discard. हैश की जा सकने वाली वैल्यू होनी चाहिए. |
इंटरसेक्शन
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |
isdisjoint
bool set.isdisjoint(other)
उदाहरण के लिए,
set([1, 2]).isdisjoint([3, 4]) # True set().isdisjoint(set()) # True set([1, 2]).isdisjoint([2, 3]) # False
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, हैश किए जा सकने वाले एलिमेंट का क्रम या कोई डिक्शनरी. |
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
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, हैश किए जा सकने वाले एलिमेंट का क्रम या कोई डिक्शनरी. |
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
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, हैश किए जा सकने वाले एलिमेंट का क्रम या कोई डिक्शनरी. |
पॉप
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 या -= बेहतर असाइनमेंट ऑपरेशन देखें.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है हटाने के लिए एलिमेंट. यह सेट का एलिमेंट होना चाहिए और हैश किया जा सकता है. |
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, हैश किए जा सकने वाले एलिमेंट का क्रम या कोई डिक्शनरी. |
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, हैश किए जा सकने वाले एलिमेंट का क्रम या कोई डिक्शनरी. |
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])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |
अपडेट करें
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 को बिना किसी आर्ग्युमेंट के कॉल किया जा सकता है. इससे सेट में कोई बदलाव नहीं होता.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी हैश किए जा सकने वाले एलिमेंट के सेट, क्रम या डिक्शनरी. |