Back to the topics list

လုပ်ဆောင်ချက်များကိုသတ်မှတ်ခြင်း။

Functions များကို သတ်မှတ်ခြင်း။

ဒီသင်ခန်းစာမှာ functions တွေအကြောင်း လေ့လာပါမယ်။ လုပ်ဆောင်ချက်တစ်ခုသည် ကွန်ပြူတာကို ဘာလုပ်ရမည်ကို ပြောပြသည့် ဟင်းချက်နည်းကဲ့သို့ သေးငယ်သော ညွှန်ကြားချက်များဖြစ်သည်။ လုပ်ဆောင်ချက်များသည် ပြဿနာကြီးများကို အပိုင်းငယ်များအဖြစ် ခွဲခြမ်းရန် ကူညီပေးပါသည်။ ၎င်းတို့သည် ကျွန်ုပ်တို့၏အလုပ်ကို ပိုမိုလွယ်ကူစေပြီး ကျွန်ုပ်တို့၏အစီအစဉ်များကို ပိုမိုရှင်းလင်းစေသည်။ ယနေ့တွင် အဘယ်လုပ်ဆောင်ချက်များ၊ ၎င်းတို့ကို ကျွန်ုပ်တို့အသုံးပြုရသနည်း၊ ၎င်းတို့သည် ကျွန်ုပ်တို့အား ရိုးရှင်းသောနည်းလမ်းဖြင့် ပရိုဂရမ်များဖန်တီးရာတွင် ကူညီပေးပုံတို့ကို ကြည့်ရှုပါမည်။

နိဒါန်း

သင့်တွင် အမြဲတူညီသောအလုပ်လုပ်ဆောင်သည့် အရုပ်စက်တစ်ခုရှိသည်ကို မြင်ယောင်ကြည့်ပါ။ ခလုတ်တစ်ခုကို နှိပ်လိုက်တာနဲ့ စက်က သီချင်းဆိုတယ်။ ကွန်ပြူတာ ပရိုဂရမ်တစ်ခုရှိ လုပ်ဆောင်ချက်သည် အလားတူနည်းလမ်းဖြင့် အလုပ်လုပ်သည်။ ၎င်းသည် သင် ထပ်ခါထပ်ခါ အသုံးပြုနိုင်သော ညွှန်ကြားချက်အစုတစ်ခုဖြစ်သည်။ သင်သည် လုပ်ဆောင်ချက်ကို တစ်ကြိမ်သတ်မှတ်ပြီး ၎င်းကို အသုံးပြုလိုသည့်အခါတိုင်း ၎င်းကို ခေါ်နိုင်သည်။ ဤအကြံဉာဏ်သည် ပရိုဂရမ်များကို နားလည်လွယ်စေပြီး တည်ဆောက်ရန် ပိုမိုမြန်ဆန်စေသည်။

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

Function ဆိုတာဘာလဲ။

လုပ်ဆောင်ချက်တစ်ခုသည် သီးခြားလုပ်ငန်းတစ်ခုကို လုပ်ဆောင်သည့် ကုဒ်အမည်ရှိ ဘလော့တစ်ခုဖြစ်သည်။ မင်းရဲ့ ပိုကြီးတဲ့ ပရိုဂရမ်အတွင်းက မီနီပရိုဂရမ်တစ်ခုလို့ ထင်မြင်နိုင်ပါတယ်။ လုပ်ငန်းငယ်တစ်ခုလုပ်ဆောင်ရန် လုပ်ဆောင်ချက်များကို ရေးသားထားသည်။ ၎င်းတို့သည် နံပါတ်များထည့်ခြင်း၊ တစ်စုံတစ်ဦးအား နှုတ်ဆက်ခြင်း သို့မဟုတ် ဖန်သားပြင်ပေါ်တွင် ပုံများဆွဲခြင်းတို့ ပြုလုပ်နိုင်သည်။ စိတ်ကူးသည် လုပ်ဆောင်ချက်အတွင်းတွင် လုပ်ဆောင်စရာအသေးစိတ်များကို ဝှက်ထားရန်ဖြစ်သည်။ ထိုနည်းအားဖြင့် သင်သည် အလုပ်ပြီးမြောက်ရန် လိုအပ်သောအခါတွင် လုပ်ဆောင်ချက်ကို ၎င်း၏အမည်ဖြင့်သာ ခေါ်ရန် လိုအပ်သည်။

ဥပမာအားဖြင့်၊ ရိုးရှင်းသောလုပ်ဆောင်ချက်သည် မီးခလုတ်တစ်ခုကဲ့သို့ ဖြစ်နိုင်ပါသည်။ ခလုတ်ကို လှန်လိုက်သောအခါတွင် မီးပွင့်သည်။ အလားတူပင် သင်သည် လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်သောအခါ၊ ကွန်ပျူတာသည် ၎င်းအတွင်းရှိ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်သည်။ ၎င်းသည် သင့်အလုပ်ကို သပ်ရပ်စွာ ထိန်းသိမ်းထားပြီး မည်သည့်ပြဿနာများကိုမဆို ရှာဖွေရန်နှင့် ဖြေရှင်းရန် လွယ်ကူစေသည်။

