Python ၏ သတ်မှတ်အမျိုးအစားဖြင့် လုပ်ဆောင်ချက်များကို သတ်မှတ်ခြင်း (ဥပမာ၊ သမဂ္ဂအစုံများ၊ ထုတ်ကုန်အစုံများနှင့် အပိုင်းခွဲများ)

Python သည် sets များကို ကိုင်တွယ်သည့် built-in data အမျိုးအစား၊ set ကို ပေးပါသည်။

အမျိုးအစားအစုံသည် ထပ်တူမဟုတ်သောဒြပ်စင်များ (တန်ဖိုးတူမဟုတ်သောဒြပ်စင်များ၊ တစ်မူထူးခြားသောဒြပ်စင်များ) အစုအဝေးတစ်ခုဖြစ်ပြီး union set၊ ထုတ်ကုန်အစုံနှင့် ခြားနားချက်အစုံကဲ့သို့သော သတ်မှတ်လုပ်ဆောင်ချက်များကို လုပ်ဆောင်နိုင်သည်။

• Set Types — set, frozenset — Python 3.10.4 Documentation

ဤကဏ္ဍတွင်၊ set-type set operations တွင် အခြေခံလုပ်ဆောင်မှုများကို နမူနာကုဒ်ဖြင့် ရှင်းပြထားသည်။

• အစုံအရာဝတ္ထုများဖန်တီးခြင်း။:{}၊set()
• inclusion notation သတ်မှတ်ပါ။
• အစုံရှိ အစိတ်အပိုင်း အရေအတွက်:len()
• Set တစ်ခုသို့ Element တစ်ခုထည့်ခြင်း။:add()
• အစုတစ်ခုမှ အစိတ်အပိုင်းတစ်ခုကို ဖယ်ရှားပါ။:discard()၊remove()၊pop()၊clear()

• Wasset (ပေါင်းစည်းခြင်း၊ ပြည်ထောင်စု)၊:|အော်ပရေတာ,union()
• ကုန်ပစ္စည်းအစုံများ (အသုံးများသော အစိတ်အပိုင်းများ၊ လမ်းဆုံများ၊ လမ်းဆုံများ):& အော်ပရေတာ,intersection()
• ဆွေမျိုးအဖြည့်:-အော်ပရေတာ,difference()
• symmetry ခြားနားချက်အစုံ:^ အော်,symmetric_difference()
• ခွဲထားသည်ဖြစ်စေ၊:<= အော်ပရေတာ,issubset()
• အထက်ပိုင်းသတ်မှတ်သည်ဖြစ်စေ၊:>= အော်ပရေတာ,issuperset()
• နှစ်ဦးနှစ်ဖက် အချုပ်အခြာဖြစ်ခြင်း ရှိ၊မရှိ ဆုံးဖြတ်ခြင်း။:isdisjoint()

သတ်မှတ်အမျိုးအစားသည် ဒြပ်စင်များကို ပေါင်းထည့်နိုင်ပြီး ဖျက်နိုင်သော မပြောင်းလဲနိုင်သော အမျိုးအစားဖြစ်ပြီး တူညီသော လုပ်ဆောင်ချက်နှင့် သတ်မှတ်အမျိုးအစားကဲ့သို့ အခြားနည်းလမ်းများပါရှိသော frozenset အမျိုးအစားလည်း ရှိသော်လည်း မပြောင်းလဲနိုင် (ဒြပ်စင်များကို ထည့်ခြင်း၊ ဖျက်ခြင်း သို့မဟုတ် အခြားနည်းဖြင့် မွမ်းမံခြင်းမပြုနိုင်ပါ။ )

သတ်မှတ်အရာဝတ္ထုကို ဖန်တီးခြင်း-:{}၊set()

လှိုင်းကွင်းများ {} ဖြင့် ထုတ်လုပ်သည်

အကွက်များ {} တွင် ဒြပ်စင်များကို ထည့်သွင်းခြင်းဖြင့် အမျိုးအစားအစုံ၏ အရာဝတ္ထုများကို ဖန်တီးနိုင်သည်။

ထပ်နေသောတန်ဖိုးများရှိပါက ၎င်းတို့ကို လျစ်လျူရှုပြီး ထူးခြားသောတန်ဖိုးများသာ ဒြပ်စင်များအဖြစ် ကျန်ရှိနေပါသည်။

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

ဒြပ်စင်များအဖြစ် အမျိုးအစားအမျိုးမျိုးရှိနိုင်သည်။ သို့သော်လည်း စာရင်းအမျိုးအစားများကဲ့သို့သော ဒေတာမြှင့်တင်နိုင်သော အရာဝတ္ထုများကို စာရင်းသွင်း၍မရပါ။ Tuple များကိုခွင့်ပြုထားသည်။

