પાયથોનના સેટ પ્રકાર સાથે સેટ ઓપરેશન્સ (દા.ત., યુનિયન સેટ, પ્રોડક્ટ સેટ્સ અને સબસેટ્સ નક્કી કરવા)

પાયથોન બિલ્ટ-ઇન ડેટા પ્રકાર, સેટ પૂરો પાડે છે, જે સેટને હેન્ડલ કરે છે.

પ્રકાર સમૂહ એ બિન-ડુપ્લિકેટ તત્વો (તત્વો કે જે સમાન મૂલ્ય નથી, અનન્ય તત્વો) નો સંગ્રહ છે અને તે યુનિયન સેટ, ઉત્પાદન સમૂહ અને તફાવત સમૂહ જેવા સમૂહ કામગીરી કરી શકે છે.

• Set Types — set, frozenset — Python 3.10.4 Documentation

આ વિભાગમાં, સેટ-ટાઈપ સેટ ઓપરેશન્સમાં મૂળભૂત કામગીરીને નમૂના કોડ સાથે સમજાવવામાં આવી છે.

• સેટ ઑબ્જેક્ટ્સની રચના:{},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'>

તત્વો તરીકે વિવિધ પ્રકારના હોય તે શક્ય છે. જો કે, અપડેટ કરી શકાય તેવા ઑબ્જેક્ટ્સ જેમ કે સૂચિ પ્રકારો રજીસ્ટર કરી શકાતા નથી. ટ્યુપલ્સને મંજૂરી છે.

ઉપરાંત, સમૂહના પ્રકારો અવ્યવસ્થિત હોવાથી, તેઓ જે ક્રમમાં ઉત્પન્ન થાય છે તે સંગ્રહિત નથી.

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 અને ફ્લોટ, જો તેમની કિંમતો સમકક્ષ હોય તો તેને ડુપ્લિકેટ ગણવામાં આવે છે.

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'>

ડુપ્લિકેટ ઘટકોને સૂચિમાંથી દૂર કરી શકાય છે અથવા સેટ() નો ઉપયોગ કરીને ટપલ કરી શકાય છે, પરંતુ મૂળ સૂચિનો ક્રમ સાચવવામાં આવતો નથી.

સેટ પ્રકારને સૂચિ અથવા ટ્યુપલમાં કન્વર્ટ કરવા માટે, સૂચિ(), ટ્યુપલ() નો ઉપયોગ કરો.

• સંબંધિત:list(), tuple() પાયથોનમાં લિસ્ટ અને ટપલને એકબીજા સાથે કન્વર્ટ કરવા

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

ઓર્ડર સાચવતી વખતે ડુપ્લિકેટ તત્વોને દૂર કરવા, માત્ર ડુપ્લિકેટ તત્વો કાઢવા અને દ્વિ-પરિમાણીય એરે (સૂચિઓની સૂચિ) માં ડુપ્લિકેટ તત્વોની પ્રક્રિયા કરવા વિશેની માહિતી માટે નીચેનો લેખ જુઓ.

• સંબંધિત:Python માં સૂચિ (એરે) માંથી ડુપ્લિકેટ ઘટકોને દૂર કરો અને બહાર કાઢો

સમાવેશ નોટેશન સેટ કરો

સૂચિની સમજણની સાથે સાથે, ત્યાં સમૂહ સમજણ પણ છે. સૂચિની સમજણમાં ફક્ત ચોરસ કૌંસ [] ને કૌંસ {} વડે બદલો.

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

સમૂહમાંથી તત્વને દૂર કરવા માટે, discard(), remove(), pop(), અને clear() પદ્ધતિઓનો ઉપયોગ કરો.

discard() પદ્ધતિ દલીલમાં ઉલ્લેખિત ઘટકને કાઢી નાખે છે. જો કોઈ મૂલ્ય જે સેટમાં અસ્તિત્વમાં નથી તે ઉલ્લેખિત છે, તો કંઈ કરવામાં આવતું નથી.

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

pop() પદ્ધતિ સમૂહમાંથી તત્વોને દૂર કરે છે અને તેમની કિંમતો પરત કરે છે. કયા મૂલ્યોને દૂર કરવા તે પસંદ કરવાનું શક્ય નથી. ખાલી સેટને કારણે KeyError ભૂલ આવશે.

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

ઉત્પાદન સમૂહ (સામાન્ય ભાગ, આંતરછેદ અને આંતરછેદ) & સાથે મેળવી શકાય છે. operator અથવા 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()

સપ્રમાણ તફાવત સમૂહ (બેમાંથી માત્ર એકમાં સમાયેલ તત્વોનો સમૂહ) ^ ઓપરેટર અથવા સમપ્રમાણ_ભેદ() સાથે મેળવી શકાય છે.

લોજિકલ ઓપરેશન્સમાં એક્સક્લુઝિવ ડિસજંક્શન (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()

એક સેટ બીજાનો સુપરસેટ છે કે કેમ તે નક્કી કરવા માટે, >= ઓપરેટર અથવા ઈસ્યુપરસેટ() નો ઉપયોગ કરો.

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