ကျွန်ုပ်တို့ ဘာကြောင့် Functions ကိုသုံးတာလဲ။

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

သင်သည် LEGO ရဲတိုက်ကြီးတစ်ခုကို တည်ဆောက်နေသည်ဟု မြင်ယောင်ကြည့်ပါ။ ရဲတိုက်ကြီးတစ်ခုလုံးကို တည်ဆောက်ဖို့အတွက် သေးငယ်တဲ့ အတုံးသေးသေးလေးတွေကို အသုံးပြုပါ။ သေးငယ်သော ဘလောက်တစ်ခုစီသည် သီးခြားအလုပ်တစ်ခုကို လုပ်ဆောင်သည့် လုပ်ဆောင်ချက်တစ်ခုနှင့်တူသည်။ တုံးအားလုံးကို ပေါင်းလိုက်သောအခါတွင် ပြီးပြည့်စုံသော ရဲတိုက်ရှိသည်။ အလားတူပင်၊ တစ်ဦးချင်းလုပ်ဆောင်ချက်များသည် ပြီးပြည့်စုံသော ပရိုဂရမ်တစ်ခုဖြစ်သည်။

Function တစ်ခုကို ဘယ်လိုသတ်မှတ်မလဲ။

အထူးကုဒ်သုံးပြီး လုပ်ဆောင်ချက်တစ်ခုကို ကျွန်ုပ်တို့ သတ်မှတ်နိုင်သည်။ ပရိုဂရမ်းမင်းဘာသာစကားများစွာတွင် ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့လုပ်ဆောင်နေသောကွန်ပျူတာကိုဖော်ပြသောသော့ချက်စကားလုံးကိုအသုံးပြုသည်။ ပရိုဂရမ်းမင်းကို သင်ကြားရာတွင် လူကြိုက်များသော ဘာသာစကားတစ်ခုမှာ Python ဖြစ်သည်။ Python တွင်၊ function တစ်ခုစတင်ရန် စကားလုံး def ကို အသုံးပြုသည်။ ဤသည်မှာ ရိုးရှင်းသော ဥပမာတစ်ခုဖြစ်သည်။

ဥပမာ-

 def say_hello():
    print("မင်္ဂလာပါ သူငယ်ချင်း!")
  

ဤဥပမာတွင်၊ function ကို say_hello ဟုခေါ်သည်။ def ဟူသော စကားလုံးသည် ကျွန်ုပ်တို့သည် လုပ်ဆောင်မှုတစ်ခုကို အဓိပ္ပါယ်ဖွင့်ဆိုနေသည်မှာ ကွန်ပျူတာကို ပြောပြသည်။ လုပ်ဆောင်ချက်သည် တစ်ချက်လုပ်ဆောင်သည်- ၎င်းသည် ဖန်သားပြင်ပေါ်တွင် ဖော်ရွေသော မက်ဆေ့ချ်ကို ပရင့်ထုတ်သည်။

ဤလုပ်ဆောင်ချက်ကို ကျွန်ုပ်တို့ သတ်မှတ်ပြီးသည်နှင့်၊ ကျွန်ုပ်တို့၏ ပရိုဂရမ်တွင် ၎င်းကို နောက်ပိုင်းတွင် အသုံးပြုနိုင်ပါသည်။ ၎င်းကို function ဟုခေါ်သည် ။ ၎င်းကိုခေါ်တိုင်း ကွန်ပျူတာသည် လုပ်ဆောင်မှုအတွင်းရှိ အဆင့်အားလုံးကို လုပ်ဆောင်မည်ဖြစ်သည်။

Functions များ၏ ရိုးရှင်းသော ဥပမာများ

ယခု ကျွန်ုပ်တို့သည် ရိုးရှင်းသော လုပ်ဆောင်ချက်များ၏ နမူနာသုံးခုကို ကြည့်ပါမည်။ ၎င်းတို့သည် နားလည်ရန် လွယ်ကူပြီး အခြေခံ အယူအဆများကို လေ့လာရန် ကူညီပေးပါသည်။

ဥပမာ 1- နှုတ်ဆက်ခြင်းလုပ်ဆောင်ချက်

ပထမဥပမာတွင်၊ ကျွန်ုပ်တို့သည် တစ်စုံတစ်ဦးကို နာမည်ဖြင့်နှုတ်ဆက်သည့် လုပ်ဆောင်ချက်တစ်ခုကို ဖန်တီးသည်။ လုပ်ဆောင်ချက်ကို ဖုန်းခေါ်ဆိုသည့်အခါ သူငယ်ချင်းတစ်ဦးအား နှုတ်ဆက်ပါမည်။