ထို့အပြင် သတ်မှတ်အမျိုးအစားများကို စီစဥ်ထားခြင်းမရှိသောကြောင့် ၎င်းတို့ထုတ်လုပ်လိုက်သော အမှာစာများကို သိမ်းဆည်းမည်မဟုတ်ပါ။

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}

ဗလာဘောင်စည်း {} ကို အဘိဓာန်အမျိုးအစားဟု ယူဆသောကြောင့်၊ နောက်တွင်ဖော်ပြထားသော constructor ကိုအသုံးပြု၍ ဗလာ set type object (empty set) ကို ဖန်တီးနိုင်သည်။

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

constructor set() မှထုတ်ပေးသည်

အမျိုးအစားအစုံ၏ အရာဝတ္ထုများကိုလည်း constructor set() ဖြင့် ဖန်တီးနိုင်သည်။

အငြင်းအခုံအဖြစ် စာရင်းတစ်ခု သို့မဟုတ် tuple ကဲ့သို့ ထပ်တူကျနိုင်သော အရာတစ်ခုကို သတ်မှတ်ခြင်းသည် ပွားနေသောဒြပ်စင်များကို ဖယ်ထုတ်ထားခြင်းဖြင့် ဒြပ်စင်များကို သီးသန့်တန်ဖိုးများသာဖြစ်သည့် သတ်မှတ်အရာဝတ္တုကို ထုတ်ပေးသည်။

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

မပြောင်းလဲနိုင်သော frozenset အမျိုးအစားများကို constructor frozenset() ဖြင့် ဖန်တီးထားသည်။

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

အငြင်းအခုံကို ချန်လှပ်ထားပါက၊ ဗလာ set-type object (empty set) ကို ဖန်တီးသည်။

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

set() ကို အသုံးပြု၍ မိတ္တူပွားနေသောဒြပ်စင်များကို စာရင်းတစ်ခု သို့မဟုတ် tuple မှ ဖယ်ရှားနိုင်သော်လည်း မူရင်းစာရင်း၏ အစီအစဥ်ကို ထိန်းသိမ်းမထားပါ။

သတ်မှတ်အမျိုးအစားတစ်ခုကို စာရင်းတစ်ခု သို့မဟုတ် tuple အဖြစ်သို့ ပြောင်းရန်၊ list(),tuple() ကိုသုံးပါ။

• ဆက်စပ်-list(), tuple() သည် စာရင်းနှင့် tuple ကို Python တွင် တစ်ခုနှင့်တစ်ခုသို့ ပြောင်းရန်

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

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

အမှာစာကို ထိန်းသိမ်းထားစဉ်၊ ပွားနေသောဒြပ်စင်များကိုသာ ထုတ်ယူခြင်းနှင့် နှစ်ဘက်မြင် အခင်းအကျင်းတွင် ပွားနေသောဒြပ်စင်များကို လုပ်ဆောင်ခြင်းဆိုင်ရာ အချက်အလက်များအတွက် အောက်ပါဆောင်းပါးကို ကြည့်ပါ။

• ဆက်စပ်-Python ရှိ စာရင်း (array) တစ်ခုမှ ပွားနေသော အစိတ်အပိုင်းများကို ဖယ်ရှားပြီး ထုတ်ယူပါ။

inclusion notation သတ်မှတ်ပါ။

စာရင်းနားလည်မှုများအပြင် သတ်မှတ်နားလည်နိုင်စွမ်းများလည်း ရှိပါသည်။ စာရင်းနားလည်မှုများတွင် လေးထောင့်ကွင်းစကွက်များ [] ကို ကွင်းကောက်များ {} ဖြင့် အစားထိုးပါ။

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

စာရင်းနားလည်မှုမှတ်စုဆိုင်ရာ နောက်ထပ်အချက်အလက်များအတွက် အောက်ပါဆောင်းပါးကို ကြည့်ပါ။

• ဆက်စပ်-Python list comprehensions ကိုအသုံးပြုနည်း

အစုံရှိ အစိတ်အပိုင်း အရေအတွက်:len()

တပ်ဆင်ထားသောလုပ်ဆောင်ချက် len() ဖြင့် set တစ်ခုရှိ element အရေအတွက်ကို ရယူနိုင်ပါသည်။

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

ပွားနေသောတန်ဖိုးများ စသည်တို့ပါရှိသော စာရင်းတစ်ခုစီရှိ ဒြပ်စင်အရေအတွက်ကို ရေတွက်လိုပါက အောက်ပါဆောင်းပါးကို ကြည့်ပါ။

• ဆက်စပ်-Python’s Counter ဖြင့် စာရင်းတစ်ခုရှိ ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်ခြင်း။

Set တစ်ခုသို့ Element တစ်ခုထည့်ခြင်း။:add()

အစိတ်အပိုင်းတစ်ခုအား set တစ်ခုသို့ထည့်ရန် add() method ကိုသုံးပါ။

