Chapter 1: ပထမခြေလှမ်းများ (First Steps)

Chapter 0 မှာ Python ကို install လုပ်ပြီး print("မင်္ဂလာပါ!") ကို run ကြည့်ပြီးပြီ။ အခု တကယ့် code စရေးပါပြီ။ ဒီအခန်းဟာ programming ရဲ့ အခြေခံအုတ်မြစ် ဖြစ်တယ် — ဒီမှာ သင်ရမယ့် print(), comment, variable, data type, operator ဆိုတဲ့ အကြောင်းအရာတွေဟာ နောက်အခန်းတိုင်းမှာ ပြန်ပေါ်လာမယ့် အရာတွေပါ။ ဒါကြောင့် ဒီအခန်းကို သေသေချာချာ လေ့ကျင့်သွားပါ။ အခန်းဆုံးရင် မုန့်ဆိုင်တစ်ဆိုင်ရဲ့ ဘေလ်တွက်တဲ့ program လေးတောင် ကိုယ်တိုင် ရေးနိုင်နေပါလိမ့်မယ်။

print() — ကွန်ပျူတာကို စကားပြောခိုင်းခြင်း

print() ဆိုတာ Python ရဲ့ အခြေခံအကျဆုံး အမိန့်ပါ။ ကွင်းစကွင်းပိတ်ထဲက အရာကို screen ပေါ်မှာ ထုတ်ပြပေးတယ်။ ဂဏန်းလည်း ရတယ်၊ စာသားလည်း ရတယ်။

print(100)
print(3.5)
print("မင်္ဂလာပါ")

Output:

100
3.5
မင်္ဂလာပါ

သတိထားရမှာက စာသား (text) ကို ပြချင်ရင် quote ထဲမှာ ထည့်ရတယ် — " " (double quote) ဖြစ်ဖြစ် ' ' (single quote) ဖြစ်ဖြစ် ရတယ်။ ဂဏန်းကျတော့ quote မလိုဘူး။ print("100") နဲ့ print(100) က မတူဘူး — ပထမတစ်ခုက စာသား "100"၊ ဒုတိယတစ်ခုက ဂဏန်း 100။ အခု အဲဒီကွာခြားချက်က အရေးမကြီးသေးပေမယ့် နောက်ပိုင်း data type အကြောင်း သင်တဲ့အခါ အရေးပါလာပါလိမ့်မယ်။

print() ထဲမှာ အရာများစွာကို ကော်မာနဲ့ ခြားပြီး ထည့်လို့လည်း ရတယ်။ အဲဒီအခါ Python က သူတို့ကြားမှာ space တစ်ချက်စီ ခြားပြီး ထုတ်ပေးတယ်။

print("ကျွန်တော့်အသက်", 25, "နှစ်ပါ")

Output:

ကျွန်တော့်အသက် 25 နှစ်ပါ

ဒီအချက်က နောက်ပိုင်း variable တွေရဲ့ တန်ဖိုးကို စာသားနဲ့ တွဲပြချင်တဲ့အခါ အရမ်းအသုံးဝင်ပါတယ်။