ကုဒ်-

 def နှုတ်ဆက်ခြင်း(အမည်)-
    print("မင်္ဂလာပါ" +နာမည် +"!")
  
# "Alice" အမည်ဖြင့် လုပ်ဆောင်ချက်ကို ခေါ်ဆိုခြင်း
နှုတ်ဆက်ပါ ("အဲလစ်")
  

အဆင့်ဆင့် ရှင်းလင်းချက်-

• function greet ကို name လို့ခေါ်တဲ့ parameter တစ်ခုနဲ့ သတ်မှတ်ပါတယ်။
• လုပ်ဆောင်ချက်ကို ခေါ်သောအခါ၊ သင်ဖြတ်သန်းသောတန်ဖိုး ("Alice" ကဲ့သို့) ကိုယူ၍ "Hello, Alice!" မျက်နှာပြင်ပေါ်တွင်။
• လုပ်ဆောင်ချက်ကို မည်သည့်အမည်ဖြင့်မဆို ခေါ်ဆိုနိုင်ပြီး ဖော်ရွေသော နှုတ်ခွန်းဆက်မှုကို အမြဲပြသမည်ဖြစ်သည်။

ဥပမာ 2- Addition Function

ဒုတိယဥပမာတွင်၊ ကျွန်ုပ်တို့သည် ဂဏန်းနှစ်လုံးကို ပေါင်းထည့်သည့် လုပ်ဆောင်ချက်တစ်ခုကို ရေးသည်။ ၎င်းသည် ဂဏန်းများကို ပေါင်းထည့်သည့် အသေးစားဂဏန်းတွက်စက်နှင့် တူသည်။

ကုဒ်-

 def add_numbers(num1၊ num2):
    ရလဒ် = နံပါတ် 1 + နံပါတ် 2
    print("ပေါင်းလဒ်သည်:", ရလဒ်)
  
# နံပါတ် 3 နှင့် 5 ဖြင့်လုပ်ဆောင်ချက်ကိုခေါ်ဆိုခြင်း။
add_numbers(3၊ 5)
  

အဆင့်ဆင့် ရှင်းလင်းချက်-

• လုပ်ဆောင်ချက် add_numbers များကို ကန့်သတ်ချက်များ နှစ်ခုဖြင့် သတ်မှတ်သည်- num1 နှင့် num2 .
• လုပ်ဆောင်ချက်အတွင်းတွင် ဂဏန်းနှစ်လုံးကို ပေါင်းထည့်ထားသည်။ ဤစုစုပေါင်းကို ရလဒ် ဟုခေါ်သော ကိန်းရှင်တွင် သိမ်းဆည်းထားသည်။
• ထို့နောက် function သည် "sum is:" ပြီးနောက် ရလဒ် တန်ဖိုးကို print ထုတ်သည်။
• add_numbers(3၊ 5) ကို ခေါ်သောအခါ၊ function သည် 8 ကိုပေးရန်အတွက် 3 နှင့် 5 ကိုပေါင်းထည့်သည်၊ ထို့နောက် printed ။

ဥပမာ 3- Multiplication Function

တတိယဥပမာတွင်၊ ကျွန်ုပ်တို့သည် နံပါတ်တစ်ခုကို 2 ဖြင့်မြှောက်သည့် လုပ်ဆောင်ချက်တစ်ခုကို ဖန်တီးပါမည်။ ဤလုပ်ဆောင်ချက်သည် နောက်ပိုင်းအသုံးအတွက် တန်ဖိုးတစ်ခုကို မည်သို့ပြန်ပို့ပေးနိုင်သည်ကို ဤလုပ်ဆောင်ချက်က ပြသသည်။

ကုဒ်-

 def multiply_by_ two(x):
    new_value = x * 2
    new_value ကို ပြန်ပေးပါ။
  
# လုပ်ဆောင်ချက်ကိုခေါ်ဆိုပြီးရလဒ်ကိုသိမ်းဆည်းပါ။
ရလဒ် = multiply_by_ two(4)
print("4 နှင့် 2 is", ရလဒ်)
  

အဆင့်ဆင့် ရှင်းလင်းချက်-

