Python တွင် loop လုပ်နေစဉ်။ ဘယ်လိုအလုပ်လုပ်သလဲ၊ အသုံးပြုပုံ ဥပမာ

Loops သည် မည်သည့်ဘာသာစကား၏ အဓိကကိရိယာများထဲမှ တစ်ခုဖြစ်သည်။ Python တွင် အခြေခံ loop နှစ်ခုရှိပြီး တစ်ခုမှာ while ဖြစ်သည်။ ၎င်းကို ဆင်ခြင်ပါ၊ ရုပ်ပုံ၏ ပိုမိုကောင်းမွန်သော နားလည်မှုအတွက်၊ နောက်တစ်ခု။ အမှန်မှာ၊ အလားတူအရာနှင့် နှိုင်းယှဉ်လျှင် မည်သည့်ပစ္စည်းကိုမဆို နားလည်ရန် ပိုမိုလွယ်ကူသည်မဟုတ်လော။

သံသရာသဘောတရား

လုပ်ဆောင်ချက်တစ်ခုခုကို အကြိမ်များစွာ လုပ်ဆောင်ရန် လိုအပ်သည့်အခါ ကွင်းဆက်တစ်ခု လိုအပ်ပါသည်။ ၎င်းသည် အလွန်ရိုးရှင်းသောကြောင့် လက်တွေ့တွင် cycles အတွက် applications များ၏ အကွာအဝေးသည် ပိုမိုကျယ်ပြန့်သောကြောင့်ဖြစ်သည်။ Python တွင် အဓိက loop အမျိုးအစား နှစ်မျိုးရှိသည်- for and while. ရေပန်းအစားဆုံးကတော့.

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

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

သံသရာအတွက်

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

Python ရှိ ဤ loop ၏ အားသာချက်မှာ loop မှထွက်မည့်အချိန်ကို သိရန် element ၏ အညွှန်းကို ဆုံးဖြတ်ရန် မလိုအပ်ပါ။ အရာအားလုံးက အလိုအလျောက် ပြီးသွားလိမ့်မယ်။

>>> spisok = [10, 40, 20, 30]

spisok ရှိ element အတွက် >>>

… ပုံနှိပ်ခြင်း (ဒြပ်စင် + 2)

...

12

42

22

32

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

ကျွန်ုပ်တို့၏အခြေအနေတွင်၊ စာရင်းသည် နံပါတ် 10,40,20,30 ၏ sequence တစ်ခုဖြစ်သည်။ iteration တစ်ခုစီတွင်၊ ဆက်စပ်တန်ဖိုးသည် variable တွင်ပေါ်လာသည်။ ဥပမာအားဖြင့်၊ loop စတင်သည်နှင့်တပြိုင်နက် variable ကို ဓါတ် တန်ဖိုး 10 ကို သတ်မှတ်ပေးသည်။ နောက်တစ်ကြိမ် ထပ်ခါထပ်ခါတွင်၊ ဆယ်ခုသည် နံပါတ် 40 သို့ပြောင်းကာ တတိယအကြိမ်တွင် နံပါတ် 20 သို့ပြောင်းကာ နောက်ဆုံးတွင် ကွင်းပတ်၏နောက်ဆုံးအကြိမ်တွင် 30 ဖြစ်သွားသည်။

သံသရာ၏အဆုံးအတွက်အချက်ပြမှုသည်စာရင်းရှိဒြပ်စင်များ၏အဆုံးဖြစ်သည်။

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

>>> spisok = [1,2,3,4,5]

သို့မဟုတ် function ကိုသုံးပါ။ len(), စာရင်း၏အရှည်ကိုဆုံးဖြတ်ရန်။ ဒါပေမယ့် ဒီအခြေအနေမှာ loop ကိုသုံးတာက ပိုကောင်းပါတယ်။ စဉ်တွင်, ဘာလို့လဲဆိုတော့ variable ကိုသုံးစရာမလိုပါဘူး။

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

Loop နေစဉ်

သံသရာနှင့်မတူ ဘို့sequence ၏တန်ဖိုးများကို ရိုးရှင်းစွာ ထပ်တလဲလဲပြုလုပ်ပေးသော loop ၊ စဉ်တွင် ပိုအသုံးများတယ်။ ဤသံသရာအမျိုးအစား၏အမည်ကို "မရှိသေး" ဟုပြန်ဆိုသည်။ ဆိုလိုသည်မှာ “တိုင်အောင်” ဖြစ်သည်။