Comment (#) — ကွန်ပျူတာ လျစ်လျူရှုတဲ့ မှတ်စုများ

Code ရေးတဲ့အခါ ကိုယ့်ကိုယ်ကို (သို့မဟုတ် တခြားဖတ်မယ့်သူကို) ရှင်းပြဖို့ မှတ်စုထားချင်တဲ့အခါရှိတယ်။ အဲဒါကို comment လို့ ခေါ်တယ်။ # သင်္ကေတ နောက်က စာသားမှန်သမျှကို ကွန်ပျူတာက လုံးဝ လျစ်လျူရှုတယ် — လူဖတ်ဖို့သက်သက်ပါ။

# ဒါက comment ပါ — ကွန်ပျူတာက ဒီစာကြောင်းကို ကျော်သွားတယ်
print(500)  # ဒီလိုမျိုး စာကြောင်းအဆုံးမှာလည်း မှတ်စုရေးလို့ရတယ်

# print(999)  # # ခံထားတဲ့ code က အလုပ်မလုပ်ဘူး — ယာယီပိတ်ထားချင်ရင် ဒီနည်းသုံး
print(100)

Output:

500
100

မြင်တဲ့အတိုင်းပဲ — 999 ထုတ်တဲ့ စာကြောင်းက # ခံထားလို့ အလုပ်မလုပ်ဘူး။ Comment ကို အသုံးများတဲ့ နေရာနှစ်ခုရှိတယ်။ တစ်ခုက ရှင်းလင်းချက် ပေးဖို့ (ဒီ code က ဘာလုပ်တာလဲဆိုတာ)၊ နောက်တစ်ခုက ယာယီ ပိတ်ထားဖို့ (မဖျက်ချင်သေးတဲ့ code ကို ခဏ အလုပ်မလုပ်စေချင်တဲ့အခါ)။

Variable — နာမည်ပေးထားတဲ့ သိုလှောင်ခန်း

Program တွေဟာ အချက်အလက် (data) တွေနဲ့ အလုပ်လုပ်ရတယ် — စျေးနှုန်းတွေ၊ နာမည်တွေ၊ အရေအတွက်တွေ။ ဒီ data တွေကို ခဏသိမ်းထားဖို့ memory ထဲမှာ နေရာတစ်ခု လိုတယ်။ အဲဒီနေရာကို နာမည်ပေးထားတာကိုပဲ variable လို့ ခေါ်တယ်။

အလွယ်မှတ်ရအောင် variable ကို အရုပ်ထည့်တဲ့ ဗူး လို့ သဘောထားပါ။ ဗူးပေါ်မှာ နာမည် (ဥပမာ num) ကပ်ထားတယ်။ အထဲမှာ အရုပ် (တန်ဖိုး၊ ဥပမာ 10) ထည့်ထားတယ်။ အရုပ်ကို အချိန်မရွေး လဲလို့ရတယ် — ဗူးနာမည်ကတော့ အတူတူပဲ။

snack_price = 800
print(snack_price)

shop_name = "ရွှေမုန့်ဆိုင်"
print(shop_name)

Output:

800
ရွှေမုန့်ဆိုင်

= သင်္ကေတကို သတိထားပါ။ သင်္ချာမှာ = က "ညီမျှတယ်" လို့ အဓိပ္ပာယ်ရပေမယ့်၊ programming မှာတော့ "ညာဘက်က တန်ဖိုးကို ဘယ်ဘက်က variable ထဲ ထည့်" လို့ အဓိပ္ပာယ်ရတယ်။ snack_price = 800 ဆိုတာ "snack_price ဆိုတဲ့ ဗူးထဲကို 800 ထည့်" လို့ ဖတ်ပါ။

Variable ရဲ့ တန်ဖိုးကို နောက်မှ ပြောင်းလို့ရတယ် — အသစ်ပေးလိုက်တဲ့ တန်ဖိုးက အဟောင်းကို အစားထိုးသွားတယ်။

score = 50
print(score)

score = 85
print(score)

Output:

50
85

ပထမ print မှာ 50 ထွက်ပြီး၊ ဒုတိယ print မှာ 85 ပဲ ထွက်တယ် — နောက်ဆုံးပေးထားတဲ့ တန်ဖိုးသာ ကျန်တာပါ။ ဒီသဘောကို နားလည်ထားတာ အရေးကြီးတယ်၊ နောက်ပိုင်း loop တွေမှာ variable တန်ဖိုး တစ်ဖြည်းဖြည်း ပြောင်းသွားတာကို တွေ့ရမှာမို့လို့ပါ။

↻ ပြန်ဖွင့်ရန်

Variable နာမည်ပေးတဲ့ စည်းကမ်းများ

Variable နာမည်ကို ကြိုက်သလို ပေးလို့ရပေမယ့် စည်းကမ်းလေးတွေ ရှိတယ်။

၁။ အက္ခရာ (သို့မဟုတ် underscore _) နဲ့ စရမယ်။ ဂဏန်းနဲ့ မစရဘူး။

shop_name = "ရွှေမုန့်ဆိုင်"   # မှန်တယ်
_shop = "ရွှေမုန့်ဆိုင်"        # မှန်တယ် — underscore နဲ့ စလို့ရတယ်
total2 = 100                  # မှန်တယ် — နောက်မှာ ဂဏန်းပါလို့ရတယ်
# 2shop = "ရွှေမုန့်ဆိုင်"      # မှားတယ် — ဂဏန်းနဲ့ စလို့မရဘူး (SyntaxError တက်မယ်)

၂။ နာမည်ထဲမှာ space၊ hyphen (-) စတဲ့ သင်္ကေတတွေ မပါရဘူး။ စကားလုံးနှစ်လုံး ဆက်ချင်ရင် underscore (_) သုံးပါ။

daily_sales = 135000   # မှန်တယ်
# daily-sales = 135000  # မှားတယ် — hyphen ကို အနုတ်လက္ခဏာလို့ ထင်သွားမယ်

၃။ Python ရဲ့ keyword တွေ (သီးသန့်စကားလုံးတွေ) ကို နာမည်အဖြစ် သုံးလို့မရဘူး။ ဥပမာ if, for, class တို့ဟာ Python ရဲ့ ကိုယ်ပိုင်စကားလုံးတွေမို့ variable နာမည်အဖြစ် ပေးလို့မရဘူး။

၄။ အကြီးအသေး ခွဲခြားတယ် (case-sensitive)။ Score, score, SCORE ဆိုတာ variable သုံးခုကွဲပြားပါတယ်။ ဒါကြောင့် နာမည်ပေးပြီးရင် အတိအကျ ပြန်သုံးပါ။

Data Type များ — အချက်အလက်ရဲ့ အမျိုးအစားများ

Variable ဗူးထဲ ထည့်တဲ့ "အရုပ်" တွေမှာ အမျိုးအစားတွေ ရှိတယ်။ ဂဏန်းလား၊ စာသားလား၊ အမှန်/အမှားလား — ဒါကို data type လို့ ခေါ်တယ်။ Python မှာ အခြေခံ data type ၅ မျိုး ရှိတယ်။

int — ကိန်းပြည့် (integer)။ ... -2, -1, 0, 1, 2 ...

apple_count = 12
temperature = -5

float — ဒသမ (floating-point) ပါတဲ့ ဂဏန်း။

apple_price = 12.5
pi_value = 3.14159

complex — သင်္ချာရဲ့ complex number (j ကို သုံးတယ်)။ သိပ္ပံ၊ အင်ဂျင်နီယာတွက်ချက်မှုတွေမှာ သုံးတယ်။

signal_a = 4 + 3j
signal_b = 1 + 2j
print(signal_a + signal_b)
print(signal_a - signal_b)

Output:

(5+5j)
(3+1j)

str — စာသား (string)။ စာလုံးတွေ ဆက်ထားတာ။ quote ထဲမှာ ထည့်ရတယ်။

customer_name = "Aung Khant"

bool — Boolean။ တန်ဖိုးနှစ်မျိုးပဲ ရှိတယ် — True (အမှန်) သို့မဟုတ် False (အမှား)။ နောက်အခန်းတွေမှာ ဆုံးဖြတ်ချက်ချတဲ့နေရာတွေမှာ အဓိက သုံးရမှာပါ။ T နဲ့ F ကို အကြီးနဲ့ ရေးရတယ်ဆိုတာ သတိထားပါ။

shop_open = True
sold_out = False

Variable တစ်ခုရဲ့ data type ကို သိချင်ရင် type() ဆိုတဲ့ function နဲ့ စစ်လို့ရတယ်။

apple = 12
price = 12.5
signal = 3 + 2j
name = "Aung Khant"
is_open = True

print(type(apple))
print(type(price))
print(type(signal))
print(type(name))
print(type(is_open))

Output:

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bool'>

<class 'int'> ဆိုတာ "ဒါက int အမျိုးအစားဝင်တယ်" လို့ ပြောတာပါ။ အစပိုင်းမှာ ဒီပုံစံက ထူးဆန်းနေလိမ့်မယ် — int, float စတဲ့ စာသားလေးကိုပဲ ကြည့်ပါ။

Arithmetic Operator များ — တွက်ချက်တဲ့ သင်္ကေတများ

Operator ဆိုတာ တွက်ချက်မှုလုပ်တဲ့ သင်္ကေတပါ။ Python ရဲ့ အခြေခံ arithmetic operator ၇ ခု ရှိတယ်။ မုန့်ဆိုင်ဥပမာလေးနဲ့ တစ်ခုချင်း ကြည့်ရအောင်။

tea_price = 800
cake_price = 1200

bill = tea_price + cake_price   # + ပေါင်းခြင်း
print(bill)                     # 2000

change = 5000 - bill            # - နုတ်ခြင်း
print(change)                   # 3000

dozen_price = tea_price * 12    # * မြှောက်ခြင်း
print(dozen_price)              # 9600

per_person = bill / 2           # / စားခြင်း — အဖြေက အမြဲ float
print(per_person)               # 1000.0

leftover = 10 % 3               # % ကြွင်း (modulo) — စားပြီး ကျန်တာ
print(leftover)                 # 1

full_boxes = 10 // 3            # // ကိန်းပြည့်စားခြင်း (floor division)
print(full_boxes)               # 3

power = 2 ** 5                  # ** ထပ်ကိန်း (exponent)
print(power)                    # 32

% (modulo) နဲ့ // (floor division) က အစပြုသူအတွက် အသစ်ဖြစ်လိမ့်မယ်။ လက်တွေ့မြင်အောင် ပြောရရင် — မုန့် 10 ခုကို တစ်ဗူး 3 ခုနှုန်း ထည့်မယ်ဆို၊ 10 // 3 = ဗူး 3 ဗူး အပြည့်ရမယ်၊ 10 % 3 = 1 ခု ပိုလျှံမယ်။ ဒီနှစ်ခုက နောက်ပိုင်း "စုံ/မ" စစ်တာ၊ အချိန်ပြောင်းတာတွေမှာ ခဏခဏ သုံးရမှာပါ။

ဘယ် operator ကို အရင်တွက်မလဲ (Operator Precedence)

Expression တစ်ခုမှာ operator အများကြီး ပါလာရင် Python က စည်းကမ်းအတိုင်း အစဉ်လိုက် တွက်တယ်။ အရေးကြီးဆုံး အဆင့် ၄ ဆင့် —

1. () — ကွင်းစကွင်းပိတ်ထဲက အရင်ဆုံး တွက်
2. ** — ထပ်ကိန်း (ညာဘက်ကနေ ဘယ်ဘက်ကို တွက်တယ်)
3. * / // % — မြှောက်၊ စား (ဘယ်ဘက်ကနေ ညာဘက်ကို)
4. + - — ပေါင်း၊ နုတ် (ဘယ်ဘက်ကနေ ညာဘက်ကို)

bill = 500 + 3 * 800
print(bill)   # 2900 — အမြှောက်အရင်တွက် (3*800=2400)၊ ပြီးမှ ပေါင်း

3 * 800 ကို အရင်တွက်လို့ အဖြေက 2900 ပါ။ ကွင်းစကွင်းပိတ်ထည့်လိုက်ရင် အစဉ်ပြောင်းသွားတယ်။

wrong_way = (500 + 3) * 800
print(wrong_way)   # 402400 — ကွင်းထဲက (500+3) ကို အရင်တွက်

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

↻ ပြန်ဖွင့်ရန်

Expression — တန်ဖိုးထွက်တဲ့ အသုံးအနှုန်း

Variable တွေ၊ တန်ဖိုးတွေ၊ operator တွေ ရောထားတဲ့ အရာကို expression လို့ ခေါ်တယ်။ Expression တိုင်းမှာ အဖြေ (တန်ဖိုး) တစ်ခု ထွက်တယ်။

price = 1200
qty = 5
discount = 500

total = price * qty - discount   # ဒါက expression တစ်ခု
print(total)                     # 5500

price * qty - discount ဆိုတဲ့ expression ကို Python က အဆင့်ဆင့် တွက်တယ် — 1200 * 5 = 6000၊ ပြီးမှ 6000 - 500 = 5500။ ပြီးတော့ အဖြေကို total ဆိုတဲ့ variable ထဲ ထည့်တယ်။ x = 5 + 2 * 3 လိုမျိုး ရိုးရိုးလေးကအစ၊ ရှည်လျားတဲ့ တွက်ချက်မှုအထိ — အဖြေထွက်တဲ့ အရာမှန်သမျှ expression ပါပဲ။

Compound Assignment — အတိုကောက် တွက်နည်း

Variable တစ်ခုရဲ့ တန်ဖိုးကို သူ့ကိုယ်သူနဲ့ပဲ ပေါင်း/နုတ်/မြှောက်/စား လုပ်ရတဲ့ အခြေအနေက ခဏခဏ ကြုံရတယ်။ ဥပမာ တစ်နေ့တာ ရောင်းရငွေကို စုစုပေါင်းထည့်သွားတာမျိုး။

daily_sales = 0

morning = 45000
daily_sales = daily_sales + morning   # ရှည်တဲ့နည်း
print(daily_sales)                    # 45000

afternoon = 38000
daily_sales += afternoon              # အတိုကောက် — အဓိပ္ပာယ်အတူတူပဲ
print(daily_sales)                    # 83000

shop_fee = 10000
daily_sales -= shop_fee               # ဆိုင်ခ နုတ်
print(daily_sales)                    # 73000

daily_sales += afternoon ဆိုတာ daily_sales = daily_sales + afternoon ရဲ့ အတိုကောက်ပါ။ ဒါကို compound assignment operator လို့ ခေါ်တယ်။ လေးမျိုးရှိတယ် —

• += — ပေါင်းထည့် (a += b ဆိုတာ a = a + b)
• -= — နုတ်ယူ (a -= b ဆိုတာ a = a - b)
• *= — မြှောက်ထည့် (a *= b ဆိုတာ a = a * b)
• /= — စားထည့် (a /= b ဆိုတာ a = a / b)

stock = 10
stock *= 2    # 20 — ပစ္စည်း နှစ်ဆရောက်လာတယ်
stock /= 4    # 5.0 — လေးပုံတစ်ပုံ ရောင်းထွက်သွားတယ်
print(stock)

Output:

5.0

stock /= 4 ရဲ့ အဖြေက 5.0 (float) ဖြစ်တာ သတိထားမိမှာပါ — / က အမြဲ float ထုတ်တယ်ဆိုတဲ့ စည်းကမ်းအတိုင်းပါပဲ။

စာကြောင်းရှည် Statement တွေ ရေးနည်း

Code တစ်ကြောင်းက အရမ်းရှည်လာတဲ့အခါ ဖတ်ရခက်တယ်။ Python မှာ statement တစ်ခုကို စာကြောင်းများစွာ ခွဲရေးလို့ရတယ်။ နည်းနှစ်မျိုးရှိတယ်။

**နည်း ၁ — Backslash (\) နဲ့ ဆက်ရေးနည်း။** စာကြောင်းအဆုံးမှာ \ ခံထားရင် "နောက်စာကြောင်းနဲ့ ဆက်ထားတယ်" လို့ ဆိုလိုတယ်။

total = 1200 + 800 + 1500 + \
        2000 + 500
print(total)   # 6000

နည်း ၂ — ကွင်းစကွင်းပိတ် (()) နဲ့ ဆက်ရေးနည်း။ ကွင်းထဲက အရာတွေက စာကြောင်းခွဲရေးလို့ရတယ် — \ ထက် ပိုသန့်ရှင်းပြီး အမှားနည်းတယ်။

total = (1200 + 800 + 1500
         + 2000 + 500)
print(total)   # 6000

ဒီနည်းက programmer တွေ ပိုကြိုက်တဲ့ နည်းပါ — \ လို နောက်ဆုံးအက္ခရာအကြောင်း စိတ်ပူစရာ မလိုဘူးလေ။

တစ်ကြောင်းတည်းမှာ statement အများကြီး — Semicolon (;)

ပြောင်းပြန်အနေနဲ့၊ statement အသေးလေးတွေကို တစ်ကြောင်းတည်းမှာ ; နဲ့ ခြားပြီး ရေးလို့လည်း ရတယ်။

tea = 800; cake = 1200; total = tea + cake
print(total)   # 2000

အလုပ်လုပ်ပါတယ်။ ဒါပေမယ့် —

ဒီအခန်းရဲ့ အနှစ်ချုပ်

• print() — screen ပေါ် ထုတ်ပြဖို့။ စာသားကို quote ထဲထည့်၊ ဂဏန်းကို တိုက်ရိုက်ရေး။
• Comment — # နောက်က စာသားကို ကွန်ပျူတာ လျစ်လျူရှုတယ်။ ရှင်းလင်းချက်ပေးဖို့နဲ့ code ယာယီပိတ်ဖို့ သုံး။
• Variable — နာမည်ပေးထားတဲ့ memory နေရာ။ = က "ညာဘက်က တန်ဖိုးကို ဘယ်ဘက်ထဲထည့်"။ တန်ဖိုးကို နောက်မှ ပြောင်းလို့ရတယ်၊ နောက်ဆုံးတန်ဖိုးသာ ကျန်တယ်။
• နာမည်ပေးစည်းကမ်း — အက္ခရာ/_ နဲ့စ၊ space/hyphen မရ၊ keyword မရ၊ အကြီးအသေး ခွဲခြားတယ်။ snake_case သုံးပါ။
• Data type — int (ကိန်းပြည့်), float (ဒသမ), complex (j ပါတဲ့), str (စာသား), bool (True/False)။ type() နဲ့ စစ်လို့ရတယ်။
• Operator — + - * / % // **။ / က အမြဲ float ထုတ်တယ်။ % က ကြွင်း၊ // က ကိန်းပြည့်စား၊ ** က ထပ်ကိန်း။
• Precedence — () → ** → * / // % → + -။ မသေချာရင် ကွင်းထည့်။
• Compound assignment — += -= *= /= တွေက a = a + b တို့ရဲ့ အတိုကောက်။
• Statement ရှည်ရင် \ (နောက်ဆုံးအက္ခရာ ဖြစ်ရမယ်) သို့မဟုတ် () နဲ့ စာကြောင်းခွဲရေး။ ; နဲ့ တစ်ကြောင်းတည်း အများကြီး ရေးလို့ရပေမယ့် မသုံးတာ ပိုကောင်းတယ်။

လေ့ကျင့်ခန်းများ

1. (အခြေခံ) ကိုယ့်အကြိုက်ဆုံး အစားအစာတစ်ခုရဲ့ အမည်၊ တစ်ခုချင်းစျေးနှုန်းနဲ့ ဝယ်ယူမယ့် အရေအတွက်ကို variable သုံးခုထဲမှာ ထည့်ပါ။ ပြီးရင် စုစုပေါင်း ကျသင့်ငွေကို print() နဲ့ ထုတ်ပြပါ။ (ဥပမာ — မုန့်ဟင်းခါး တစ်ပွဲ 1500၊ ၄ ပွဲဆို စုစုပေါင်း 6000)
2. (အလယ်အလတ်) စုစုပေါင်း 200 မိနစ် ရှိတယ်။ ဒါကို နာရီနဲ့ ကျန်တဲ့မိနစ် အဖြစ် ပြောင်းပြပါ။ (// နဲ့ % ကို သုံးပါ။ အဖြေ: 3 နာရီ 20 မိနစ်)
3. (အလယ်အလတ်) အောက်ပါ expression တွေရဲ့ အဖြေကို အရင်ဆုံး စာရွက်ပေါ်မှာ ကိုယ်တိုင်တွက်ကြည့်ပါ။ ပြီးမှ Python မှာ run ပြီး တိုက်စစ်ပါ။
   • 8 + 4 * 2 ** 2 - 10 / 5 (အဖြေ: 22.0)
   • (7 + 3) % 4 * 2 (အဖြေ: 4)
4. (အဆင့်မြင့်) မုန့်ဆိုင်တစ်ဆိုင်ရဲ့ တစ်နေ့တာ ရောင်းရငွေ — မနက် 45000၊ နေ့လယ် 38000၊ ညနေ 52000။ daily_sales ဆိုတဲ့ variable တစ်ခုတည်းနဲ့ += သုံးပြီး စုစုပေါင်း တွက်ပါ။ ပြီးရင် ဆိုင်ခ 10000 ကို -= နဲ့ နုတ်ပြီး အသားတင် ဝင်ငွေကို ထုတ်ပြပါ။ (အဖြေ: စုစုပေါင်း 135000၊ အသားတင် 125000)
5. (အဆင့်မြင့်) years = 5 ဆိုတဲ့ variable ထဲမှာ နှစ်အရေအတွက် ထည့်ထားတယ်။ ရက်ပေါင်း ဘယ်လောက်ရှိလဲ တွက်ပြပါ။ (တစ်နှစ်ကို 365 ရက်နှုန်း၊ leap year ထည့်မတွက်ပါနဲ့။ အဖြေ: 1825 ရက်)