Python Tutorial - Learn Programming

Polymorphism ဆိုတာ ဘာလဲ?

Inheritance (အမွေ) ကိစ္စ ရှင်းသွားပြီဆိုတော့၊ Polymorphism ပေါ့။

စကားလုံးကို ခွဲကြည့်: Poly (အများကြီး) + Morph (ပုံစံ) = ပုံစံအများကြီး

The Definition: ဒါက တစ်ချက်ခုတ်၊ အကုန်ပြတ် ကိစ္စ။

စဉ်းစားကြည့်... PS5 controller မှာ X ခလုတ် ရှိတယ်မလား။

FIFA ကန်နေတုန်း X နှိပ်ရင် ဘာဖြစ်မလဲ? Pass ပေးတယ်။
God of War ဆော့နေတုန်း X နှိပ်ရင် ဘာဖြစ်မလဲ? Dodge (ရှောင်) သွားတယ်။

ခလုတ်က ခလုတ် တစ်ခုတည်း (X button)။ ဒါပေမယ့် ဆော့နေတဲ့ Game (Object) ပေါ်မူတည်ပြီး သူလုပ်သွားတဲ့ အလုပ် (Action) က တစ်မျိုးစီ ဖြစ်သွားတယ်။

OOP မှာလည်း အဲ့ဒီအတိုင်းပဲ။ Method (function) နာမည် တစ်ခုတည်း က သူ့ကို ခေါ်လိုက်တဲ့ Object (Class) ပေါ်မူတည်ပြီး အလုပ်လုပ်ပုံ ပုံစံအများကြီး ပြောင်းသွားတာကို Polymorphism လို့ခေါ်တာ။

ဒါကို ဘာလို့ သုံးရတာလဲ?

Flexibility (ပြောင်းလွယ်ပြင်လွယ်) ရှိလို့။

Polymorphism မရှိရင် ဘရို ဘယ်လို code တွေ ရေးရမလဲ သိလား? if...else... တွေနဲ့ ညစ်သွားမှာ။

                Without Polymorphism code ညစ်ပတ်ပြီ
            
# ဒါက Polymorphism မသုံးတဲ့ code
if object_is_dog:
    object.bark()
elif object_is_cat:
    object.meow()
elif object_is_duck:
    object.quack()

Polymorphism သုံးလိုက်ရင်... အဲ့ဒါတွေ အကုန် မလိုတော့ဘူး။

                With Polymorphism
            
# ဒါက Polymorphism နဲ့ ဖိုင်းသွားတဲ့ code
# ဘာ object ကြီးပဲ လာလာ၊ speak() သာ ခေါ်ချလိုက်
object.speak()

အဓိက အားသာချက်: ဘရိုက ဘာကောင်လဲ လို့ စစ်စရာမလိုတော့ဘူး။ မင်း စကားပြောတတ်လား? ပြော လို့ ခိုင်းလိုက်ရုံပဲ။

Python မှာ Polymorphism ကဘယ်လို စွမ်းတာလဲ?

Python မှာ Polymorphism လုပ်လို့ရတဲ့ နည်းလမ်း ၂ ခု ရှိတယ်။

1. Inheritance နဲ့ Overriding (Classic နည်း)

ဒါက ဘရို Inheritance မှာ နည်းနည်း တွေ့ခဲ့ပြီးသား။ Animal မှာ speak() skill ရှိတယ်။ Dog, Cat က အဲ့ဒီ speak() ကိုပဲ Override လုပ်ပြီး သူ့အသံနဲ့သူ ထွက်တယ်။

Code ကြည့်မယ်:

                Inheritance with Overriding Example
            
# SuperClass
class Animal:
    def speak(self):
        print("... (တိတ်ဆိတ်နေသည်) ...")

# SubClasses
class Dog(Animal):
    def speak(self):  # Overriding လုပ်ပြီ
        print("ဝုတ်! ဝုတ်!")

class Cat(Animal):
    def speak(self):  # Overriding လုပ်ပြီ
        print("မြောင်... မြောင်...")

class Duck(Animal):
    def speak(self):  # Overriding လုပ်ပြီ
        print("ကွတ်! ကွတ်!")



# တိရစ္ဆာန်တွေ အကုန် စုထားမယ်
my_pets = [Dog(), Cat(), Duck(), Animal()]

# အခု... ဘာကောင်တွေလဲဆိုတာ စိတ်မဝင်စားဘူး
# speak() ဆိုတဲ့ ခလုတ် ကိုပဲ နှိပ်မယ်
for pet in my_pets:
    pet.speak()  <-- ဒါက Polymorphism!

Output:

                Output
            
ဝုတ်! ဝုတ်!
မြောင်... မြောင်...
ကွတ်! ကွတ်!
... (တိတ်ဆိတ်နေသည်) ...

တွေ့လား? ဘရိုခေါ်လိုက်တာ pet.speak() ဆိုတဲ့ command တစ်ခုတည်း။ ဒါပေမယ့် pet ထဲက object ပေါ်မူတည်ပြီး အသံ တစ်မျိုးစီ ထွက်သွားတယ်။