s = {0, 1, 2}

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

အစုတစ်ခုမှ အစိတ်အပိုင်းတစ်ခုကို ဖယ်ရှားပါ။:discard()၊remove()၊pop()၊clear()

set တစ်ခုမှ အစိတ်အပိုင်းတစ်ခုကို ဖယ်ရှားရန်၊ discard(), remove(), pop(), နှင့် clear() နည်းလမ်းများကို အသုံးပြုပါ။

discard() method သည် argument တွင် သတ်မှတ်ထားသော element ကို ဖျက်သည်။ set တွင်မရှိသောတန်ဖိုးကိုသတ်မှတ်ပါကဘာမျှလုပ်ဆောင်မည်မဟုတ်ပါ။

s = {0, 1, 2}

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

s = {0, 1, 2}

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

remove() method သည် argument တွင်ဖော်ပြထားသော element ကိုလည်းဖယ်ရှားသည်၊ သို့သော် set တွင်မရှိသောတန်ဖိုးကိုသတ်မှတ်ထားပါက Key Error သည်ပြန်လာလိမ့်မည်။

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

pop() method သည် set တစ်ခုမှ element များကိုဖယ်ရှားပြီး ၎င်းတို့၏တန်ဖိုးများကို ပြန်ပေးသည်။ မည်သည့်တန်ဖိုးများကို ဖယ်ရှားရမည်ကို ရွေးချယ်ရန် မဖြစ်နိုင်ပါ။ ဗလာအစုံသည် 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() method သည် element အားလုံးကိုဖယ်ရှားပြီး set ကို ဗလာဖြစ်စေသည်။

s = {0, 1, 2}

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

Wasset (ပေါင်းစည်းခြင်း၊ ပြည်ထောင်စု)၊:|အော်ပရေတာ,union()

union set (ပေါင်းစည်းခြင်း၊ union) ဖြင့် ရယူနိုင်ပါသည်။ အော်ပရေတာ သို့မဟုတ် 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() ဖြင့် သတ်မှတ်အမျိုးအစားသို့ ပြောင်းလဲနိုင်သော စာရင်းများနှင့် tuple များကို အကြောင်းပြချက်များအဖြစ် သတ်မှတ်နိုင်သည်။ နောက်ဆက်တွဲ အော်ပရေတာများနှင့် နည်းလမ်းများနှင့် အကျုံးဝင်ပါသည်။

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

ထုတ်ကုန်အစုံ (ဘုံအပိုင်း၊ လမ်းဆုံနှင့် လမ်းဆုံ) ကို & အော်ပရေတာ သို့မဟုတ် လမ်းဆုံ() နည်းလမ်း။

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}

symmetry ခြားနားချက်အစုံ:^ အော်,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()

set တစ်ခုသည် အခြား set တစ်ခု၏ ခွဲဆက်တစ်ခု ဟုတ်မဟုတ် ဆုံးဖြတ်ရန်၊ <= operator သို့မဟုတ် issubset() method ကို အသုံးပြုပါ။

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

<= အော်ပရေတာနှင့် issubset() နည်းလမ်းနှစ်ခုလုံးသည် ညီမျှသောအတွဲများအတွက် မှန်ပါသည်။

၎င်းသည် စစ်မှန်သောအစုခွဲတစ်ခုဟုတ်မဟုတ် ဆုံးဖြတ်ရန်၊ ညီမျှသောအတွဲများအတွက် false ပြန်ပေးသည့် <= အော်ပရေတာကို အသုံးပြုပါ။

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

အထက်ပိုင်းသတ်မှတ်သည်ဖြစ်စေ၊:>= အော်ပရေတာ,issuperset()

တစ်ခုသည် အခြားတစ်ခု၏ superset ဖြစ်မဖြစ် ဆုံးဖြတ်ရန် >= အော်ပရေတာ သို့မဟုတ် issuperset() ကို အသုံးပြုပါ။

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

>= အော်ပရေတာနှင့် issuperset() နည်းလမ်းနှစ်ခုလုံးသည် ညီမျှသောအတွဲများအတွက် မှန်ပါသည်။

၎င်းသည် စစ်မှန်သောစူပါဆက်ဆက်ဟုတ်မဟုတ် ဆုံးဖြတ်ရန်၊ ညီမျှသောအတွဲများအတွက် false ပြန်ပေးသည့် >= အော်ပရေတာကို အသုံးပြုပါ။

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

နှစ်ဦးနှစ်ဖက် အချုပ်အခြာဖြစ်ခြင်း ရှိ၊မရှိ ဆုံးဖြတ်ခြင်း။:isdisjoint()

အစုံနှစ်ခုသည် တစ်ခုနှင့်တစ်ခု တူညီမှုရှိမရှိ ဆုံးဖြတ်ရန် isdisjoint() method ကို အသုံးပြုပါ။

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True