• လုပ်ဆောင်ချက် multiply_by_two ကို ကန့်သတ်ချက် x တစ်ခုဖြင့် သတ်မှတ်သည်။
• လုပ်ဆောင်ချက်အတွင်းတွင် x ၏တန်ဖိုးကို 2 ဖြင့်မြှောက်ပြီး new_value ဟုခေါ်သော variable တွင် သိမ်းဆည်းထားသည်။
• လုပ်ဆောင်ချက်သည် ရလဒ်ကို လုပ်ဆောင်ချက်ဟုခေါ်သည့်နေရာသို့ ပြန်ပေးပို့ရန် သော့ချက် စကားလုံးကို အသုံးပြုသည်။
• ကျွန်ုပ်တို့ multiply_by_two(4) ကို ခေါ်သောအခါ၊ function သည် 4 နှင့် 2 နှင့် 8 ကို တွက်ပြီး ဤတန်ဖိုးကို ပြန်ပေးသည်။
• ပြန်ပေးသည့်တန်ဖိုးကို ရလဒ် အမည်ရှိ ကိန်းရှင်တစ်ခုတွင် သိမ်းဆည်းထားပြီး၊ ထို့နောက် ရိုက်နှိပ်ထားသည်။

Parameters နှင့် Return Values ​​ကို နားလည်ခြင်း။

လုပ်ဆောင်ချက်များသည် ဘောင်များမှ တဆင့် ပြင်ပမှ အချက်အလက်များကို လက်ခံနိုင်သည်။ ဘောင်တစ်ခုသည် လုပ်ဆောင်ချက်တစ်ခုအား ခေါ်သောအခါတွင် ဒေတာကို သိမ်းဆည်းသည့် ကိန်းရှင်တစ်ခုဖြစ်သည်။ ကျွန်ုပ်တို့၏နမူနာများတွင်၊ name ၊ num1 ၊ num2 နှင့် x တို့သည် parameters များဖြစ်သည်။

အချို့သောလုပ်ဆောင်ချက်များသည် တန်ဖိုးများကို ပြန်ပေးသည် ။ return value သည် function က ၎င်းကို လုပ်ဆောင်ပြီးနောက် ပြန်ပေးသည့် ရလဒ်ဖြစ်သည်။ ဥပမာ 3 တွင်၊ function multiply_by_two သည် variable တွင်သိမ်းဆည်းထားသည့်တန်ဖိုးကိုပြန်ပေးသည်။

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

Modular ပရိုဂရမ်ရေးဆွဲခြင်း- ပြဿနာများကို အပိုင်းပိုင်းအဖြစ် ခွဲထုတ်ခြင်း။

Function များသည် Modular ပရိုဂရမ်းမင်း တွင် အဓိကကျသော အယူအဆတစ်ခုဖြစ်သည်။ Modular programming ဆိုသည်မှာ ကြီးမားသော ပရိုဂရမ်တစ်ခုကို သေးငယ်သော၊ စီမံခန့်ခွဲနိုင်သော အစိတ်အပိုင်းများ သို့မဟုတ် မော်ဂျူးများအဖြစ် ပိုင်းခြားခြင်းဖြစ်သည်။ လုပ်ဆောင်ချက်တစ်ခုစီသည် ရိုးရှင်းသောအလုပ်တစ်ခုကို လုပ်ဆောင်သည့် module တစ်ခုနှင့်တူသည်။ Module များအားလုံး အတူတူအလုပ်လုပ်သောအခါ၊ ၎င်းတို့သည် ပြီးပြည့်စုံသော ပရိုဂရမ်တစ်ခုကို ဖန်တီးသည်။

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

Modular programming သည် ထပ်ခါထပ်ခါဖြစ်ခြင်းကို လျှော့ချပေးသည်။ သင့်ပရိုဂရမ်၏အစိတ်အပိုင်းတစ်ခုသည် တူညီသောအလုပ်တစ်ခုကို ထပ်ခါထပ်ခါလုပ်ဆောင်ရန် လိုအပ်ပါက၊ သင်သည် ၎င်းအတွက် လုပ်ဆောင်ချက်တစ်ခုကို ရေးပါ။ အဲဒီ့အလုပ်ပြီးတဲ့အခါတိုင်း၊ တူညီတဲ့ကုဒ်ကိုရေးမယ့်အစား function ကို ရိုးရိုးဖုန်းခေါ်လိုက်ပါ။

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

ဆက်စပ်သောနေ့စဉ်ဥပမာများ

နေ့စဉ်လုပ်ဆောင်ချက်များနှင့် လုပ်ဆောင်ချက်များကို နှိုင်းယှဉ်ကြည့်ကြပါစို့။ အိမ်မှာ အိမ်မှုကိစ္စတွေ အများကြီးရှိနေတယ်လို့ မြင်ယောင်ကြည့်ပါ။ မင်းရဲ့အလုပ်တွေထဲက တစ်ခုက အပင်တွေကို ရေလောင်းဖို့ပါပဲ။ ခြေလှမ်းအားလုံးကို အချိန်တိုင်း တွေးနေမယ့်အစား "အပင်တွေကို ရေလောင်းပါ" လို့ မှတ်သားထားနိုင်ပါတယ်။ သင်အပင်များကိုအလုပ်လုပ်တိုင်း၊ သင်သည်သင်၏ကိုယ်ပိုင်လုပ်ဆောင်ချက်ကိုအသုံးပြုသည်။

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

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

