सेट करो

एक्सपेरिमेंटल. यह एपीआई, एक्सपेरिमेंट के तौर पर उपलब्ध है. इसमें कभी भी बदलाव किया जा सकता है. कृपया इस पर निर्भर न रहें. इसे एक्सपेरिमेंट के तौर पर चालू किया जा सकता है. इसके लिए, --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)

पैरामीटर

मिटाएं

None set.clear()

अंतर

set set.difference(*others)

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

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

पैरामीटर

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

पैरामीटर

खारिज करें

None set.discard(element)

पैरामीटर

इंटरसेक्शन

set set.intersection(*others)

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

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

पैरामीटर

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

पैरामीटर

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

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

None set.remove(element)

पैरामीटर

symmetric_difference

set set.symmetric_difference(other)

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

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

पैरामीटर

symmetric_difference_update

None set.symmetric_difference_update(other)

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

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

पैरामीटर

Union

set set.union(*others)

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

set([1, 2]).union([2, 3, 4], [4, 5]) == set([1, 2, 3, 4, 5])

पैरामीटर

अपडेट करें

None set.update(*others)

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

x = set([1, 2])
x.update([2, 3], [3, 4])
# x is now set([1, 2, 3, 4])

पैरामीटर