Python හි කුලක වර්ගය සමඟ මෙහෙයුම් සකසන්න (උදා., වෘත්තීය සමිති කට්ටල, නිෂ්පාදන කට්ටල සහ උප කුලක නිර්ණය කිරීම)

ව්යාපාරික

Python විසින් ගොඩනඟන ලද දත්ත වර්ගයක්, කට්ටල හසුරුවන කට්ටලයක් සපයයි.

වර්ග කට්ටලය යනු අනුපිටපත් නොවන මූලද්‍රව්‍යවල (එකම අගය නොවන මූලද්‍රව්‍ය, අද්විතීය මූලද්‍රව්‍ය) එකතුවක් වන අතර සමිති කට්ටලය, නිෂ්පාදන කට්ටලය සහ වෙනස්කම් කට්ටලය වැනි සකසන මෙහෙයුම් සිදු කළ හැක.

මෙම කොටසෙහි, කට්ටල ආකාරයේ කට්ටල මෙහෙයුම්වල මූලික මෙහෙයුම් නියැදි කේතය සමඟ විස්තර කෙරේ.

  • සැකසූ වස්තූන් නිර්මාණය කිරීම:{},set()
  • ඇතුළත් කිරීමේ අංකනය සකසන්න
  • කට්ටලයේ ඇති මූලද්රව්ය ගණන:len()
  • කට්ටලයකට මූලද්රව්යයක් එකතු කිරීම:add()
  • කට්ටලයකින් මූලද්රව්යයක් ඉවත් කරන්න:discard(),remove(),pop(),clear()
  • Wasset (ඒකාබද්ධ කිරීම, සංගමය):|ක්‍රියාකරු,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'>

Constructor set() මගින් ජනනය

කන්ස්ට්‍රක්ටර් සෙට්() සමඟින් වර්ග කට්ටලයේ වස්තු ද සෑදිය හැක.

ලැයිස්තුවක් හෝ ටියුපල් වැනි පුනරාවර්තනය කළ හැකි වස්තුවක් තර්කයක් ලෙස සඳහන් කිරීමෙන් අනුපිටපත් මූලද්‍රව්‍ය බැහැර කර ඇති මූලද්‍රව්‍ය අද්විතීය අගයන් පමණක් වන කට්ටල වස්තුවක් ජනනය කරයි.

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

අනුපිටපත් මූලද්‍රව්‍ය set() භාවිතයෙන් ලැයිස්තුවකින් හෝ ටුපල් වලින් ඉවත් කළ හැකි නමුත් මුල් ලැයිස්තුවේ අනුපිළිවෙල සුරැකෙන්නේ නැත.

කට්ටල වර්ගයක් ලැයිස්තුවක් හෝ ටපල් එකක් බවට පරිවර්තනය කිරීමට, list(),tuple() භාවිතා කරන්න.

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

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

අනුපිළිවෙල සුරැකීමේදී අනුපිටපත් මූලද්‍රව්‍ය ඉවත් කිරීම, අනුපිටපත් මූලද්‍රව්‍ය පමණක් උපුටා ගැනීම සහ ද්විමාන අරාවක (ලැයිස්තු ලැයිස්තුව) අනුපිටපත් මූලද්‍රව්‍ය සැකසීම පිළිබඳ තොරතුරු සඳහා පහත ලිපිය බලන්න.

ඇතුළත් කිරීමේ අංකනය සකසන්න

ලිස්ට් අවෙබෝධයන් මෙන්ම සෙට් අවෙබෝධයන් ද ඇත. ලැයිස්තු අවබෝධයන්හි වර්ග වරහන් [] වරහන් {} සමඟ ප්‍රතිස්ථාපනය කරන්න.

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

කට්ටලයකින් මූලද්‍රව්‍යයක් ඉවත් කිරීමට, ඉවතලන(), ඉවත් කරන්න(), pop(), සහ පැහැදිලි() ක්‍රම භාවිතා කරන්න.

ඉවතලන () ක්‍රමය තර්කයේ දක්වා ඇති මූලද්‍රව්‍යය මකා දමයි. කට්ටලයේ නොමැති අගයක් නියම කර ඇත්නම්, කිසිවක් නොකෙරේ.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

Remove() ක්‍රමය මඟින් තර්කයේ සඳහන් කර ඇති මූලද්‍රව්‍යය ද ඉවත් කරයි, නමුත් කට්ටලයේ නොමැති අගයක් සඳහන් කළහොත් දෝෂයක් 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'

clear() ක්‍රමය මඟින් සියලුම මූලද්‍රව්‍ය ඉවත් කර කට්ටලය හිස් කරයි.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (ඒකාබද්ධ කිරීම, සංගමය):|ක්‍රියාකරු,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}

ක්‍රමයක් සඳහා බහු තර්ක නියම කළ හැක. කට්ටල වර්ගයට අමතරව, set() මඟින් කට්ටල වර්ගයට පරිවර්තනය කළ හැකි ලැයිස්තු සහ ටියුපල් ද තර්ක ලෙස දැක්විය හැකිය. පසුකාලීන ක්‍රියාකරුවන් සහ ක්‍රම සඳහාද මෙය අදාළ වේ.

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

නිෂ්පාදන කට්ටලය (පොදු කොටස, ඡේදනය සහ ඡේදනය) සහ amp; ක්රියාකරු හෝ ඡේදනය () ක්රමය.

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

සමමිතික වෙනස කට්ටලය (දෙකින් එකක පමණක් අඩංගු මූලද්‍රව්‍ය කට්ටලය) ^ operator හෝ 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

>= ක්‍රියාකරු සහ නිකුත් කරන () ක්‍රමය යන දෙකම සමාන කට්ටල සඳහා සත්‍ය වේ.

එය සත්‍ය සුපිරි කට්ටලයක් දැයි තීරණය කිරීමට, සමාන කට්ටල සඳහා අසත්‍ය ලබා දෙන >= ක්‍රියාකරු භාවිතා කරන්න.

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
Copied title and URL