၎င်းသည် ပရိုဂရမ်းမင်းဘာသာစကားအားလုံးတွင် တွေ့ရသည့် universal loop တစ်ခုဖြစ်သည်။ အချို့သောနည်းလမ်းများတွင် ၎င်းသည် conditional operator နှင့်တူသည်။ ဟုတ်တယ်၊ အချို့သောအခြေအနေများနှင့်ကိုက်ညီမှုရှိမရှိစစ်ဆေးရန်စစ်ဆေးခြင်းလုပ်ဆောင်သည်။ အခြေအနေအရ အော်ပရေတာများနှင့် မတူဘဲ၊ စဉ်တွင် တစ်ကြိမ်တည်းမဟုတ်ဘဲ ထပ်ကာထပ်ကာတစ်ခုစီတွင် စစ်ဆေးမှုကို လုပ်ဆောင်သည်။ အခြေအနေသည် လွဲမှားနေပါက ကွင်းဆက်သည် ပြီးဆုံးသွားပြီး ၎င်းကို လိုက်နာသည့် command ကို လုပ်ဆောင်မည်ဖြစ်သည်။ ရိုးရိုးရှင်းရှင်းပြောရရင် သူအလုပ်လုပ်နေတဲ့ အခြေအနေက မမှန်တော့ဘူး။

သံသရာဆွဲရင်၊ စဉ်တွင် ရိုးရိုးရှင်းရှင်း၊ ဤကဲ့သို့သော အစီအစဉ်ကို အသုံးပြု၍ လုပ်ဆောင်သည်။

ပရိုဂရမ်၏ ပင်မအကိုင်းအခက် (ကွင်းဆက်ပြင်ပတွင်လည်ပတ်နေသော) ကို အပြာရောင်စတုဂံများဖြင့် ဤပုံတွင် ပုံဖော်ထားသည်။ Turquoise သည် သံသရာ၏ ခန္ဓာကိုယ်ကို ကိုယ်စားပြုသည်။ တစ်ဖန်၊ rhombus သည် တစ်ကြိမ်စီတိုင်းတွင် စစ်ဆေးထားသော အခြေအနေတစ်ခုဖြစ်သည်။

အစဉ်အဆက် စဉ်တွင် ခြွင်းချက်နှစ်ခု ဖြစ်ပေါ်လာနိုင်သည်-

1. အကယ်၍ loop ၏အစတွင် logical expression သည် true ပြန်မလာပါက၊ execution မလုပ်မီ ပြီးသွားပါက ၎င်းသည် စတင်မည်မဟုတ်ပါ။ ယေဘုယျအားဖြင့်၊ ဤအခြေအနေသည် ပုံမှန်ဖြစ်သည်၊ အကြောင်းမှာ အချို့သောအခြေအနေများတွင်၊ အပလီကေးရှင်းသည် loop body တွင် ဖော်ပြချက်များရှိနေခြင်းကို ပံ့ပိုးပေးမည်မဟုတ်သောကြောင့်ဖြစ်သည်။
2. စကားအသုံးအနှုန်းသည် အမြဲမှန်နေပါက၊ ၎င်းသည် loop တစ်ခုသို့ ဦးတည်သွားနိုင်သည်။ ဆိုလိုသည်မှာ သံသရာ၏ အဆုံးမရှိလှိမ့်ခြင်းဆီသို့။ ထို့ကြောင့်၊ ထိုကဲ့သို့သော ပရိုဂရမ်များတွင်၊ loop သို့မဟုတ် ပရိုဂရမ်မှ ထွက်ပေါက်ဖော်ပြချက် အမြဲရှိသင့်သည်။ သို့သော်လည်း ပရိုဂရမ်သည် အခြေအနေတစ်ခု၏ အမှန်တရား သို့မဟုတ် အတုအယောင်ကို ဆုံးဖြတ်နိုင်ခဲ့ပါက ဤအခြေအနေသည် ဖြစ်ပေါ်လာမည်ဖြစ်သည်။ ၎င်းကို လုပ်ဆောင်ရန် ပျက်ကွက်ပါက ပရိုဂရမ်ကို ရပ်စဲပြီးနောက် အမှားအယွင်းတစ်ခု ပြန်လာမည်ဖြစ်သည်။ သို့မဟုတ် သင်သည် error ကို ကိုင်တွယ်နိုင်ပြီး၊ ဖြစ်ပေါ်လာပါက၊ အချို့သော ကုဒ်များကို လုပ်ဆောင်လိမ့်မည်။

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