လုပ်ဆောင်ချက်များကို သတ်မှတ်ခြင်းအကြောင်း နောက်ထပ်

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

အထွေထွေဖွဲ့စည်းပုံ-

 def function_name(parameter1၊ parameter2၊ ...):
    # ကုဒ်ပိတ်ဆို့
    လိုအပ်ပါက some_value # ကို ပြန်ပေးပါ။
  

ဤတွင် function_name သည် function ၏အမည်ဖြစ်သည်။ ကန့်သတ်ချက်များ သည် လုပ်ဆောင်ချက်ကို အသုံးပြုသည့် ထည့်သွင်းမှုများဖြစ်သည်။ ကုဒ်ပိတ်ဆို့ခြင်း သည် လုပ်ဆောင်ချက်ကို လုပ်ဆောင်မည့် ညွှန်ကြားချက်အစုအဝေးဖြစ်သည်။ နောက်ဆုံးတွင် return ရလဒ်ကို ပြန်ပေးသည်။

တစ်ခါတရံတွင် မည်သည့် ကန့်သတ်ချက်များမှ မပါဝင်သည့် လုပ်ဆောင်ချက်များကို သင်တွေ့နိုင်သည်။ လုပ်ဆောင်ချက်တစ်ခုသည် အပိုအချက်အလက်များ မလိုအပ်သောအခါ၊ သင်သည် ကွင်းစဥ်များကို ရေးနေသေးသော်လည်း ၎င်းတို့သည် ဗလာဖြစ်နေသည်။ အလားတူ၊ များစွာသော လုပ်ဆောင်ချက်များသည် မက်ဆေ့ချ်များ ပုံနှိပ်ခြင်းကဲ့သို့ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်ပြီး မည်သည့်တန်ဖိုးကိုမျှ ပြန်မပေးပါ။

Functions များ၏ မရှိမဖြစ် ဂုဏ်သတ္တိများ

ဤသည်မှာ သင်မှတ်သားထားသင့်သည့် လုပ်ဆောင်ချက်များ၏ အရေးကြီးသော ဂုဏ်သတ္တိများ ဖြစ်သည် ။

• ပြန်သုံးနိုင်မှု- လုပ်ဆောင်ချက်တစ်ခုကို သတ်မှတ်ပြီးသည်နှင့် တူညီသောကုဒ်ကို ထပ်မရေးဘဲ ၎င်းကို အကြိမ်များစွာ အသုံးပြုနိုင်သည်။
• Modularity- လုပ်ဆောင်ချက်များသည် ပရိုဂရမ်အား သေးငယ်သော အစိတ်အပိုင်းများအဖြစ် ခွဲခြမ်းရန် ကူညီပေးသည်။ အပိုင်းတစ်ခုစီသည် သီးခြားအလုပ်တစ်ခုစီ လုပ်ဆောင်သည်။
• ထိန်းသိမ်းနိုင်မှု- အမှားအယွင်းတစ်ခု သို့မဟုတ် အပြောင်းအလဲတစ်ခု လိုအပ်ပါက၊ ကုဒ်စာကြောင်းများစွာအစား လုပ်ဆောင်ချက်တစ်ခုတည်းကို သင်ပြင်နိုင်သည်။
• ရှင်းလင်းချက်- လုပ်ဆောင်ချက်များသည် ပရိုဂရမ်ကို ဖတ်ရလွယ်ကူစေသည်။ ကုဒ်များစွာကိုဖတ်မည့်အစား၊ အပိုင်းတစ်ခုစီ၏လုပ်ဆောင်ပုံကိုပြောပြသော ရှင်းလင်းသောလုပ်ဆောင်ချက်အမည်များကို သင်တွေ့ရပါမည်။

ဤဂုဏ်သတ္တိများကို လိုက်နာခြင်းဖြင့်၊ ပရိုဂရမ်မာများသည် နားလည်ရပိုလွယ်သော ပရိုဂရမ်များကို ဖန်တီးနိုင်သည်၊ အမှားရှာပြင်နိုင်ပြီး အချိန်ကြာလာသည်နှင့်အမျှ တိုးတက်ကောင်းမွန်လာနိုင်သည်။ သင့်အရုပ်များကို သေတ္တာများအတွင်း စီခွဲခြင်းဖြင့် သင့်အခန်းကို သပ်ရပ်အောင် ထားရှိခြင်းကဲ့သို့ပင်၊ လုပ်ဆောင်ချက်များသည် ပရိုဂရမ်များကို သပ်သပ်ရပ်ရပ်နှင့် စနစ်တကျ ထိန်းသိမ်းထားသည်။

ကွဲပြားမှုများနှင့် ပိုမိုအဆင့်မြင့်သော အတွေးအခေါ်များ

