Python ले सेट ह्यान्डल गर्ने बिल्ट-इन डाटा प्रकार, सेट प्रदान गर्दछ।
प्रकार सेट गैर-डुप्लिकेट तत्वहरूको सङ्कलन हो (एउटै मान नभएका तत्वहरू, अद्वितीय तत्वहरू) र युनियन सेट, उत्पादन सेट, र भिन्नता सेट जस्ता सेट अपरेशनहरू गर्न सक्छन्।
यस खण्डमा, सेट-प्रकार सेट अपरेशनहरूमा आधारभूत कार्यहरू नमूना कोडको साथ व्याख्या गरिएको छ।
- सेट वस्तुहरूको निर्माण:
{},set() - समावेश नोटेशन सेट गर्नुहोस्
- सेटमा तत्वहरूको संख्या:
len() - एक सेट मा एक तत्व थप्दै:
add() - सेटबाट तत्व हटाउनुहोस्:
discard(),remove(),pop(),clear()
- वासेट (विलय, संघ):| अपरेटर,
union() - उत्पादन सेटहरू (सामान्य भागहरू, प्रतिच्छेदनहरू, प्रतिच्छेदनहरू):& अपरेटर,
intersection() - सापेक्ष पूरक:– अपरेटर,
difference() - सममिति भिन्नता सेट:^ अपरेटर,
symmetric_difference() - उपसेट वा होइन:<= अपरेटर,
issubset() - माथिल्लो सेट वा छैन:>= अपरेटर,
issuperset() - तिनीहरू पारस्परिक रूपमा प्रमुख छन् वा छैनन् भन्ने निर्धारण:
isdisjoint()
सेट प्रकार एक परिवर्तनीय प्रकार हो जसले तत्वहरू थप्न र मेटाउन सक्छ, र त्यहाँ एक फ्रोजेनसेट प्रकार पनि छ जसमा सेट प्रकार जस्तै सेट अपरेशन र अन्य विधिहरू छन् तर अपरिवर्तनीय छ (तत्वहरू थपेर, मेटाएर वा अन्यथा परिमार्जन गरेर परिमार्जन गर्न सकिँदैन। )।
- सेट वस्तुको निर्माण::{},set()
- समावेश नोटेशन सेट गर्नुहोस्
- सेटमा तत्वहरूको संख्या:len()
- एक सेट मा एक तत्व थप्दै:add()
- सेटबाट तत्व हटाउनुहोस्:discard(),remove(),pop(),clear()
- वासेट (विलय, संघ):| अपरेटर,union()
- उत्पादन सेटहरू (सामान्य भागहरू, प्रतिच्छेदनहरू, प्रतिच्छेदनहरू):& अपरेटर,intersection()
- सापेक्ष पूरक:– अपरेटर,difference()
- सममिति भिन्नता सेट:^ अपरेटर,symmetric_difference()
- उपसेट वा होइन:<= अपरेटर,issubset()
- माथिल्लो सेट वा छैन:>= अपरेटर,issuperset()
- तिनीहरू पारस्परिक रूपमा प्रमुख छन् वा छैनन् भन्ने निर्धारण:isdisjoint()
सेट वस्तुको निर्माण::{},set()
तरंग कोष्ठक द्वारा उत्पन्न {}
प्रकार सेटका वस्तुहरू ब्रेसेस {} मा तत्वहरू संलग्न गरेर सिर्जना गर्न सकिन्छ।
यदि त्यहाँ डुप्लिकेट मानहरू छन् भने, तिनीहरूलाई बेवास्ता गरिन्छ र केवल अद्वितीय मानहरू तत्वहरूको रूपमा रहन्छन्।
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
तत्वहरूको रूपमा विभिन्न प्रकारहरू हुन सम्भव छ। यद्यपि, अद्यावधिक गर्न मिल्ने वस्तुहरू जस्तै सूची प्रकारहरू दर्ता गर्न सकिँदैन। Tuples लाई अनुमति छ।
साथै, सेट प्रकारहरू अक्रमित भएकाले, तिनीहरू उत्पन्न भएको क्रम भण्डारण हुँदैन।
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
विभिन्न प्रकारहरू, जस्तै int र float, तिनीहरूको मान बराबर भएमा नक्कल मानिन्छ।
s = {100, 100.0}
print(s)
# {100}
खाली ब्रेस {} लाई शब्दकोश प्रकार मानिएको हुनाले, अर्को वर्णन गरिएको कन्स्ट्रक्टर प्रयोग गरेर खाली सेट प्रकारको वस्तु (खाली सेट) सिर्जना गर्न सकिन्छ।
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
कन्स्ट्रक्टर सेट () द्वारा उत्पन्न
कन्स्ट्रक्टर सेट() सँग टाइप सेटका वस्तुहरू पनि सिर्जना गर्न सकिन्छ।
पुनरावृत्ति योग्य वस्तु निर्दिष्ट गर्नाले जस्तै सूची वा तर्कको रूपमा टपलले एक सेट वस्तु उत्पन्न गर्दछ जसको तत्वहरू अद्वितीय मानहरू मात्र हुन्, नक्कल तत्वहरू बहिष्कृत।
l = [1, 2, 2, 3, 1, 4]
print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>
s_l = set(l)
print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>
कन्स्ट्रक्टर फ्रोजेनसेट() सँग अपरिवर्तनीय फ्रोजेनसेट प्रकारहरू सिर्जना गरिन्छ।
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
यदि तर्क हटाइयो भने, एउटा खाली सेट-प्रकार वस्तु (खाली सेट) सिर्जना हुन्छ।
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
डुप्लिकेट तत्वहरूलाई सूचीबाट हटाउन सकिन्छ वा सेट() प्रयोग गरेर टुपल गर्न सकिन्छ, तर मूल सूचीको क्रम सुरक्षित गरिएको छैन।
सेट प्रकारलाई सूची वा टपलमा रूपान्तरण गर्न, सूची (), टपल () प्रयोग गर्नुहोस्।
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
क्रम सुरक्षित गर्दा, नक्कल तत्वहरू मात्र निकाल्ने, र दुई-आयामी एरे (सूचीहरूको सूची) मा डुप्लिकेट तत्वहरू प्रशोधन गर्दा नक्कल तत्वहरू हटाउने ’bout जानकारीको लागि निम्न लेख हेर्नुहोस्।
समावेश नोटेशन सेट गर्नुहोस्
साथै सूची बुझाइहरू, त्यहाँ सेट समझहरू छन्। केवल वर्ग कोष्ठकहरू [] कोष्ठकहरू {} ले सूची बुझाइमा बदल्नुहोस्।
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
सूची बुझ्ने नोटेशनमा थप जानकारीको लागि निम्न लेख हेर्नुहोस्।
- सम्बन्धित:पाइथन सूची समझ कसरी प्रयोग गर्ने
सेटमा तत्वहरूको संख्या:len()
एक सेट मा तत्व को संख्या बिल्ट-इन प्रकार्य len() संग प्राप्त गर्न सकिन्छ।
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
यदि तपाइँ प्रत्येक सूचीमा तत्वहरूको संख्या गणना गर्न चाहानुहुन्छ जसमा डुप्लिकेट मानहरू इत्यादि भएका तत्वहरू छन्, निम्न लेख हेर्नुहोस्।
एक सेट मा एक तत्व थप्दै:add()
सेटमा एउटा तत्व थप्न, add() विधि प्रयोग गर्नुहोस्।
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
सेटबाट तत्व हटाउनुहोस्:discard(),remove(),pop(),clear()
सेटबाट तत्व हटाउनको लागि, त्याग्नुहोस्(), हटाउनुहोस्(), पप(), र स्पष्ट() विधिहरू प्रयोग गर्नुहोस्।
रद्द गर्नुहोस्() विधिले तर्कमा निर्दिष्ट गरिएको तत्व मेटाउँछ। यदि सेटमा अवस्थित नभएको मान निर्दिष्ट गरिएको छ भने, केहि पनि गरिएको छैन।
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
हटाउन() विधिले आर्गुमेन्टमा निर्दिष्ट गरिएको तत्वलाई पनि हटाउँछ, तर सेटमा अवस्थित नभएको मान निर्दिष्ट गरिएको खण्डमा त्रुटि KeyError फर्काइन्छ।
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
पप() विधिले सेटबाट तत्वहरू हटाउँछ र तिनीहरूको मानहरू फर्काउँछ। कुन मानहरू हटाउने भनेर चयन गर्न सम्भव छैन। एउटा खाली सेटले कुञ्जी त्रुटि त्रुटिको परिणाम दिन्छ।
s = {2, 1, 0}
v = s.pop()
print(s)
print(v)
# {1, 2}
# 0
s = {2, 1, 0}
print(s.pop())
# 0
print(s.pop())
# 1
print(s.pop())
# 2
# print(s.pop())
# KeyError: 'pop from an empty set'
स्पष्ट() विधिले सबै तत्वहरू हटाउँछ र सेटलाई खाली बनाउँछ।
s = {0, 1, 2}
s.clear()
print(s)
# set()
वासेट (विलय, संघ):| अपरेटर,union()
युनियन सेट (विलय, संघ) | सँग प्राप्त गर्न सकिन्छ अपरेटर वा संघ() विधि।
s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}
s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}
s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}
एक विधिको लागि धेरै तर्कहरू निर्दिष्ट गर्न सकिन्छ। सेट प्रकारको अतिरिक्त, सेट () द्वारा सेट प्रकारमा रूपान्तरण गर्न सकिने सूचिहरू र टुपलहरूलाई पनि तर्कको रूपमा निर्दिष्ट गर्न सकिन्छ। पछिल्लो अपरेटर र विधिहरूमा पनि यही कुरा लागू हुन्छ।
s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}
s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}
उत्पादन सेटहरू (सामान्य भागहरू, प्रतिच्छेदनहरू, प्रतिच्छेदनहरू):& अपरेटर,intersection()
उत्पादन सेट (सामान्य भाग, प्रतिच्छेदन, र प्रतिच्छेदन) & बाट प्राप्त गर्न सकिन्छ। अपरेटर वा intersection() विधि।
s_intersection = s1 & s2
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}
s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}
सापेक्ष पूरक:– अपरेटर,difference()
भिन्नता सेट – अपरेटर वा भिन्नता() विधिबाट प्राप्त गर्न सकिन्छ।
s_difference = s1 - s2
print(s_difference)
# {0}
s_difference = s1.difference(s2)
print(s_difference)
# {0}
s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}
सममिति भिन्नता सेट:^ अपरेटर,symmetric_difference()
सममित भिन्नता सेट (दुई मध्ये एउटामा मात्र समावेश तत्वहरूको सेट) ^ अपरेटर वा symmetric_difference() सँग प्राप्त गर्न सकिन्छ।
तार्किक कार्यहरूमा विशेष विच्छेदन (XOR) को बराबर।
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
उपसेट वा होइन:<= अपरेटर,issubset()
सेट अर्को सेटको सबसेट हो कि भनेर निर्धारण गर्न, <= अपरेटर वा issubset() विधि प्रयोग गर्नुहोस्।
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
दुवै <= अपरेटर र issubset() विधि बराबर सेटहरूको लागि सही फर्काउँछ।
यो एक साँचो उपसेट हो कि भनेर निर्धारण गर्न, <= अपरेटर प्रयोग गर्नुहोस्, जसले बराबर सेटहरूको लागि गलत फर्काउँछ।
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
माथिल्लो सेट वा छैन:>= अपरेटर,issuperset()
एउटा सेट अर्कोको सुपरसेट हो कि भनेर निर्धारण गर्न, >= अपरेटर वा issuperset() प्रयोग गर्नुहोस्।
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
>= अपरेटर र issuperset() विधि बराबर सेटहरूको लागि सही फर्काउँछ।
यो एक साँचो सुपरसेट हो कि भनेर निर्धारण गर्न, >= अपरेटर प्रयोग गर्नुहोस्, जसले बराबर सेटहरूको लागि गलत फर्काउँछ।
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
तिनीहरू पारस्परिक रूपमा प्रमुख छन् वा छैनन् भन्ने निर्धारण:isdisjoint()
यदि दुई सेटहरू एकअर्काको लागि प्रमुख छन् भने निर्धारण गर्न, isdisjoint() विधि प्रयोग गर्नुहोस्।
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True