while Loop နမူနာများ

ဤကိစ္စတွင် error တစ်ခုကို ကိုင်တွယ်သည့် code ၏ ဥပမာတစ်ခုဖြစ်သည်။

n = input("ကိန်းပြည့်ထည့်ပါ-") 

type(n) != int: နေစဉ်

    ကြိုးစားပါ:

        n = int(n)

    ValueError မှအပ

        ပုံနှိပ်ခြင်း ("မှားယွင်းသော ဝင်ရောက်မှု!")

        n = input("ကိန်းပြည့်ထည့်ပါ-") 

အကယ်၍ n %2 == 0:

    ပုံနှိပ်ခြင်း ("တောင်")

အခြား:

    ပုံနှိပ်ခြင်း (“အဆန်း”)

ရှုပ်ထွေးသောကုဒ်တည်ဆောက်မှုများကိုကြေငြာရန် Python သည် ကော်လံများကိုအသုံးပြုကြောင်း မှတ်သားထားပါ။

အထက်ဖော်ပြပါ ကုဒ်တွင်၊ နံပါတ်သည် ကိန်းပြည့်ဟုတ်မဟုတ် စစ်ဆေးသင့်သည့် အခြေအနေတစ်ခုအဖြစ် သတ်မှတ်သည်။ ဟုတ်ရင် false ပြန်ပေးတယ်။ မဟုတ်ရင် အမှန်ပါပဲ။

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

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

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

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

ကုဒ်ခွဲခြမ်းစိတ်ဖြာခြင်း။

အခု ဒီကုဒ် ဘယ်လိုအလုပ်လုပ်သလဲဆိုတာကို အသေးစိတ်ကြည့်ရအောင်။ ဒါကိုလုပ်ဖို့၊ အဆင့်ဆင့်ခွဲခြမ်းစိတ်ဖြာမယ်။

1. ပထမဦးစွာ၊ အသုံးပြုသူသည် variable n မှလက်ခံသည့် string တစ်ခုသို့ဝင်ရောက်သည်။ 
2. ကြိုးဝိုင်းကို အသုံးပြုခြင်း။ စဉ်တွင် ဤကိန်းရှင်၏ အမျိုးအစားကို စစ်ဆေးထားသည်။ ပထမ ဝင်ခွင့်မှာ ညီမျှခြင်း မရှိပါ။ int. ထို့ကြောင့် စမ်းသပ်မှုရလဒ်အရ ဤအခြေအနေမှန်ကြောင်း တွေ့ရှိရပါသည်။ ထို့ကြောင့် loop body ထဲသို့ ဝင်သည်။
3. အော်ပရေတာတစ်ခု၏အကူအညီဖြင့် ကြိုးစား ကြိုးတစ်ချောင်းကို နံပါတ်တစ်ခုသို့ ပြောင်းရန် ကျွန်ုပ်တို့ ကြိုးစားနေပါသည်။ ပြီးသွားရင်တော့ Error မရှိပါဘူး။ ထို့ကြောင့် ၎င်းကို လုပ်ဆောင်ရန် မလိုအပ်ပါ။ ထို့ကြောင့်၊ စကားပြန်သည် စက်ဝိုင်း၏အစသို့ ပြန်သွားကာ စစ်ဆေးမှုရလဒ်များအရ ၎င်းသည် ကိန်းပြည့်ဖြစ်လာကြောင်း ထွက်ပေါ်လာသည်။ ဒါဆို အဆင့် 7 ကိုသွားရအောင်
4. ပြောင်းလဲခြင်း မအောင်မြင်ပါက ValueError ပေါ်လာပါမည်။ ဤကိစ္စတွင်၊ ပရိုဂရမ်စီးဆင်းမှုကို ကိုင်တွယ်သူမှလွဲ၍ အခြားအရာများသို့ ပေးပို့သည်။
5. အသုံးပြုသူသည် variable n ကိုသတ်မှတ်ပေးသောတန်ဖိုးအသစ်တစ်ခုဝင်ရောက်သည်။
6. စကားပြန်သည် အဆင့် 2 သို့ပြန်သွားပြီး ထပ်မံစစ်ဆေးသည်။ ၎င်းသည် ကိန်းပြည့်တန်ဖိုးဖြစ်ပါက အဆင့် 7 သို့သွားပါ။ မဟုတ်ပါက၊ အဆင့် 3 အရ ပြောင်းလဲခြင်းကို ထပ်မံကြိုးစားပါသည်။
7. အော်ပရေတာတစ်ခု၏အကူအညီဖြင့် if ဂဏန်းတစ်ခုကို 2 ဖြင့် ခွဲပြီးနောက် အကြွင်းရှိမရှိ ဆုံးဖြတ်သည်။ 
8. မဟုတ်ပါက “even” ဟူသော စာသားကို ပြန်ပေးသည်။
9. မဟုတ်ပါက “odd” ဟူသော စာသားကို ပြန်ပေးသည်။