2. Duck Typing (Python ရဲ့ အမိုက်စားနည်း)

ဒါက Python ရဲ့ Signature (လက်မှတ်) လို ကိစ္စ။ အလန်းပေါ့။

Duck Typing ဆိုတာ ဘာလဲ?

Duck Typing ရဲ့ အဓိပ္ပာယ်: ဘဲ (Duck) လို လမ်းလျှောက်၊ ဘဲလို အော်တတ်ရင်... အဲ့ဒါ ဘဲပဲကွာ။ (If it walks like a duck and quacks like a duck, it is a duck.)

Python က bro ဘယ် class က လာတာလဲ? (bro ရဲ့ Inheritance) ကို လုံးဝ စိတ်မဝင်စားဘူး။ Python က bro မှာ အဲ့ဒီ skill (method) ရှိလား ဆိုတာပဲ စိတ်ဝင်စားတယ်။

အပေါ်က Dog, Cat, Duck တွေက Animal ကနေ အမွေဆက်ခံ (Inherit) မှ မဟုတ်ဘူး။ အချင်းချင်း ဘာမှ မတော်လည်း အလုပ်လုပ်တယ်။

ကြည့်ရအောင် (Duck Typing):

                Duck Typing Example
            
# ဒီ class တွေက ဘယ်သူ့ ဆီကမှ အမွေမယူထားဘူး
# အချင်းချင်း ဘာမှ မတော်ဘူး

class Car:
    def drive(self):
        print("ဘရွန်း... ကားမောင်းနေပြီ...")

class Bicycle:
    def drive(self):
        print("ရှူး... စက်ဘီး နင်းနေတယ်...")

class Plane:
    def fly(self):  <-- ဒါက နာမည်မတူဘူး
        print("ဝှီး... လေယာဉ် ပျံနေပြီ...")



# ဒီ function က obj ဆိုတဲ့ကောင်ကို ယူမယ်
# ပြီးရင် drive() ဆိုတဲ့ skill ကို ခေါ်မယ်
# obj က Car လား Bicycle လား သူ စိတ်မဝင်စားဘူး
def start_driving(obj):
    obj.drive()

# စမ်းကြည့်မယ်
car1 = Car()
bike1 = Bicycle()
plane1 = Plane()

start_driving(car1)    # အလုပ်လုပ်တယ်
start_driving(bike1)   # အလုပ်လုပ်တယ်
# start_driving(plane1)  # <-- ဒါကို ခေါ်ရင် Error တက်မယ်

Output:

                Output
            
ဘရွန်း... ကားမောင်းနေပြီ...
ရှူး... စက်ဘီး နင်းနေတယ်...

plane1 ကို start_driving() နဲ့ ခေါ်ရင်ဘာလို့ Error တက်လဲ?

ဘာလို့ Error တက်လဲ?

Python က ကြည့်လိုက်တယ်။ ဟေ့ plane1၊ မင်းမှာ drive() ဆိုတဲ့ skill ရှိလား?
plane1: Sorry ဘရို၊ ငါ့မှာ fly() ပဲ ရှိတာ။
Python: ဒါဆို မင်းက ဘဲ (Duck) မဟုတ်ဘူး။ ငါခေါ်မရဘူး။ Error!

ဒါပဲ။ Python က Car လား Bicycle လားလို့ မစစ်ဘူး။ drive() ဆိုတဲ့ အပြုအမူ (Behavior) ရှိ၊ မရှိပဲ စစ်တယ်။

အနှစ်ချုပ်

Polymorphism ဆိုတာ: ပုံစံအများကြီး။
ဘာကို ပြောတာလဲ?: Method (function) နာမည် တစ်ခုတည်း က object မတူရင် အလုပ်လုပ်ပုံ တစ်မျိုးစီ ဖြစ်သွားတာ။
နည်းလမ်း (၁) - Inheritance: SuperClass ရဲ့ skill ကို SubClass တွေက Override လုပ်ပြီး သုံးတယ်။ (ဥပမာ: Animal.speak() ကို Dog နဲ့ Cat က ပြင်သုံးတာ)
နည်းလမ်း (၂) - Duck Typing (Pythonic Way): အမျိုး (Class) ကို မစစ်ဘူး။ Skill (Method) ရှိ၊ မရှိပဲ စစ်တယ်။ Skill ရှိရင် ခေါ်လို့ရတယ်။ ဥပမာ: drive() ရှိရင် Car ဖြစ်ဖြစ် Bicycle ဖြစ်ဖြစ် ခေါ်သုံးလို့ရတာ

နိဂုံး: ဘရို... ဒီလောက်ဆို Polymorphism ကို နားလည်သွားလောက်ပြီ ထင်တယ်။ ဒါက OOP ရဲ့ အလန်းဆုံး feature တွေထဲက တစ်ခုပဲ။