← Back to Home

Functions

Introduction

Function ဆိုတာ? လွယ်လွယ်ပြောရရင်၊ Function ဆိုတာ အလုပ်တစ်ခုကို လုပ်ပေးမယ့် code ပေါင်းချုပ်ကြီး။

ဥပမာ bro က code တွေရေးရင်း နဲ့ နေရာ ၅ နေရာလောက်မှာ code အလုပ်လုပ်တဲ့ သဘောတရား တူတာကို ထပ်ခါထပ်ခါ ရေးနေရတယ် ဆိုပါစို့။ (ဥပမာ user ကို နှုတ်ဆက်တာမျိုး)။ အဲ့ဒါက ပင်ပန်းတယ်လေ၊ ဟုတ်တယ်မလား။

အဲ့ဒီ ထပ်ခါထပ်ခါ ရေးနေရတဲ့ code တွေကို Function တစ်ခုအနေနဲ့ ရေးလိုက်ပြီး၊ လိုတဲ့နေရာမှာ အဲ့ Function ကို လှမ်းခေါ်လိုက်ရုံပဲ။

Why Functions?

ဒါက ပြောရရင် DRY (Don't Repeat Yourself) ပေါ့။

DRY Principle: Don't Repeat Yourself - တူညီတဲ့ code ကို ထပ်ခါထပ်ခါ မရေးနဲ့။ Function တစ်ခု ဆောက်ပြီး ပြန်သုံးပါ ဆိုတာမျိုး။

Function မသုံးရင် ဘာဖြစ်မလဲ?

without_function.py
# Function မသုံးဘဲ ထပ်ခါထပ်ခါ ရေးနေရတယ် print("Xello မင်းထက်သာ!") print("Python လေ့လာရတာ လွယ်တယ်ဟုတ်။") print("Xello မောင်စိုင်း!") print("Python လေ့လာရတာ လွယ်တယ်ဟုတ်။") print("Xello ပိုင်တွန်!") print("Python လေ့လာရတာ လွယ်တယ်ဟုတ်။") # ရှုပ်တယ်လေ! ပြင်ချင်ရင် နေရာ ၃ နေရာ ပြင်ရမယ်!

Function သုံးရင် ဘာကောင်းကျိုးပေးမှာလဲ?

with_function.py
# Function ဆောက်လိုက်မယ် def greet_student(name): print(f"Xello {name}!") print("Python လေ့လာရတာ လွယ်တယ်ဟုတ်။") # အခု ခေါ်သုံးရုံပဲ - ရှင်းတယ်! greet_student("မင်းထက်သာ") greet_student("မောင်စိုင်း") greet_student("ပိုင်တွန်") # ပြင်ချင်ရင် Function တစ်နေရာတည်းကိုပဲ ပြင်လိုက်ရုံပဲ!

Functions ရဲ့ အားသာချက်တွေ:

  • Code Reusability: တစ်ခါ ရေး၊ အကြိမ်ကြိမ် သုံး
  • Easy Maintenance: ပြင်ချင်ရင် တစ်နေရာတည်းကိုပဲ ပြင်
  • Better Organization: Code တွေကပိုပြီး စနစ်တကျ ဖြစ်လာစေတယ်
  • Easier Testing: Function တစ်ခုချင်းစီကို သီးခြား test လုပ်လို့ရတယ်

Function ကို ဘယ်လို ဆောက်မလဲ?

Function တစ်ခု ဆောက်တာကို Defining လုပ်တယ်လို့ ခေါ်တယ်။ Python မှာ def ဆိုတဲ့ keyword နဲ့ စရတယ်။

Function Definition Syntax:

Function Syntax
def function_name(): # Code ကို ဒီမှာ ရေးမယ် # Indent အတွင်းဘက် ရွှေ့ရမယ်နော် pass
  • def - define (သတ်မှတ်တယ်) ကို ပြောတာ
  • function_name - ကိုယ်ကြိုက်တဲ့ Function နာမည်
  • () - ကွင်းစ ကွင်းပိတ် (Parameters ထည့်ဖို့)
  • : - colon (အစက်နှစ်စက်) နဲ့ ပိတ်
  • Indented code - Function ရဲ့ body (အတွင်းပိုင်း code)
CRITICAL: Indentation Enter ခေါက်လိုက်ရင်၊ အောက်တစ်ကြောင်းမှာ indent (အတွင်းဘက် နည်းနည်းရွှေ့) ပြီးမှ အဲ့ function က လုပ်ရမယ့် code တွေကို ရေးရမယ်။ Python မှာ indentation က syntax ရဲ့ အစိတ်အပိုင်းပဲ။

ရိုးရှင်းဆုံး Function:

simple_function.py
# Function ကို သတ်မှတ်မယ် def greet_bro(): print("ဟေ့ bro! မင်းစကီ နေကောင်းလား?") print("Python က လွယ်တယ်နော်။")

ဒါပဲ။ bro အခု function တစ်ခု ဆောက်ပြီးသွားပြီ။

Function ကို ဘယ်လို ခေါ်သုံးမလဲ?

အပေါ်ကလို ရေးလိုက်ရုံနဲ့ သူက အလုပ်မလုပ်သေးဘူး။ ဒါက ကျနော် ဒီလို လုပ်တတ်တယ် လို့ စက်ရုပ်ကို သင်ပေးထားတာပဲ ရှိသေးတယ်။

တကယ် လုပ်ခိုင်းချင်ရင်၊ သူ့နာမည်ကို ခေါ်ရမယ်။

Calling a Function:

calling_function.py
# Function ကို သတ်မှတ်မယ် def greet_bro(): print("ဟေ့ bro! နေကောင်းလား?") print("Python က လွယ်တယ်နော်။") # Function ကို ခေါ် (Calling the function) greet_bro() greet_bro()

Output:

Output
ဟေ့ bro! နေကောင်းလား? Python က လွယ်တယ်နော်။ ဟေ့ bro! နေကောင်းလား? Python က လွယ်တယ်နော်။

အပေါ်ကလို greet_bro() လို့ နှစ်ခါခေါ်ရင်၊ စာသားတွေ နှစ်ခါ ထွက်လာလိမ့်မယ်။ အဲ့ဒါပဲ! ထပ်ခါထပ်ခါ ပြန်ရေးစရာ မလိုတော့ဘူး။

သတိပေးချင်တာ: Function ခေါ်တဲ့အခါ () ကွင်း မပါရင် Error မတက်ဘူး၊ ဒါပေမယ့် Function မ run ဘူး။

Parameters & Arguments

ကဲ၊ နည်းနည်း level တက်ကြမယ်။

ခုနက function က bro လို့ပဲ အမြဲ နှုတ်ဆက်နေတယ်။ ကျနော်က မင်းထက်သာ ကို နှုတ်ဆက်ချင်ရင်ရော? စကီ ကို နှုတ်ဆက်ချင်ရင်ကော?

အဲ့ဒီ မင်းထက်သာ တို့ စကီ တို့ဆိုတဲ့ data ကို function ထဲ ထည့်ပေးလို့ရတယ်။

Parameters vs Arguments - ကွာခြားချက်:

Parameters vs Arguments:
  • Parameter: Function ဆောက်တုန်းက () ထဲမှာ ထည့်ထားတဲ့ variable
  • Argument: Function ခေါ်တဲ့အခါ () ထဲမှာ ထည့်ပေးတဲ့ တကယ့် value
parameters_vs_arguments.py
# name က Parameter (ဒီမှာ သတ်မှတ်တယ်) def greet_person(name): print(f"Xello {name}! What's up?။") # မင်းထက်သာ က Argument (ဒီမှာ ထည့်ပေးတယ်) greet_person("မင်းထက်သာ") greet_person("စကီ")

Output:

Output
Xello မင်းထက်သာ! What's up?။ Xello စကီ! What's up?။

မင်းထက်သာ ဆိုတဲ့ တန်ဖိုးက name ဆိုတဲ့ Parameter ထဲကို ဝင်သွားတာ။

Multiple Parameters

Function တစ်ခုမှာ Parameter တစ်ခုထက် ပိုထည့်လို့ရတယ်။

Two Parameters:

two_parameters.py
def add_numbers(num1, num2): total = num1 + num2 print(f"{num1} + {num2} = {total}") add_numbers(5, 3) add_numbers(10, 20)

Output:

Output
5 + 3 = 8 10 + 20 = 30

Three Parameters:

three_parameters.py
def introduce(name, age, city): print(f"ကျနော် {name} ပါ။") print(f"အသက် {age} နှစ် ရှိပြီ။") print(f"{city} မှာ နေပါတယ်။") introduce("မင်းထက်သာ", 25, "Yangon")

Output:

Output
ကျနော် မင်းထက်သာ ပါ။ အသက် 25 နှစ် ရှိပြီ။ Yangon မှာ နေပါတယ်။

Four Parameters:

four_parameters.py
def calculate_rectangle(length, width, unit, color): area = length * width print(f"{color} အရောင် စတုဂံ") print(f"အရှည်: {length} {unit}") print(f"အနံ: {width} {unit}") print(f"ဧရိယာ: {area} {unit}²") calculate_rectangle(10, 5, "cm", "အနီ")

Output:

Output
အနီ အရောင် စတုဂံ အရှည်: 10 cm အနံ: 5 cm ဧရိယာ: 50 cm²

Default Parameters

Parameter တွေကို default value ပေးလို့ရတယ်။ Function ခေါ်တဲ့အခါ argument မပေးရင် default value ကို သုံးမယ်ပေါ့။

default_parameters.py
def greet(name="User", greeting="Xello"): print(f"{greeting} {name}!") # Arguments မပေးဘဲ ခေါ်ရင် default values သုံးမယ် greet() # name ပဲ ပေးမယ် greet("မင်းထက်သာ") # နှစ်ခုလုံး ပေးမယ် greet("မောင်စိုင်း", "ဟိုင်း")

Output:

Output
Xello User! Xello မင်းထက်သာ! ဟိုင်း မောင်စိုင်း!

သတိနော်: Default parameter တွေက non-default parameter တွေရဲ့ နောက်မှာ ရှိရမယ်။

Return Statement

နောက်တစ်ဆင့်။ ခုနက function တွေက print ပဲ လုပ်တယ်။ သူတို့က အလုပ်ပဲ လုပ်ပြီး ဘာ တန်ဖိုးမှ ပြန်မပေးဘူး။

တကယ်လို့ function ကို တွက်ချက်မှုတစ်ခုခု (ဥပမာ ဂဏန်းနှစ်လုံး ပေါင်းခိုင်းတာ) လုပ်ခိုင်းပြီး အဲ့ အဖြေကို ပြန်လိုချင်ရင် return ဆိုတာကို သုံးရတယ်။

Basic Return:

basic_return.py
# ဒီ function က ဂဏန်းနှစ်လုံးကို ပေါင်းပြီး အဖြေကို ပြန်ပေး (return) မယ် def add_numbers(num1, num2): total = num1 + num2 return total # ခေါ်သုံးတဲ့အခါ၊ သူ return ပြန်ပေးတဲ့ တန်ဖိုးကို variable ထဲ သိမ်းလို့ရတယ် answer = add_numbers(5, 3) print(f"အဖြေက: {answer}") # ဒီလို တိုက်ရိုက်ခေါ်သုံးလို့လည်း ရတယ် print(f"10 နဲ့ 20 ပေါင်းတော့: {add_numbers(10, 20)}")

Output:

Output
အဖြေက: 8 10 နဲ့ 20 ပေါင်းတော့: 30
CRITICAL: Code after return won't execute! return ရဲ့ နောက်မှာ ဘာ code မှ ဆက်မရေးနဲ့၊ သူက function ကို အဲ့မှာတင် ရပ်ပစ်လိုက်တာ။

Return Multiple Values (Tuple Unpacking):

return_multiple.py
def calculate(a, b): sum_result = a + b diff_result = a - b mult_result = a * b return sum_result, diff_result, mult_result # Tuple အနေနဲ့ ပြန်ပေးတယ် # Tuple unpacking နဲ့ လက်ခံမယ် sum_val, diff_val, mult_val = calculate(10, 3) print(f"ပေါင်း: {sum_val}") print(f"နုတ်: {diff_val}") print(f"မြှောက်: {mult_val}")

Output:

Output
ပေါင်း: 13 နုတ်: 7 မြှောက်: 30

Functions Without Return (None):

no_return.py
def greet(name): print(f"Xello {name}!") # return statement မရှိဘူး result = greet("မင်းထက်သာ") print(f"Result: {result}") # None ဖြစ်နေမယ်

Output:

Output
Xello မင်းထက်သာ! Result: None

Function မှာ return statement မရှိရင် Python က အလိုလို None ကို return လုပ်တယ်။

Return vs Print - ခြားနားချက်

Return နဲ့ Print မတူဘူးနော်:
  • print - Screen ပေါ်မှာ ပြလိုက်တာပဲ။ အဲ့တန်ဖိုးကို ပြန်သုံးလို့ မရဘူး
  • return - Function ကနေ တန်ဖိုးတစ်ခုကို ပြန်ထုတ်ပေးလိုက်တာ။ အဲ့တန်ဖိုးကို ယူပြီး တခြားနေရာမှာ ဆက်သုံးလို့ရတယ်

Example - Print Only:

print_only.py
def add_with_print(a, b): result = a + b print(result) # Print လုပ်ပေမယ့် return မလုပ်ဘူး # Screen ပေါ်မှာ ပြပေမယ့် value ကို သိမ်းလို့ မရဘူး answer = add_with_print(5, 3) # 8 ပြမယ် print(f"Answer: {answer}") # None ဖြစ်နေမယ် # ဒီလို တွက်ချက်မှုတွေ မလုပ်နိုင်ဘူး # total = add_with_print(5, 3) + add_with_print(10, 2) # Error!

Output:

Output
8 Answer: None

Example - Return (Correct Way):

return_correct.py
def add_with_return(a, b): result = a + b return result # တန်ဖိုးကို return ပြန်ပေးတယ် # Value ကို သိမ်းလို့ရတယ် answer = add_with_return(5, 3) print(f"Answer: {answer}") # 8 ပြမယ် # တွက်ချက်မှုတွေ လုပ်လို့ရတယ် total = add_with_return(5, 3) + add_with_return(10, 2) print(f"Total: {total}") # 20

Output:

Output
Answer: 8 Total: 20

Variable Scope (Local vs Global)

Variable တွေမှာ scope (နယ်မြေကန့်သတ်ချက်) ရှိတယ်။ Function ထဲမှာ ရေးတဲ့ variable က local၊ function အပြင်မှာ ရေးထားတဲ့ variable က global။

Local Variables:

local_variables.py
def my_function(): local_var = "ဒါက local" print(local_var) my_function() # Function အပြင်ကနေ local variable ကို access မလုပ်နိုင်ဘူး try: print(local_var) # Error! except NameError: print("local_var က function အပြင်မှာ မရှိဘူး")

Output:

Output
ဒါက local local_var က function အပြင်မှာ မရှိဘူး

Global Variables:

global_variables.py
# Global variable global_var = "ဒါက global" def my_function(): # Function ထဲကနေ global variable ကို ဖတ်လို့ရတယ် print(global_var) my_function() print(global_var) # Function အပြင်ကနေလည်း ရတယ်

Output:

Output
ဒါက global ဒါက global

Global Keyword:

global_keyword.py
counter = 0 def increment(): global counter # Global variable ကို ပြင်မယ် counter += 1 print(f"Counter: {counter}") increment() increment() increment()

Output:

Output
Counter: 1 Counter: 2 Counter: 3

*args and **kwargs (Flexible Arguments)

တစ်ခါတစ်လေ argument ဘယ်နှခု ထည့်မလဲ ကြိုမသိရင် *args နဲ့ **kwargs သုံးလို့ရတယ်။

*args - Variable Number of Positional Arguments:

args_example.py
def sum_all(*args): # args က tuple အဖြစ် ရလာမယ် total = 0 for num in args: total += num return total print(sum_all(1, 2, 3)) print(sum_all(1, 2, 3, 4, 5)) print(sum_all(10, 20))

Output:

Output
6 15 30

**kwargs - Variable Number of Keyword Arguments:

kwargs_example.py
def print_info(**kwargs): # kwargs က dictionary အနေနဲ့ ရလာမယ် for key, value in kwargs.items(): print(f"{key}: {value}") print_info(name="မင်းထက်သာ", age=25, city="Yangon")

Output:

Output
name: မင်းထက်သာ age: 25 city: Yangon

Combining Regular, *args, and **kwargs:

combined_args.py
def flexible_function(required, *args, **kwargs): print(f"Required: {required}") print(f"Args: {args}") print(f"Kwargs: {kwargs}") flexible_function("must have", 1, 2, 3, name="Test", value=100)

Output:

Output
Required: must have Args: (1, 2, 3) Kwargs: {'name': 'Test', 'value': 100}

Lambda Functions (Anonymous Functions)

Lambda function က တစ်ကြောင်းတည်းနဲ့ ရေးလို့ရတဲ့ အတိုကောက် function လို့ပြောလို့ရတယ်။ ရိုးရှင်းတဲ့ function တွေဆောက်ဖို့ အတွက်သုံးတယ်။

Lambda Syntax:

Lambda Syntax
lambda arguments: expression

Example - Regular Function vs Lambda:

lambda_vs_regular.py
# Regular function def add(a, b): return a + b # Lambda function (တစ်ကြောင်းတည်း) add_lambda = lambda a, b: a + b print(add(5, 3)) print(add_lambda(5, 3))

Output:

Output
8 8

Lambda with map(), filter():

lambda_with_map.py
numbers = [1, 2, 3, 4, 5] # map() နဲ့ သုံးတာ - ဂဏန်းတိုင်းကို နှစ်ဆ လုပ်မယ် doubled = list(map(lambda x: x * 2, numbers)) print(f"Doubled: {doubled}") # filter() နဲ့ သုံးတာ - စုံဂဏန်းတွေပဲ ယူမယ် evens = list(filter(lambda x: x % 2 == 0, numbers)) print(f"Evens: {evens}")

Output:

Output
Doubled: [2, 4, 6, 8, 10] Evens: [2, 4]

Function Naming Conventions

Function နာမည် ပေးတဲ့အခါ စည်းကမ်းတွေ ရှိတယ်။

Naming Rules:

  • Lowercase with underscores: my_function, calculate_total
  • Descriptive names: Function က ဘာလုပ်တယ်ဆိုတာ ရှင်းရှင်းလင်းလင်း သိနိုင်အောင်
  • Verbs: Function က action လုပ်တဲ့အတွက် verb နဲ့ စတာ ကောင်းတယ် (calculate, get, set, print)
  • No spaces: Space မထည့်ဘဲ underscore သုံးပါ
  • Start with letter: ဂဏန်းနဲ့ စလို့မရ

Good vs Bad Names:

naming_examples.py
# Good names (ရှင်းတယ်) def calculate_total_price(items): pass def get_user_name(): pass def send_email(recipient, message): pass # Bad names (မရှင်းဘူး) def calc(): # တိုလွန်းတယ် pass def x(): # ဘာလုပ်တာလဲ မသိရ pass def DoSomething(): # CamelCase မသင့်တော် pass

Function Documentation (Docstrings)

Function ကို document လုပ်ဖို့ docstring သုံးလို့ရတယ်။ Triple quotes """...""" နဲ့ ရေးတယ်။

docstring_example.py
def calculate_area(length, width): """ စတုဂံရဲ့ ဧရိယာကို တွက်တာ။ Parameters: length (float): အရှည် width (float): အနံ Returns: float: ဧရိယာ """ return length * width # Docstring ကို ဖတ်လို့ရတယ် print(calculate_area.__doc__)

Early Return (Conditional Returns)

Function တစ်ခုမှာ return statement အများကြီး ရှိနေနိုင်တယ်။ Condition ပေါ်မူတည်ပြီး မတူညီတဲ့ value တွေ return လုပ်လို့ရတယ်။

early_return.py
def check_age(age): if age < 0: return "Invalid age" elif age < 18: return "လူငယ်" elif age < 60: return "လူကြီး" else: return "သက်ကြီးရွယ်အို" print(check_age(15)) print(check_age(30)) print(check_age(70))

Output:

Output
လူငယ် လူကြီး သက်ကြီးရွယ်အို

Functions Calling Functions

Function တစ်ခုက နောက် function တစ်ခုကို ခေါ်လို့ရတယ်။

function_calling_function.py
def celsius_to_fahrenheit(celsius): return (celsius * 9/5) + 32 def fahrenheit_to_celsius(fahrenheit): return (fahrenheit - 32) * 5/9 def temperature_info(temp, unit): # ဒီ function က အပေါ်က functions တွေကို ခေါ်တယ် if unit == "C": fahrenheit = celsius_to_fahrenheit(temp) print(f"{temp}°C = {fahrenheit:.1f}°F") elif unit == "F": celsius = fahrenheit_to_celsius(temp) print(f"{temp}°F = {celsius:.1f}°C") temperature_info(100, "C") temperature_info(32, "F")

Output:

Output
100°C = 212.0°F 32°F = 0.0°C

Recursion (Function ကကိုယ့်ကိုယ်ကို ပြန်ခေါ်တာ)

Recursion ဆိုတာ function တစ်ခုက ကိုယ့်ကိုယ်ကို ပြန်ခေါ်တာကို ပြောတာ။

Example: Factorial:

recursion_factorial.py
def factorial(n): # Base case (ရပ်တဲ့ အခြေအနေ) if n == 0 or n == 1: return 1 # Recursive case (ကိုယ့်ကိုယ်ကို ပြန်ခေါ်တာ) else: return n * factorial(n - 1) print(f"5! = {factorial(5)}") # 5 * 4 * 3 * 2 * 1 = 120 print(f"3! = {factorial(3)}") # 3 * 2 * 1 = 6

Output:

Output
5! = 120 3! = 6

သတိ: Recursion သုံးတဲ့အခါ ရပ်တဲ့ အခြေနေ ရှိရမယ်။ မဟုတ်ရင် infinite loop ဖြစ်သွားမယ်။

Pass Statement (Empty Functions)

Function တစ်ခု ဆောက်ချင်ပေမယ့် code မရေးသေးချင်ရင် pass သုံးလို့ရတယ်။

pass_statement.py
def empty_function(): pass # ဘာမှ မလုပ်ဘူး၊ နောက်မှ ရေးမယ် def coming_soon(): pass # TODO: Implement later empty_function() # Error မတက်ဘူး

Common Mistakes

1. Forgetting Parentheses When Calling:

mistake_parentheses.py
def greet(): print("Xello") # Wrong - ကွင်း မပါဘူး print(greet) # Function object ကို print ထုတ်မယ် # Correct - ကွင်း ပါရမယ် greet() # Function ကို execute လုပ်မယ်

2. Forgetting Return Statement:

mistake_return.py
# Wrong - return မရှိဘူး def add_wrong(a, b): result = a + b # return ပါရမယ်! answer = add_wrong(5, 3) print(answer) # None # Correct - return ပါတယ် def add_correct(a, b): result = a + b return result answer = add_correct(5, 3) print(answer) # 8

3. Indentation Errors:

mistake_indentation.py
# Wrong - indentation မှားနေတယ် # def greet(): # print("Hello") # IndentationError! # Correct - indent လုပ်ထားတယ် def greet(): print("Hello") # 4 spaces သို့မဟုတ် 1 tab

Practical Examples

Example 1: Calculator Functions:

calculator.py
def add(a, b): return a + b def subtract(a, b): return a - b def multiply(a, b): return a * b def divide(a, b): if b == 0: return "Cannot divide by zero" return a / b # Calculator သုံးကြည့်မယ် print(f"10 + 5 = {add(10, 5)}") print(f"10 - 5 = {subtract(10, 5)}") print(f"10 × 5 = {multiply(10, 5)}") print(f"10 ÷ 5 = {divide(10, 5)}")

Example 2: Temperature Converter:

temperature_converter.py
def celsius_to_fahrenheit(celsius): """Celsius ကနေ Fahrenheit ကို ပြောင်းတယ်""" return (celsius * 9/5) + 32 def fahrenheit_to_celsius(fahrenheit): """Fahrenheit ကနေ Celsius ကို ပြောင်းတယ်""" return (fahrenheit - 32) * 5/9 def celsius_to_kelvin(celsius): """Celsius ကနေ Kelvin ကို ပြောင်းတယ်""" return celsius + 273.15 # Temperature Converter သုံးကြည့်မယ် print("=== Temperature Converter ===") print(f"100°C = {celsius_to_fahrenheit(100)}°F") print(f"32°F = {fahrenheit_to_celsius(32)}°C") print(f"0°C = {celsius_to_kelvin(0)}K")

Example 3: Grade Calculator:

grade_calculator.py
def calculate_average(scores): """အမှတ်တွေရဲ့ ပျမ်းမျှကို တွက်မယ်""" if len(scores) == 0: return 0 return sum(scores) / len(scores) def get_grade(average): """ပျမ်းမျှ အမှတ်ကနေ Grade ပေးတယ်""" if average >= 90: return "A" elif average >= 80: return "B" elif average >= 70: return "C" elif average >= 60: return "D" else: return "F" def student_report(name, scores): """ကျောင်းသား Report ပြတယ်""" average = calculate_average(scores) grade = get_grade(average) print(f"\n=== {name} ရဲ့ Report ===") print(f"အမှတ်များ: {scores}") print(f"ပျမ်းမျှ: {average:.2f}") print(f"Grade: {grade}") # Grade Calculator သုံးကြည့်မယ် student_report("မင်းထက်သာ", [85, 90, 88, 92]) student_report("မောင်စိုင်း", [75, 70, 78, 72])

Built-in Functions (Python မှာ ပါပြီးသား)

Python မှာ built-in functions ရှိတယ် တစ်နည်းပြောရရင် Python မှာပါပြီးသား functions တွေ။

builtin_examples.py
# အသုံးများတဲ့ built-in functions print("Hello") # Output ထုတ်တယ် len([1, 2, 3]) # Length ရတယ် type(5) # Data type စစ်တယ် int("10") # String ကို int ပြောင်းတယ် str(100) # Number ကို string ပြောင်းတယ် max([1, 5, 3]) # Maximum ရှာတယ် min([1, 5, 3]) # Minimum ရှာတယ် sum([1, 2, 3]) # Sum တွက်တယ်

Function Reusability (ပြန်သုံးလို့ရတဲ့ အားသာချက်)

Functions ရဲ့ အကြီးမားဆုံး အကျိုးကျေးဇူး ကတော့ reusability ပဲ။ တစ်ခါ ရေးပြီးရင် ဘယ်နေရာမှာမဆို ခေါ်သုံးလို့ရတယ်။

Example: Password Validator:

password_validator.py
def is_valid_password(password): """ Password က valid ဖြစ်/မဖြစ် - အနည်းဆုံး 8 လုံး ရှိရမယ် - ဂဏန်း ပါရမယ် """ if len(password) < 8: return False has_digit = False for char in password: if char.isdigit(): has_digit = True break return has_digit # ဒီ function ကို နေရာ အမျိုးမျိုးမှာ သုံးလို့ရတယ် passwords = ["abc123", "password123", "nodigit", "valid1234"] for pwd in passwords: if is_valid_password(pwd): print(f"'{pwd}' က valid") else: print(f"'{pwd}' က invalid")

Output:

Output
'abc123' က invalid 'password123' က valid 'nodigit' က invalid 'valid1234' က valid

ဘယ်ချိန် Functions သုံးမလဲ?

  • Code Repetition: တူညီတဲ့ code ကို ထပ်ခါထပ်ခါ ရေးနေရရင်
  • Complex Tasks: ရှုပ်ထွေးတဲ့ အလုပ်ကို ခွဲခြားပြီး လုပ်ချင်ရင်
  • Testing: Code ကို test လုပ်ဖို့ လွယ်စေချင်ရင်
  • Organization: Code ကို စနစ်တကျ စီမံချင်ရင်
  • Reusability: Code ကို နေရာ အမျိုးမျိုးမှာ သုံးချင်ရင်

အနှစ်ချုပ်

ကဲ... Function ဆိုတာ ဒါပါပဲ။

Function Basics:

  • def နဲ့ ဆောက်မယ်။ (ဥပမာ: def my_func():)
  • () နဲ့ ခေါ်မယ်။ (ဥပမာ: my_func())
  • Parameter (() ထဲက variable) နဲ့ data လက်ခံမယ်။ (ဥပမာ: def hi(name):)
  • return နဲ့ အဖြေပြန်ပေးမယ်။ (ဥပမာ: return result)

Key Concepts:

  • DRY Principle: Don't Repeat Yourself - Functions ကို သုံးပြီး code repetition ကို ရှောင်
  • Parameters: Function definition မှာ ထားတဲ့ variables
  • Arguments: Function call လုပ်တဲ့အခါ ထည့်ပေးတဲ့ values
  • Return: Function ကနေ value ပြန်ပေးတာ (print မဟုတ်ဘူး!)
  • Scope: Local variables က function ထဲမှာပဲ ရှိတယ်

Advanced Features:

  • Default Parameters: def greet(name="User"):
  • Multiple Returns: Tuple အနေနဲ့ တန်ဖိုး အများကြီး return လုပ်လို့ရတယ်
  • *args & **kwargs: Variable number of arguments
  • Lambda Functions: တစ်ကြောင်းတည်း functions
  • Recursion: Function က ကိုယ့်ကိုယ်ကို ပြန်ခေါ်တာ
Functions က Programming ရဲ့ အုတ်မြစ်! Functions ကို ကောင်းကောင်း သုံးတတ်သွားရင် bro ရဲ့ code က ရှင်းလင်းသွားမယ်၊ maintain လုပ်ဖို့ လွယ်သွားမယ်၊ reusable ဖြစ်သွားမယ်။ ဒါက Python programming မှာ အရေးကြီးဆုံး concept တွေထဲကတစ်ခု။

Quick Reference

function_reference.py
# Basic function def greet(): print("Hello") # Function with parameters def greet_person(name): print(f"Hello {name}") # Function with return def add(a, b): return a + b # Default parameters def greet(name="User"): print(f"Hello {name}") # Multiple returns def calc(a, b): return a+b, a-b, a*b # *args def sum_all(*args): return sum(args) # **kwargs def print_info(**kwargs): for k, v in kwargs.items(): print(f"{k}: {v}") # Lambda square = lambda x: x**2 # Recursion def factorial(n): if n == 1: return 1 return n * factorial(n-1)