လုပ်ဆောင်ချက်တွေရဲ့ စိတ်ကူးကို ပိုအဆင်ပြေလာတာနဲ့အမျှ ကွဲပြားမှုတွေ အနည်းငယ် ကြုံတွေ့ရနိုင်ပါတယ်။ တစ်ခါတစ်ရံတွင် လုပ်ဆောင်ချက်များသည် မည်သည့်အရာကိုမျှ ပြန်မရနိုင်ပါ။ လုပ်ဆောင်ချက်တွေပဲ လုပ်တယ်။ အခြားအချိန်များတွင် လုပ်ဆောင်ချက်များသည် အခြားလုပ်ဆောင်ချက်များကို ခေါ်ဆိုနိုင်သည်။ ၎င်းကို nesting functions သို့မဟုတ် function composition ဟုခေါ်သည်။

ဥပမာအားဖြင့်၊ လုပ်ဆောင်ချက်တစ်ခုသည် အခြားလုပ်ဆောင်စရာတစ်ခုကို မစတင်မီ နှုတ်ဆက်ခြင်း လုပ်ဆောင်ချက်ကို ခေါ်နိုင်သည်။ ဤလုပ်ဆောင်ချက်များ၏ အလွှာသည် သင့်အား သေးငယ်ပြီး ရိုးရှင်းသော လုပ်ဆောင်စရာများစွာမှ ရှုပ်ထွေးသော ပရိုဂရမ်များကို တည်ဆောက်နိုင်စေပါသည်။

နောက်ပိုင်းအဆင့်တွင်၊ recursive functions ကဲ့သို့သော အကြောင်းအရာများကို သင်လေ့လာနိုင်ပါသည်။ recursive function သည် သူ့ဘာသာသူ ခေါ်ဆိုသော တစ်ခုဖြစ်သည်။ ဤအကြံအစည်သည် အနည်းငယ် ဆန်းကျယ်သည်ဟု ထင်ရသော်လည်း ပြဿနာများကို သေးငယ်သော အစိတ်အပိုင်းများအဖြစ် ခွဲခြမ်းရန် အခြားနည်းလမ်းတစ်ခုဖြစ်သည်။ ယခုအချိန်တွင်၊ လုပ်ဆောင်ချက်များသည် သင့်အား စမတ်ကျပြီး သပ်ရပ်သောကုဒ်ရေးရန် ကူညီပေးကြောင်း သိရန် လုံလောက်ပါသည်။

ထပ်လောင်းဥပမာများနှင့် အဆင့်ဆင့်ဖြေရှင်းချက်

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

ဥပမာ 4- ကိန်းဂဏန်းများကို စစ်ဆေးရန် လုပ်ဆောင်ချက်တစ်ခု

 def is_even(နံပါတ်)-
    # နံပါတ်တူရှိမရှိ စစ်ဆေးပါ။
    အကယ်၍ နံပါတ် %2 == 0:
        အမှန်ပြန်ပါ။
    အခြား:
        False ပြန်လာပါ။

# နံပါတ် 6 ကိုစစ်ဆေးရန် function ကိုအသုံးပြုခြင်း။
ရလဒ် = is_even(6)
print("6 ညီလား?"၊ ရလဒ်)
  

အဆင့်ဆင့် ရှင်းလင်းချက်-

• လုပ်ဆောင်ချက်သည် _even သည် နံပါတ် အမည်ရှိသော ပါရာမီတာတစ်ခုကို ယူသည်။
• ၎င်းသည် modulus operator % ကို အသုံးပြု၍ 2 နှင့် ပိုင်းထားသော နံပါတ်တွင် အကြွင်းမရှိ၊ စစ်ဆေးပေးပါသည်။
• အကြွင်းမရှိပါက၊ function သည် True ဖြစ်သည်၊ ဆိုလိုသည်မှာ နံပါတ်သည် ပင်ဖြစ်ပါသည်။
• အကြွင်းတစ်ခုရှိလျှင် function သည် False ပြန်ပေးသည်။
• is_even(6) ကို ခေါ်သောအခါ၊ function သည် 6 ကို ညီကြောင်း စစ်ဆေးပြီး တွေ့ရှိသောကြောင့် ၎င်းသည် True ပြန်သွားပါသည်။

ဥပမာ 5- စတုရန်းတစ်ခု၏ ဧရိယာကို တွက်ချက်ရန် လုပ်ဆောင်ချက်တစ်ခု

 def area_of_square(ဘေး_အလျား):
    # ဖော်မြူလာကို အသုံးပြု၍ ဧရိယာကို တွက်ချက်ပါ- area = side_length * side_length
    ဧရိယာ = ဘေး_အလျား * ဘေး_အလျား
    ပြန်ဧရိယာ

# အလျား 5 ရှိသော စတုရန်းတစ်ခု၏ ဧရိယာကို တွက်ချက်ရန် လုပ်ဆောင်ချက်ကို အသုံးပြုခြင်း။
square_area = ဧရိယာ_of_square(5)
print("စတုရန်း၏ဧရိယာသည်", square_area)
  

