Python လုပ်ဆောင်ချက်များ
လုပ်ဆောင်ချက်တစ်ခုသည် ၎င်းကို ခေါ်သည့်အခါတွင်သာ လုပ်ဆောင်သည့် ကုဒ်တစ်ခုဖြစ်သည်။
ဒေတာများကို ဘောင်များဟုသိကြသော လုပ်ဆောင်ချက်တစ်ခုသို့ သင်ဖြတ်သန်းနိုင်သည်။
လုပ်ဆောင်ချက်တစ်ခုသည် ရလဒ်အဖြစ် ဒေတာကို ပြန်ပေးနိုင်သည်။
Function တစ်ခုဖန်တီးခြင်း။
Python တွင် def သော့ချက်စာလုံး ကို အသုံးပြု၍ လုပ်ဆောင်ချက်တစ်ခုကို သတ်မှတ်သည် ။
ဥပမာ
def my_function():
print("Hello from a function")
Function ကို ခေါ်သည်
လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ဆိုရန်၊ ကွင်းစဥ်ဖြင့် နောက်လိုက်သော လုပ်ဆောင်ချက်အမည်ကို အသုံးပြုပါ-
ဥပမာ
def my_function():
print("Hello from a function")
my_function()
အငြင်းပွားမှုများ
အချက်အလက်များကို အကြောင်းပြချက်များအဖြစ် လုပ်ငန်းဆောင်တာများသို့ လွှဲပြောင်းပေးနိုင်သည်။
ကွင်းစဥ်များအတွင်း၊ လုပ်ဆောင်ချက်အမည်ပြီးနောက် အကြောင်းပြချက်များကို သတ်မှတ်ပေးသည်။ အကြောင်းပြချက်များစွာကို သင်အလိုရှိသလောက်ထည့်နိုင်ပြီး ၎င်းတို့ကို ကော်မာတစ်ခုဖြင့် ခွဲရုံသာဖြစ်သည်။
အောက်ပါဥပမာတွင် အငြင်းအခုံတစ်ခု (fname) ဖြင့် လုပ်ဆောင်ချက်တစ်ခုရှိသည်။ လုပ်ဆောင်ချက်ကို ခေါ်သောအခါ၊ အမည်အပြည့်အစုံကို ပရင့်ထုတ်ရန် လုပ်ဆောင်ချက်အတွင်းတွင် အသုံးပြုသည့် ပထမအမည်တစ်ခုကို ကျွန်ုပ်တို့ ဖြတ်သွားသည်-
ဥပမာ
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
အကြောင်းပြချက် များကို Python စာရွက်စာတမ်းများတွင် args အဖြစ် အတိုချုံးလေ့ရှိသည် ။
ကန့်သတ်ချက်များ သို့မဟုတ် အကြောင်းပြချက်များ
သတ်မှတ်ချက် ဘောင် နှင့် အငြင်းအခုံ များကို တူညီသောအရာအတွက် အသုံးပြုနိုင်သည်။
လုပ်ဆောင်ချက်တစ်ခု၏ရှုထောင့်မှ
ဘောင်တစ်ခုသည် လုပ်ဆောင်ချက် အဓိပ္ပါယ်ဖွင့်ဆိုချက်ရှိ ကွင်းအတွင်း၌ ဖော်ပြထားသော ကိန်းရှင်ဖြစ်သည်။
အငြင်းအခုံတစ်ခုသည် ၎င်းကိုခေါ်သောအခါတွင် လုပ်ဆောင်ချက်ထံသို့ ပေးပို့သည့်တန်ဖိုးဖြစ်သည်။
အငြင်းအခုံအရေအတွက်
ပုံမှန်အားဖြင့်၊ မှန်ကန်သော အကြောင်းပြချက်အရေအတွက်ဖြင့် လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ရပါမည်။ ဆိုလိုသည်မှာ သင့် function သည် argument 2 ခုကို မျှော်လင့်ပါက၊ သင်သည် function ကို argument 2 ခုဖြင့် ခေါ်ဆိုရမည်ဖြစ်ပြီး၊ မပို၊ မနည်းပါ။
ဥပမာ
ဤလုပ်ဆောင်ချက်သည် အကြောင်းပြချက် 2 ခုကို မျှော်လင့်ထားပြီး အကြောင်းပြချက် 2 ခုကို ရရှိသည်-
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
ဥပမာ
ဤလုပ်ဆောင်ချက်သည် အကြောင်းပြချက် 2 ခုကို မျှော်လင့်သော်လည်း 1 သာရရှိသည်-
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil")
မတရား ငြင်းခုံမှုများ၊ *args
သင့်လုပ်ဆောင်ချက်ထဲသို့ ဖြတ်သွားမည့် အကြောင်းပြချက်များ မည်မျှရှိသည်ကို သင်မသိပါက၊ လုပ်ဆောင်ချက် *
အဓိပ္ပါယ်ဖွင့်ဆိုချက်တွင် ပါရာမီတာအမည်ရှေ့တွင် ပါရာမီတာအမည်ကို ထည့်ပါ။
ဤနည်းဖြင့် လုပ်ဆောင်ချက်သည် အငြင်းအခုံများစွာကို လက်ခံရရှိမည်ဖြစ်ပြီး လိုက်လျောညီထွေ ရှိသော အရာများကို ဝင်ရောက်ကြည့်ရှုနိုင်သည်-
ဥပမာ
အငြင်းအခုံအရေအတွက်ကို မသိပါက၊ *
ကန့်သတ်ချက်အမည်ရှေ့တွင် ထည့်ပါ-
def my_function(*kids):
print("The youngest child
is " + kids[2])
my_function("Emil", "Tobias", "Linus")
မတရားသော အကြောင်းပြချက်များကို Python စာရွက်စာတမ်းများတွင် *args အဖြစ် အတိုချုံးလေ့ရှိသည် ။
သော့ချက်စကားလုံး အငြင်းပွားမှုများ
key = value syntax ဖြင့် အကြောင်းပြချက်များ ပေးပို့နိုင်သည် ။
ဤနည်းဖြင့် ငြင်းခုံခြင်း၏အစီအစဥ်သည် အရေးမကြီးပါ။
ဥပမာ
def my_function(child3, child2, child1):
print("The youngest child
is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
စကားစု Keyword Arguments များကို Python စာရွက်စာတမ်းများတွင် kwargs များအဖြစ် အတိုချုံးလေ့ရှိသည် ။
မတရားသောသော့ချက်စကားလုံး အငြင်းပွားမှုများ၊ **kwargs
သင့်လုပ်ငန်းဆောင်တာတွင် သော့ချက်စကားလုံးအငြင်းအခုံများမည်မျှရှိသည်ကို သင်မသိပါက၊ လုပ်ဆောင်ချက်အဓိပ္ပါယ်ဖွင့် **
ဆိုချက်ရှိ ပါရာမီတာအမည်ရှေ့တွင် ကြယ်ပွင့်နှစ်ခုထည့်ပါ။
ဤနည်းဖြင့် လုပ်ဆောင်ချက်သည် အငြင်းအခုံများ၏ အဘိဓာန် ကို လက်ခံရရှိမည်ဖြစ်ပြီး လိုက်လျောညီထွေ ရှိသော အရာများကို ဝင်ရောက်ကြည့်ရှုနိုင်သည်-
ဥပမာ
အဓိကစကားလုံးအငြင်းပွားမှုအရေအတွက်ကို မသိပါက၊
**
ကန့်သတ်ချက်အမည်ရှေ့တွင် နှစ်ဆထည့်ပါ-
def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
မတရားသော Kword အငြင်းအခုံ များကို Python စာရွက်စာတမ်းများတွင် **kwargs ဟု အတိုချုံးလေ့ရှိသည် ။
မူရင်း ကန့်သတ်တန်ဖိုး
အောက်ဖော်ပြပါ ဥပမာသည် ပုံသေပါရာမီတာတန်ဖိုးကို မည်သို့အသုံးပြုရမည်ကို ပြသထားသည်။
အကြောင်းပြချက်မရှိဘဲ လုပ်ဆောင်ချက်ကို ကျွန်ုပ်တို့ခေါ်ဆိုပါက၊ ၎င်းသည် မူရင်းတန်ဖိုးကို အသုံးပြုသည်-
ဥပမာ
def my_function(country = "Norway"):
print("I am from " +
country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
စာရင်းတစ်ခုအား အငြင်းအခုံအဖြစ်ဖြတ်သန်းခြင်း။
သင်သည် လုပ်ဆောင်ချက်တစ်ခု (စာတန်း၊ နံပါတ်၊ စာရင်း၊ အဘိဓာန်စသည်) သို့ အကြောင်းပြချက်များ၏ မည်သည့်ဒေတာအမျိုးအစားကိုမဆို ပေးပို့နိုင်ပြီး ၎င်းကို လုပ်ဆောင်ချက်အတွင်းတွင် တူညီသောဒေတာအမျိုးအစားအဖြစ် သတ်မှတ်မည်ဖြစ်သည်။
ဥပမာအားဖြင့် စာရင်းတစ်ခုအား အငြင်းအခုံတစ်ခုအနေဖြင့် ပေးပို့ပါက၊ ၎င်းသည် လုပ်ဆောင်ချက်သို့ရောက်ရှိသည့်အခါ စာရင်းတစ်ခုအဖြစ် ရှိနေလိမ့်မည်-
ဥပမာ
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
တန်ဖိုးများ ပြန်ပေးသည်။
လုပ်ဆောင်ချက်တစ်ခုသည် တန်ဖိုးတစ်ခုပြန်ပေးရန်အတွက် return
ကြေညာချက်ကို အသုံးပြုပါ-
ဥပမာ
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
pass Statement ၊
function
အဓိပ္ပါယ်ဖွင့်ဆိုချက်များသည် ဗလာမဖြစ်နိုင်သော်လည်း အကြောင်းတစ်ခုခုကြောင့် သင့်တွင် function
အကြောင်းအရာမရှိသော အဓိပ္ပါယ်ဖွင့်ဆိုချက် တစ်ခုရှိနေပါ pass
က အမှားအယွင်းမဖြစ်စေရန်အတွက် ထုတ်ပြန်ချက်တွင် ထည့်သွင်းပါ။
ဥပမာ
def myfunction():
pass
ပြန်လှည့်ပါ။
Python သည် function recursion ကို လက်ခံသည်၊ ဆိုလိုသည်မှာ သတ်မှတ်ထားသော function သည် သူ့ဘာသာသူ ခေါ်နိုင်သည်။
Recursion သည် သာမန်သင်္ချာနှင့် ပရိုဂရမ်းမင်းအယူအဆတစ်ခုဖြစ်သည်။ ဆိုလိုသည်မှာ function တစ်ခုသည် သူ့အလိုလိုခေါ်သည်။ ၎င်းသည် ရလဒ်တစ်ခုရရှိရန် အချက်အလက်များကို လှည့်ပတ်ကြည့်ရှုနိုင်သည့် အဓိပ္ပာယ်ရှိသည်။
ဆော့ဖ်ဝဲရေးသားသူသည် အဆုံးမသတ်နိုင်သော လုပ်ဆောင်ချက် သို့မဟုတ် မန်မိုရီ သို့မဟုတ် ပရိုဆက်ဆာပါဝါကို ပိုလျှံသောပမာဏကို အသုံးပြုသည့် လုပ်ဆောင်ချက်ကို ရေးသားရာတွင် အလွန်လွယ်ကူသောကြောင့် ဆော့ဖ်ဝဲရေးသားသူသည် ပြန်လှည့်ခြင်းနှင့်ပတ်သက်၍ အလွန်သတိထားသင့်သည်။ သို့သော်၊ မှန်ကန်စွာရေးသားသည့်အခါ ပြန်ကောက်ချက်သည် ပရိုဂရမ်းမင်းအတွက် အလွန်ထိရောက်ပြီး သင်္ချာနည်းအရ အံဝင်ခွင်ကျဖြစ်နိုင်သည်။
ဤဥပမာတွင်၊ tri_recursion() သည် ကျွန်ုပ်တို့ကိုယ်တိုင် ("recurse") ဟုခေါ်ဆိုရန် သတ်မှတ်ထားသော လုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ ကျွန်ုပ်တို့ ပြန်သုံးသည့်အခါတိုင်း ( -1 ) ကို လျှော့ချပေးသော k variable ကို ဒေတာအဖြစ် အသုံးပြု ပါသည်။ အခြေအနေသည် 0 ထက်မပိုသောအခါ (ဆိုလိုသည်မှာ 0 ဖြစ်သောအခါ) အဆုံးသတ်သည်။
ဆော့ဖ်ဝဲရေးသားသူအသစ်အတွက် ၎င်းမည်ကဲ့သို့အလုပ်လုပ်သည်ကို အတိအကျသိရှိရန် အချိန်အနည်းငယ်ကြာနိုင်ပြီး၊ ၎င်းကို စမ်းသပ်ခြင်းနှင့် ပြုပြင်မွမ်းမံခြင်းဖြင့် သိရှိရန် အကောင်းဆုံးနည်းလမ်းဖြစ်သည်။
ဥပမာ
Recursion ဥပမာ
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("\n\nRecursion Example Results")
tri_recursion(6)