एक्सपेरिमेंटल. यह एपीआई, एक्सपेरिमेंट के तौर पर उपलब्ध है. इसमें कभी भी बदलाव किया जा सकता है. कृपया इस पर निर्भर न रहें. इसे एक्सपेरिमेंट के तौर पर चालू किया जा सकता है. इसके लिए, --experimental_enable_starlark_set सेट करें.
पहले से मौजूद, बदलाव किया जा सकने वाला सेट टाइप. एक्सप्रेशन सेट करने का उदाहरण:
x = set() # x is an empty set y = set([1, 2, 3]) # y is a set with 3 elements 3 in y # True 0 in y # False len(x) # 0 len(y) # 3
बूलियन कॉन्टेक्स्ट में इस्तेमाल किया गया सेट सिर्फ़ तब सही होता है, जब वह खाली न हो.
s = set() "non-empty" if s else "empty" # "empty" t = set(["x", "y"]) "non-empty" if t else "empty" # "non-empty"
किसी सेट के एलिमेंट को हैश किया जा सकता है; x किसी सेट का एलिमेंट तब ही हो सकता है, जब उसका इस्तेमाल किसी डायक्शनरी के पासकोड के तौर पर किया जा सकता हो.x
किसी सेट को हैश नहीं किया जा सकता. इसलिए, किसी सेट में किसी दूसरे सेट को एलिमेंट के तौर पर शामिल नहीं किया जा सकता.
किसी सेट के एलिमेंट को इंडेक्स के हिसाब से ऐक्सेस नहीं किया जा सकता. हालांकि, उन पर बार-बार दोहराए जाने वाले कार्रवाई का इस्तेमाल किया जा सकता है. साथ ही, list() में पहले से मौजूद फ़ंक्शन का इस्तेमाल करके, किसी सेट के एलिमेंट की सूची को दोहराए जाने वाले कार्रवाई के क्रम में पाया जा सकता है. सूचियों की तरह ही, सेट में बदलाव करने के दौरान उस पर बार-बार दोहराए जाने वाले फ़ंक्शन का इस्तेमाल करने पर गड़बड़ी होती है. एक ही तरह के वीडियो दोहराने का क्रम, इंसर्शन ऑर्डर से मेल खाता है:
s = set([3, 1, 3])
s.add(2)
# prints 3, 1, 2
for item in s:
print(item)
list(s) # [3, 1, 2]
कोई सेट s, t के बराबर तब ही होता है, जब t में वही एलिमेंट हों जो s में हैं. हालांकि, यह मुमकिन है कि t में एलिमेंट का क्रम अलग हो. खास तौर पर, कोई सेट,
not अपने एलिमेंट की सूची के बराबर होता है.
सेट को क्रम में नहीं रखा जाता. सेट के लिए, <, <=, >, और
>= ऑपरेशन तय नहीं किए गए हैं. साथ ही, सेट की सूची को क्रम से नहीं लगाया जा सकता. यह सुविधा, Python में उपलब्ध है.
दो सेट पर | ऑपरेशन करने से, दोनों सेट का यूनियन मिलता है: एक ऐसा सेट जिसमें मूल सेट में से किसी एक या दोनों में मौजूद एलिमेंट होते हैं. | ऑपरेशन में, बेहतर असाइनमेंट वर्शन होता है. s |= t, s में t के सभी एलिमेंट जोड़ता है.
set([1, 2]) | set([3, 2]) # set([1, 2, 3]) s = set([1, 2]) s |= set([2, 3, 4]) # s now equals set([1, 2, 3, 4])
दो सेट पर & ऑपरेशन करने से, दोनों सेट का इंटरसेक्शन मिलता है: ऐसा सेट जिसमें सिर्फ़ उन एलिमेंट को शामिल किया जाता है जो दोनों ओरिजनल सेट में मौजूद होते हैं. & ऑपरेशन का एक बेहतर असाइनमेंट वर्शन है; s &= t, s से उन सभी एलिमेंट को हटा देता है जो t में नहीं मिलते.
set([1, 2]) & set([2, 3]) # set([2]) set([1, 2]) & set([3, 4]) # set() s = set([1, 2]) s &= set([0, 1]) # s now equals set([1])
दो सेट पर - ऑपरेशन करने से, दोनों सेट के बीच का अंतर दिखता है: एक ऐसा सेट जिसमें बाईं ओर मौजूद सेट के एलिमेंट होते हैं, लेकिन दाईं ओर मौजूद साइट सेट के एलिमेंट नहीं होते. - ऑपरेशन में, एलिमेंट असाइन करने का बेहतर वर्शन है. s -= t, t में मिले सभी एलिमेंट को s से हटा देता है.
set([1, 2]) - set([2, 3]) # set([1]) set([1, 2]) - set([3, 4]) # set([1, 2]) s = set([1, 2]) s -= set([0, 1]) # s now equals set([2])
दो सेट पर ^ ऑपरेशन करने से, दोनों सेट के एलिमेंट का अंतर मिलता है. यह ऐसा सेट होता है जिसमें दो ओरिजनल सेट में से किसी एक में मौजूद एलिमेंट होते हैं, लेकिन दोनों में नहीं. ^ ऑपरेशन में, बेहतर असाइनमेंट वर्शन होता है; s ^= t, s में मिले t के किसी भी एलिमेंट को s से हटा देता है और s में न मिले t के किसी भी एलिमेंट को s में जोड़ देता है.
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([0, 1]) # s now equals set([2, 0])
सदस्य
- जोड़ें
- साफ़ करें
- difference
- difference_update
- खारिज करें
- intersection
- intersection_update
- isdisjoint
- issubset
- issuperset
- पॉप
- निकालें
- symmetric_difference
- symmetric_difference_update
- union
- अपडेट करें
जोड़ें
None set.add(element)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है जोड़ने के लिए एलिमेंट. |
मिटाएं
None set.clear()अंतर
set set.difference(*others)यह फ़ंक्शन, बदलाव किया जा सकने वाला एक नया सेट दिखाता है. इसमें, इस सेट और दूसरे सेट के बीच का अंतर होता है.
उदाहरण के लिए,
set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |
difference_update
None set.difference_update(*others)उदाहरण के लिए,
x = set([1, 2, 3, 4]) x.difference_update([2, 3], [3, 4]) # x is now set([1])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |
खारिज करें
None set.discard(element)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है Element to discard. |
इंटरसेक्शन
set set.intersection(*others)यह एक नया सेट दिखाता है, जिसमें इस सेट के साथ-साथ अन्य सेट के इंटरसेक्शन शामिल होते हैं.
उदाहरण के लिए,
set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |
intersection_update
None set.intersection_update(*others)उदाहरण के लिए,
x = set([1, 2, 3, 4]) x.intersection_update([2, 3], [3, 4]) # x is now set([3])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |
isdisjoint
bool set.isdisjoint(other)अगर इस सेट में किसी दूसरे सेट के साथ कोई एलिमेंट नहीं है, तो True दिखाता है.
उदाहरण के लिए,
set([1, 2]).isdisjoint([3, 4]) == True set().isdisjoint(set()) == True set([1, 2]).isdisjoint([2, 3]) == False
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, क्रम या डिक्शनरी. |
issubset
bool set.issubset(other)अगर यह सेट किसी दूसरे सेट का सबसेट है, तो True दिखाता है.
उदाहरण के लिए,
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)यह फ़ंक्शन, इस सेट के किसी दूसरे सेट के सुपरसेट होने पर True दिखाता है.
उदाहरण के लिए,
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()सेट के पहले एलिमेंट को हटाता है और उसे दिखाता है. सेट खाली होने पर, फ़ंक्शन काम नहीं करता.
कॉन्टेंट हटाना
None set.remove(element)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
element
|
ज़रूरी है हटाने के लिए एलिमेंट. |
symmetric_difference
set set.symmetric_difference(other)बदलाव किया जा सकने वाला एक नया सेट दिखाता है. इसमें, इस सेट के किसी दूसरे सेट, क्रम या डायक्शन के साथ, सिमेट्रिक डिफ़रेंस होता है.
उदाहरण के लिए,
set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, क्रम या डिक्शनरी. |
symmetric_difference_update
None set.symmetric_difference_update(other)उदाहरण के लिए,
set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
other
|
ज़रूरी है कोई सेट, क्रम या डिक्शनरी. |
Union
set set.union(*others)यह एक नया सेट दिखाता है, जिसमें इस सेट के साथ-साथ अन्य सेट भी शामिल होते हैं.
उदाहरण के लिए,
set([1, 2]).union([2, 3, 4], [4, 5]) == set([1, 2, 3, 4, 5])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |
अपडेट करें
None set.update(*others)उदाहरण के लिए,
x = set([1, 2]) x.update([2, 3], [3, 4]) # x is now set([1, 2, 3, 4])
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
others
|
ज़रूरी सेट, क्रम या डिक्शनरी. |