အဆင့်ဆင့် ရှင်းလင်းချက်-

• လုပ်ဆောင်ချက် area_of_square သည် side_length ကို ကန့်သတ်ချက်အဖြစ် အသုံးပြုသည်။
• လုပ်ဆောင်ချက်အတွင်း၊ ၎င်းသည် ဘေးထွက်အလျားကို သူ့ဘာသာသူ မြှောက်ပေးသည်။ ၎င်းသည် သင်္ချာဖော်မြူလာ \(\textrm{ဧရိယာ} = \textrm{ဘေး\_အရှည်} \times \textrm{ဘေး\_အရှည်}\) လိုက်နာသည်။
• ထို့နောက် တွက်ချက်ထားသော ဧရိယာကို ပရိုဂရမ်၏ ပင်မအပိုင်းသို့ ပြန်သွားပါသည်။
• area_of_square(5) ကို ခေါ်သောအခါ၊ function သည် 25 ကိုပေးရန် \(5 \times 5\) ကိုတွက်ချက်သည်။

ဥပမာ 6- ဂဏန်းနှစ်လုံး၏ ပိုကြီးခြင်းကို ဆုံးဖြတ်ရန် လုပ်ဆောင်ချက်တစ်ခု

 def larger_number(a၊ b):
    # ဂဏန်းနှစ်လုံးကို နှိုင်းယှဉ်ပြီး ပိုကြီးသောနံပါတ်ကို ပြန်ပေးပါ။
    a > b ဆိုရင်
        ပြန်လာပါ။
    အခြား:
        ပြန်လာခ

# 7 နှင့် 10 အကြားပိုကြီးသောနံပါတ်ကိုရှာဖွေရန် function ကိုအသုံးပြုခြင်း။
အကြီးဆုံး = larger_number(7၊ 10)
print("ပိုကြီးသောနံပါတ်သည်" အကြီးဆုံး)
  

အဆင့်ဆင့် ရှင်းလင်းချက်

• ပိုကြီး_နံပါတ် လုပ်ဆောင်ချက်သည် ဘောင်နှစ်ခုယူသည်- a နှင့် b ။
• ၎င်းသည် ဂဏန်းနှစ်လုံးကို နှိုင်းယှဉ်သည်။
• a သည် b ထက် ကြီးပါက a ကို ပြန်ပေးသည်။ မဟုတ်ရင် b ပြန်လာမယ်။
• ဥပမာတွင်၊ larger_number(7၊ 10) သည် 10 သည် 7 ထက်ကြီးသောကြောင့် 10 ကိုပြန်ပေးသည်။

Modularity အတွက် Functions တွေက ဘာကြောင့်အရေးကြီးတာလဲ။

Functions များသည် ကျွန်ုပ်တို့အား modular နည်းလမ်းဖြင့် ပရိုဂရမ်များတည်ဆောက်ရာတွင် ကူညီပေးသည့် အစွမ်းထက်သောကိရိယာတစ်ခုဖြစ်သည်။ လုပ်ဆောင်ချက်များကို အသုံးပြု၍ လွတ်လပ်စွာ လုပ်ဆောင်နိုင်သော သင့်ပရိုဂရမ်၏ သီးခြားအစိတ်အပိုင်းများကို ဖန်တီးနိုင်သည်။ ဆိုလိုသည်မှာ သင့်ပရိုဂရမ်၏ အစိတ်အပိုင်းတစ်ခုတွင် အမှားအယွင်းရှိနေပါက သို့မဟုတ် တိုးတက်မှု လိုအပ်ပါက၊ ကုဒ်အမြောက်အမြားကို ရှာဖွေနေမည့်အစား ထိုလုပ်ဆောင်ချက်တစ်ခုကို ပြုပြင်ရန်သာ လိုအပ်ပါသည်။

Modular programming သည် LEGO blocks များဖြင့် တည်ဆောက်ခြင်းနှင့်တူသည်။ ဘလောက်တစ်ခုစီသည် သီးခြားဖြစ်ပြီး မတူညီသောဖွဲ့စည်းပုံများကို ဖန်တီးရန် နည်းလမ်းအမျိုးမျိုးဖြင့် ချိတ်ဆက်နိုင်သည်။ အကွက်တစ်ခု ပျက်သွားပါက ရဲတိုက်တစ်ခုလုံးကို ပြန်လည်တည်ဆောက်ရန် မလိုအပ်ဘဲ ၎င်းကို အစားထိုးနိုင်သည်။ လုပ်ဆောင်ချက်များဖြင့်၊ သင့်ပရိုဂရမ်၏ သေးငယ်သော အပိုင်းတစ်ခုစီကို တည်ဆောက်နိုင်၊ စမ်းသပ်နိုင်ပြီး ၎င်းတွင် ပြုပြင်နိုင်သည်။