ယခုဥပမာတစ်ခုကို သုံးသပ်ကြည့်ပါ။ ဤသံသရာကို မည်မျှ ဖြတ်သန်းမည်ကို ဆုံးဖြတ်ရန် ကြိုးစားပါ။

စုစုပေါင်း = 100 

ငါ = 0

ငါ <5:

    n = int(အဝင်())

    စုစုပေါင်း = စုစုပေါင်း — n

    i = i + 1 

ပုံနှိပ်ခြင်း(“ကျန်”၊ စုစုပေါင်း)

အဖြေမှန်သည် 5 ဖြစ်သည်။ အစပိုင်းတွင်၊ variable ၏တန်ဖိုး i - သုည။ စကားပြန်သည် ကိန်းရှင်သည် တူညီမှုရှိမရှိ စစ်ဆေးသည်။ i 4 သို့မဟုတ် ထို့ထက်နည်းသည်။ ဟုတ်တယ်ဆိုရင်တော့ တန်ဖိုးကို ပြန်ပေးတယ်။ စစ်မှန်တဲ့နှင့် loop ကို အလိုက်သင့် လုပ်ဆောင်သည်။ တန်ဖိုးက တစ်ခုပြီးတစ်ခု တိုးလာတယ်။

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

ဤတန်ဖိုးသည်လည်း ငါးခုထက်နည်းသည်။ ထို့နောက် loop ကို ကိန်းရှင်သို့ ပေါင်းထည့်ကာ တတိယအကြိမ် လုပ်ဆောင်သည်။ i 1 နှင့် တန်ဖိုး 3 ကို သတ်မှတ်ပေးထားသည်။ ၎င်းသည် ငါးထက်နည်းပြန်သည်။ ထို့ကြောင့် ၎င်းသည် variable ၏တန်ဖိုးဖြစ်သည့် loop ၏ ဆဌမမြောက်ထပ်သို့ ရောက်ရှိလာသည်။ i 5 နှင့် ညီမျှသည် (အားလုံးပြီးနောက်၊ ၎င်းသည် မူလ သုညဖြစ်သည်၊ ကျွန်ုပ်တို့မှတ်မိသလောက်)။ ထို့ကြောင့်၊ ဤအခြေအနေသည် စမ်းသပ်မှုမအောင်မြင်ဘဲ ကွင်းဆက်ကို အလိုအလျောက်ရပ်စဲပြီး ၎င်းအပြင်ဘက်ရှိ နောက်တစ်ဆင့်သို့ ကူးပြောင်းခြင်း (သို့မဟုတ် အောက်ပါအဆင့်များကို မပေးပါက ပရိုဂရမ်ရပ်စဲခြင်း) ကို ဆောင်ရွက်ပါသည်။

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

စုစုပေါင်း = 100 

စုစုပေါင်း > 0:

    n = int(အဝင်())

    စုစုပေါင်း = စုစုပေါင်း — n 

ပုံနှိပ်ခြင်း(“အရင်းအမြစ်ကုန်သွားပြီ”)

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

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