Python Polymorphism
Polymorphism (พหุสัณฐาน) แปลว่า “มีได้หลายรูป” ในทาง OOP หมายถึง โค้ดชุดเดียวทำงานกับอ็อบเจกต์หลายชนิดได้ โดยแต่ละชนิดตอบสนองในแบบของตัวเอง
ภาพรวมด้วยตัวอย่าง
class Dog:
def speak(self):
return "โฮ่ง"
class Cat:
def speak(self):
return "เมี้ยว"
class Duck:
def speak(self):
return "ก้าบ"
animals = [Dog(), Cat(), Duck()]
for animal in animals:
print(animal.speak())ผลลัพธ์:
โฮ่ง
เมี้ยว
ก้าบลูปนี้ไม่สนใจว่าอ็อบเจกต์เป็นชนิดไหน แค่เรียก .speak() แล้วแต่ละตัวก็ทำงานแบบของมัน นี่คือหัวใจของ polymorphism — เขียนโค้ดครั้งเดียว รองรับหลายชนิด
Duck Typing
Python ไม่สนว่าอ็อบเจกต์เป็นคลาสอะไรหรือสืบทอดจากใคร ขอแค่มีเมท็อดที่เรียกก็พอ แนวคิดนี้เรียกว่า duck typing
“ถ้ามันเดินเหมือนเป็ด และร้องเหมือนเป็ด มันก็คือเป็ด”
class PDFReport:
def generate(self):
return "สร้างรายงาน PDF"
class ExcelReport:
def generate(self):
return "สร้างรายงาน Excel"
class EmailReport:
def generate(self):
return "ส่งรายงานทางอีเมล"
def run_report(report):
# ไม่เช็คชนิด แค่เรียก generate()
print(report.generate())
for r in [PDFReport(), ExcelReport(), EmailReport()]:
run_report(r)run_report ทำงานกับอะไรก็ได้ที่มีเมท็อด generate() ไม่ต้องมีคลาสแม่ร่วมกัน
Polymorphism กับ built-in
จริง ๆ เราใช้ polymorphism มาตลอดโดยไม่รู้ตัว len() ทำงานกับหลายชนิด
print(len("สวัสดี")) # 5 — string
print(len([1, 2, 3, 4])) # 4 — list
print(len({"a": 1, "b": 2}))# 2 — dict+ ก็เช่นกัน
print(1 + 2) # 3 บวกเลข
print("a" + "b") # ab ต่อ string
print([1, 2] + [3, 4]) # [1, 2, 3, 4] ต่อ listแต่ละชนิดนิยามว่า + หรือ len() ควรทำอะไรกับตัวมันเอง (ผ่าน magic method ในบทถัดไป)
คลาสนามธรรม (Abstract Base Class)
เมื่ออยากบังคับให้ทุกคลาสลูกต้องมีเมท็อดบางตัว ใช้ abc
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
...
def receipt(self, amount):
return f"ชำระเงิน {amount} บาทเรียบร้อย"
class CreditCard(PaymentMethod):
def pay(self, amount):
print(f"ตัดบัตรเครดิต {amount} บาท")
class PromptPay(PaymentMethod):
def pay(self, amount):
print(f"สแกน QR พร้อมเพย์ {amount} บาท")
# PaymentMethod() -> TypeError สร้างไม่ได้เพราะเป็น abstract
card = CreditCard()
card.pay(500)
print(card.receipt(500))ถ้าคลาสลูกไม่ได้นิยาม pay() Python จะไม่ยอมให้สร้างอ็อบเจกต์ ทำให้เรามั่นใจว่าทุก payment method ใช้งานได้จริง
ตัวอย่างรวม: ระบบแจ้งเตือนหลายช่องทาง
from abc import ABC, abstractmethod
class Notifier(ABC):
@abstractmethod
def send(self, message):
...
class EmailNotifier(Notifier):
def __init__(self, address):
self.address = address
def send(self, message):
print(f"[Email→{self.address}] {message}")
class SMSNotifier(Notifier):
def __init__(self, phone):
self.phone = phone
def send(self, message):
print(f"[SMS→{self.phone}] {message}")
class LineNotifier(Notifier):
def __init__(self, token):
self.token = token
def send(self, message):
print(f"[LINE] {message}")
def broadcast(notifiers, message):
for n in notifiers:
n.send(message)
channels = [
EmailNotifier("user@mail.com"),
SMSNotifier("0812345678"),
LineNotifier("xxxx"),
]
broadcast(channels, "ระบบจะปิดปรับปรุงเวลา 22:00")ผลลัพธ์:
[Email→user@mail.com] ระบบจะปิดปรับปรุงเวลา 22:00
[SMS→0812345678] ระบบจะปิดปรับปรุงเวลา 22:00
[LINE] ระบบจะปิดปรับปรุงเวลา 22:00อยากเพิ่มช่องทางใหม่ เช่น Discord ก็แค่สร้างคลาสที่มี send() โค้ด broadcast ไม่ต้องแก้เลย
เช็คความเข้าใจก่อนข้ามบท
- อธิบายได้ว่าหลายคลาสมี method ชื่อเดียวกัน แต่ทำงานต่างกันได้
- เข้าใจแนวคิด duck typing ใน Python
- ลองสร้างฟังก์ชันที่รับ object หลายชนิด แต่เรียก method ชื่อเดียวกัน
สรุป
- Polymorphism = เรียกเมท็อดชื่อเดียวกันบนอ็อบเจกต์ต่างชนิด แต่ละตัวตอบสนองแบบของมัน
- Duck typing: Python สนแค่ว่า “มีเมท็อดนี้ไหม” ไม่สนคลาส
len(),+เป็น polymorphism ที่ใช้อยู่ทุกวันABC+@abstractmethodบังคับให้คลาสลูกต้องนิยามเมท็อดที่กำหนด
บทถัดไปว่าด้วย magic methods เช่น __str__, __eq__, __len__