ဤနည်းဖြင့် ပရိုဂရမ်ရေးဆွဲခြင်းသည် ပြဿနာများကို ပိုမိုနားလည်စေပြီး ရှုပ်ထွေးသောအလုပ်များကို ပိုမိုလွယ်ကူစေသည်။ ၎င်းသည် ပြဿနာများကို ယုတ္တိနည်းကျကျ တွေးခေါ်ပုံနှင့် ၎င်းတို့ကို အဆင့်ဆင့်ဖြေရှင်းနည်းကိုလည်း သင်ပေးပါသည်။

အဓိကအချက်များ အကျဉ်းချုပ်

• အဓိပ္ပါယ်ဖွင့်ဆိုချက်- လုပ်ဆောင်ချက်တစ်ခုသည် တိကျသောလုပ်ငန်းဆောင်တာတစ်ခုကို လုပ်ဆောင်သည့် ကုဒ်တစ်ခုဖြစ်သည်။
• ပြန်သုံးနိုင်မှု- လုပ်ဆောင်ချက်တစ်ခုကို သတ်မှတ်ပြီးသည်နှင့် ပရိုဂရမ်တစ်ခုတွင် အကြိမ်များစွာ အသုံးပြုနိုင်သည်။
• ဖွဲ့စည်းတည်ဆောက်ပုံ- Functions များကို အထူးသော့ချက်စကားလုံး (Python တွင် def ကဲ့သို့) အသုံးပြု၍ သတ်မှတ်သတ်မှတ်ထားပြီး parameters နှင့် return values ​​များ ပါဝင်နိုင်သည်။
• ရိုးရှင်းသောဥပမာများ- တစ်စုံတစ်ဦးကို နှုတ်ဆက်ရန်၊ နံပါတ်များထည့်ရန်၊ နံပါတ်တစ်ခုကို နှစ်ချက်မြှောက်ရန်၊ ဂဏန်းတစ်လုံးဖြစ်မဖြစ် စစ်ဆေးရန်၊ ဧရိယာတစ်ခုကို တွက်ချက်ပြီး ဂဏန်းနှစ်လုံးကို နှိုင်းယှဉ်ရန် လုပ်ဆောင်ချက်များကို ကျွန်ုပ်တို့ကြည့်ရှုခဲ့သည်။
• Modular Programming- Functions များသည် ကြီးမားသောပြဿနာကို သေးငယ်၍ ပိုမိုလွယ်ကူသော အစိတ်အပိုင်းများအဖြစ်သို့ ခွဲထုတ်ရန် ကူညီပေးပါသည်။ ၎င်းသည် ပရိုဂရမ်များကို ရေးရန်၊ ဖတ်ရန်နှင့် ပြင်ဆင်ရန် ပိုမိုလွယ်ကူစေသည်။
• နေ့စဉ် နှိုင်းယှဉ်ချက်- ဟင်းချက်နည်းကို လိုက်နာခြင်း သို့မဟုတ် ကြီးမားသော ဖွဲ့စည်းပုံကို တည်ဆောက်ရန်အတွက် သေးငယ်သော LEGO တုံးများကို အသုံးပြုခြင်းကဲ့သို့၊ လုပ်ဆောင်ချက်များသည် ကျွန်ုပ်တို့၏ နေ့စဉ်ဘဝတွင် အလုပ်များကို စုစည်းရန် ကူညီပေးပါသည်။
• ပျော့ပြောင်းမှု- ကန့်သတ်ချက်များသည် လုပ်ဆောင်ချက်များကို မတူညီသောထည့်သွင်းမှုများဖြင့် လုပ်ဆောင်နိုင်စေပြီး၊ ပြန်ပေးတန်ဖိုးများက ကျွန်ုပ်တို့အား ရလဒ်များကို အသုံးပြုနိုင်စွမ်းကို ပေးပါသည်။
• Real-World Impact- Functions နှင့် Modular Programming များသည် ဂိမ်းများ၊ အက်ပ်များနှင့် နေ့စဉ်လူနေမှုဘဝစနစ်များတွင် အသုံးပြုသည့် ခေတ်မီနည်းပညာများ၏ တည်ဆောက်မှုတုံးများဖြစ်သည်။

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

အမြဲတမ်းသတိရပါ- ကြီးမားတဲ့လုပ်ဆောင်မှုတိုင်းကို သေးငယ်တဲ့အဆင့်တွေကို အသုံးပြုခြင်းအားဖြင့် ပိုမိုလွယ်ကူအောင်ပြုလုပ်နိုင်ပြီး အဲဒီအဆင့်လေးတွေဟာ သင့်ပရိုဂရမ်ရဲ့လုပ်ဆောင်ချက်တွေဖြစ်ပါတယ်။

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