Python တွင် tuple သို့မဟုတ် list ၏ဒြပ်စင်များကို ချဲ့ထွင်ပြီး ကိန်းရှင်များစွာအတွက် သတ်မှတ်ပေးနိုင်ပါသည်။ ဒါကို sequence unpacking သို့မဟုတ် unpacked assignment လို့ခေါ်ပါတယ်။
အောက်ပါအသေးစိတ်အချက်အလက်များကို ဤနေရာတွင် ဖော်ပြထားပါသည်။
- tuples နှင့် list များ၏အခြေခံများကိုထုပ်ပိုးခြင်း
- အသိုက်အမြုပ်များ၊ ထုပ်ပိုးထားသောစာရင်းများ
- လေးထောင့်များဖြင့် ထုပ်ပိုးခြင်း:
_ - ကြယ်ပွင့်များဖြင့် ထုပ်ပိုးခြင်း:
*
tuples, lists, and dictionaries ကို function arguments အဖြစ် ချဲ့ထွင်ပြီး pass လုပ်ရန် ကြယ်ပွင့်များကို အသုံးပြုခြင်းဆိုင်ရာ အချက်အလက်များအတွက် အောက်ပါဆောင်းပါးကို ကြည့်ပါ။
tuples နှင့် list များ၏အခြေခံများကိုထုပ်ပိုးခြင်း
ကိန်းရှင်များကို ဘယ်ဘက်ခြမ်းတွင် ကော်မာများဖြင့် ပိုင်းခြားပြီး ရေးသားသောအခါ၊ ကိန်းရှင်တစ်ခုစီကို tuple ၏ဒြပ်စင်တစ်ခု သို့မဟုတ် ညာဖက်ခြမ်းတွင် စာရင်းသတ်မှတ်ပေးသည်။ tuples နှင့် lists နှစ်ခုလုံးအတွက် တူညီသည် (အောက်ပါ ဥပမာများကို tuple ပုံစံဖြင့် ရေးသားထားသည်)။
t = (0, 1, 2)
a, b, c = t
print(a)
print(b)
print(c)
# 0
# 1
# 2
l = [0, 1, 2]
a, b, c = l
print(a)
print(b)
print(c)
# 0
# 1
# 2
tuple များသည် round bracket များကို ချန်လှပ်ထားနိုင်သောကြောင့်၊ ၎င်းကို အောက်ပါအတိုင်း စာကြောင်းတစ်ခုပေါ်ရှိ variable အများအပြားသို့ တန်ဖိုးများစွာကို သတ်မှတ်ရန် ၎င်းကို အသုံးပြုနိုင်သည်။
a, b = 0, 1
print(a)
print(b)
# 0
# 1
ကိန်းရှင်အရေအတွက်သည် ဒြပ်စင်အရေအတွက်နှင့် မကိုက်ညီပါက အမှားအယွင်းတစ်ခု ဖြစ်ပေါ်သည်။
# a, b = t
# ValueError: too many values to unpack (expected 2)
# a, b, c, d = t
# ValueError: not enough values to unpack (expected 4, got 3)
ကိန်းရှင်အရေအတွက်သည် ဒြပ်စင်အရေအတွက်ထက် နည်းနေပါက၊ ကျန်ဒြပ်စင်များကို ပြောင်းလဲနိုင်သောအမည်သို့ ခရေပွင့်တစ်ခုထည့်ခြင်းဖြင့် စာရင်းတစ်ခုအဖြစ် သတ်မှတ်နိုင်သည် (အောက်တွင်ကြည့်ပါ)။
အသိုက်အမြုပ်များ၊ ထုပ်ပိုးထားသောစာရင်းများ
Nested tuples နှင့် lists များကိုလည်း ထုပ်ပိုးနိုင်ပါသည်။ အကြောင်းအရာများကို ထုပ်ပိုးလိုပါက အောက်ပါများထဲမှ တစ်ခုတွင် ကိန်းရှင်ကို ထည့်သွင်းပါ။
()[]
t = (0, 1, (2, 3, 4))
a, b, c = t
print(a)
print(b)
print(c)
# 0
# 1
# (2, 3, 4)
print(type(c))
# <class 'tuple'>
a, b, (c, d, e) = t
print(a)
print(b)
print(c)
print(d)
print(e)
# 0
# 1
# 2
# 3
# 4
_underscore_ ဖြင့်ထုပ်ပိုးထားသည်။
Python တွင်၊ ထုပ်ပိုးပြီးရုံသာမက၊ မလိုအပ်သောတန်ဖိုးများကို သမရိုးကျအားဖြင့် underscore (underscore) _ သို့ သတ်မှတ်ပေးပါသည်။ အထူးသဒ္ဒါအဓိပ္ပါယ် မရှိပါ။ ၎င်းတို့ကို _ ဟု အမည်ပေးထားသော ကိန်းရှင်တစ်ခုသို့ ရိုးရှင်းစွာသတ်မှတ်ထားသည်။
t = (0, 1, 2)
a, b, _ = t
print(a)
print(b)
print(_)
# 0
# 1
# 2
ကြယ်ပွင့်များဖြင့် ထုပ်ပိုးခြင်း
ကိန်းရှင်အရေအတွက်သည် ဒြပ်စင်အရေအတွက်ထက် နည်းပါက၊ ပြောင်းလဲနိုင်သောအမည်ရှိ ကြယ်ပွင့်တစ်ခုသည် ဒြပ်စင်များကို စာရင်းတစ်ခုအဖြစ် သတ်မှတ်ပေးမည်ဖြစ်သည်။
ဤ syntax ကို Python 3 ကတည်းက အကောင်အထည်ဖေါ်ခဲ့ပြီး Python 2 တွင် မရရှိနိုင်ပါ။
ဒြပ်စင်များကို အစမှနေ၍ အဆုံးတွင် ကြယ်ပွင့်များမပါဘဲ ကိန်းရှင်များထံ တာဝန်ပေးအပ်ပြီး ကျန်ဒြပ်စင်များကို ကြယ်ပွင့်များဖြင့် ကိန်းရှင်များအတွက် စာရင်းတစ်ခုအဖြစ် သတ်မှတ်ပေးသည်။
t = (0, 1, 2, 3, 4)
a, b, *c = t
print(a)
print(b)
print(c)
# 0
# 1
# [2, 3, 4]
print(type(c))
# <class 'list'>
a, *b, c = t
print(a)
print(b)
print(c)
# 0
# [1, 2, 3]
# 4
*a, b, c = t
print(a)
print(b)
print(c)
# [0, 1, 2]
# 3
# 4
ဥပမာအားဖြင့်၊ tuple တစ်ခု သို့မဟုတ် list ၏ ပထမဒြပ်စင်နှစ်ခုကိုသာ variable တစ်ခုသို့ သတ်မှတ်လိုပါက၊ မလိုအပ်သော အစိတ်အပိုင်းများအတွက် အထက်ဖော်ပြပါ အမှတ်များကို အသုံးပြုနိုင်သည်။
a, b, *_ = t
print(a)
print(b)
print(_)
# 0
# 1
# [2, 3, 4]
အလားတူပင် အောက်ပါအတိုင်း ရေးသားနိုင်သည်။
a, b = t[0], t[1]
print(a)
print(b)
# 0
# 1
ခရေပွင့်တစ်ခုသာ ပူးတွဲနိုင်သည်။ ခရေပွင့်ဖြင့် အမှတ်အသားပြုထားသော ကိန်းရှင်အများအပြားရှိနေပါက၊ ကိန်းရှင်တစ်ခုစီအတွက် အစိတ်အပိုင်းအရေအတွက်မည်မျှသတ်မှတ်ထားသည်ကို ဆုံးဖြတ်ရန် မဖြစ်နိုင်သောကြောင့် SyntaxError အမှားတစ်ခု ဖြစ်ပေါ်လာမည်ဖြစ်သည်။
# *a, b, *c = t
# SyntaxError: two starred expressions in assignment
ခရေပွင့်ဖြင့် အမှတ်အသားပြုထားသော ကိန်းရှင်တစ်ခုသို့ သတ်မှတ်ထားသော ဒြပ်စင်တစ်ခုတည်းကိုပင် စာရင်းအဖြစ် သတ်မှတ်ပေးထားကြောင်း သတိပြုပါ။
t = (0, 1, 2)
a, b, *c = t
print(a)
print(b)
print(c)
# 0
# 1
# [2]
print(type(c))
# <class 'list'>
အပိုဒြပ်စင်များ မရှိပါက၊ အလွတ်စာရင်းကို သတ်မှတ်ပေးသည်။
a, b, c, *d = t
print(a)
print(b)
print(c)
print(d)
# 0
# 1
# 2
# []