การเขียนโปรแกรมเชิงวัตถุใน Python
ในบทเรียนนี้ คุณจะรู้จักการห่อหุ้ม การสืบทอด การเขียนเมธอดทับ และพหุสัณฐาน ผ่านตัวอย่างบัญชีธนาคารใน Python
การเขียนโปรแกรมเชิงวัตถุใน Python คืออะไร?
ปัญหาที่ต้องแก้
เมื่อโปรแกรมโตขึ้น หลายส่วนต้องใช้อ็อบเจกต์ชนิดเดียวกันที่ต่างกันเล็กน้อย: บัญชีปกติกับบัญชีออมทรัพย์ แมวกับสุนัข การคัดลอกคลาสแล้วเปลี่ยนไม่กี่บรรทัดทำให้โค้ดซ้ำ และการตรวจชนิดด้วย if ทุกที่ทำให้ทุกชนิดใหม่เป็นการเปลี่ยนแปลงครั้งใหญ่
ลองนึกภาพแบบนี้
การเขียนโปรแกรมเชิงวัตถุทำงานคล้ายบัญชีต่าง ๆ ในธนาคารเดียวกัน ทุกบัญชีเก็บยอดเงินไว้หลังเคาน์เตอร์ (encapsulation) บัญชีออมทรัพย์คือบัญชีธรรมดาที่มีความสามารถเพิ่มมาอีกหนึ่งอย่าง (inheritance) เมื่อธนาคารประกาศ 'สิ้นเดือน' กับทุกบัญชี แต่ละบัญชีก็ทำตามแบบของตัวเอง (polymorphism)
self._balance🔒 เงินหลังเคาน์เตอร์: เปลี่ยนได้ผ่าน deposit() เท่านั้นclass SavingsAccount(BankAccount):🏦 บัญชีออมทรัพย์คือบัญชีหนึ่ง บวกดอกเบี้ยsuper().__init__(owner, balance)📋 กรอกแบบฟอร์มบัญชีปกติก่อนaccount.month_end()📅 คำขอเดียวกัน แต่ละบัญชีตอบในแบบของตัวเองการเขียนโปรแกรมเชิงวัตถุจัดโปรแกรมเป็นคลาส ซึ่งอ็อบเจกต์เก็บข้อมูลของตัวเองเป็นส่วนตัว (encapsulation) ใช้คลาสอื่นซ้ำ (inheritance) และตอบสนองต่อการเรียกเดียวกันในแบบของตัวเอง (polymorphism)
OOP สร้างแบบจำลองระบบเป็นออบเจ็กต์ที่ทำงานร่วมกัน แต่ละออบเจ็กต์รวมสถานะและการทำงานที่อนุญาต ทำให้ความรับผิดชอบในโปรแกรมใหญ่ชัดเจน
หลักสำคัญสี่ข้อของ OOP
- Encapsulation: รวมสถานะและพฤติกรรมและควบคุมการเข้าถึง
- Abstraction: แสดงอินเทอร์เฟซที่จำเป็นและซ่อนรายละเอียด
- Inheritance: สร้างคลาสเฉพาะเมื่อมีความสัมพันธ์ is-a จริง
- Polymorphism: ใช้การทำงานเดียวกันกับหลายชนิดโดยแต่ละชนิดมีพฤติกรรมเหมาะสม
การออกแบบตัวอย่าง
- BankAccount เป็นเจ้าของยอดเงินและตรวจสอบการฝาก
- SavingsAccount ใช้สัญญาของคลาสฐาน
- SavingsAccount override month_end เพื่อเพิ่มดอกเบี้ย
- ลูปจัดการทุกบัญชีผ่านอินเทอร์เฟซเดียวกัน
ใช้เมื่อไร?
- อ็อบเจกต์หลายชนิดที่มีพฤติกรรมส่วนใหญ่ร่วมกัน: ประเภทบัญชี รูปทรง ตัวละครในเกม
- โค้ดที่ต้องทำงานกับชนิดใหม่ในภายหลังโดยไม่ต้องเขียนใหม่
- ปกป้องข้อมูลที่ต้องถูกต้องเสมอ เช่น ยอดเงินที่ติดลบไม่ได้
เมื่อไรยังไม่จำเป็น
- สคริปต์เล็กๆ ที่มีไม่กี่ฟังก์ชัน: คลาสและ inheritance เพิ่มโครงสร้างที่คุณไม่ต้องการ
- สายการสืบทอดที่ลึก (A จาก B จาก C จาก D): ตามยาก ควรใช้ composition
ตัวอย่างพื้นฐาน
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = float(balance)
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self._balance += amount
def month_end(self):
return "No interest"
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, interest_rate):
super().__init__(owner, balance)
self.interest_rate = interest_rate
def month_end(self):
self._balance *= 1 + self.interest_rate
return "Interest applied"
accounts = [
BankAccount("Ada", 100),
SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)
for account in accounts:
status = account.month_end()
print(f"{account.owner}: {account.balance:.2f} ({status})")
ผลลัพธ์จากการรัน
Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)
หลัก OOP ทั้งสี่ในการใช้งานจริง
ตัวอย่างเหล่านี้แสดงวิธีที่ Python ใช้ encapsulation, abstraction, inheritance และ polymorphism ในโค้ดทั่วไป
Encapsulation
รวมสถานะและพฤติกรรมและควบคุมการเข้าถึง
class BankAccount:
def __init__(self, balance=0):
# Double underscores prevent accidental direct access.
self.__balance = balance
@property
def balance(self):
# Expose read access without exposing mutation.
return self.__balance
def deposit(self, amount):
# Keep validation next to the state it protects.
if amount <= 0:
raise ValueError("Amount must be positive")
self.__balance += amount
account = BankAccount(100)
account.deposit(50)
print(account.balance) # 150
Abstraction
แสดงอินเทอร์เฟซที่จำเป็นและซ่อนรายละเอียด
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
# Callers know what pay does, not how each provider does it.
pass
class CreditCard(PaymentMethod):
def pay(self, amount):
# The concrete class hides its payment implementation.
return f"Paid ${amount:.2f} by card"
payment = CreditCard()
print(payment.pay(25))
Inheritance
สร้างคลาสเฉพาะเมื่อมีความสัมพันธ์ is-a จริง
class Employee:
def __init__(self, name):
self.name = name
def describe(self):
return self.name
class Developer(Employee):
def __init__(self, name, language):
# Reuse initialization from the parent class.
super().__init__(name)
self.language = language
def describe(self):
# Extend inherited behavior instead of duplicating it.
return f"{super().describe()} writes {self.language}"
print(Developer("Ada", "Python").describe())
Polymorphism
ใช้การทำงานเดียวกันกับหลายชนิดโดยแต่ละชนิดมีพฤติกรรมเหมาะสม
class EmailNotification:
def send(self, message):
return f"Email: {message}"
class SmsNotification:
def send(self, message):
return f"SMS: {message}"
def notify(channels, message):
for channel in channels:
# The same call selects behavior from each concrete object.
print(channel.send(message))
channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")
อธิบายโค้ด
คลาส BankAccount ห่อหุ้มยอดเงินไว้ในแอตทริบิวต์ _balance และยอมให้เปลี่ยนได้ผ่านเมธอดที่ควบคุมไว้อย่าง deposit() เท่านั้น คลาส SavingsAccount สืบทอดเมธอดทั้งหมดนี้และเขียน month_end() ทับเพื่อเพิ่มดอกเบี้ย ลูปเรียกเมธอดเดียวกันกับทั้งสองบัญชี แต่ Python จะเลือกเวอร์ชันที่เหมาะกับออบเจกต์แต่ละชนิดขณะทำงาน นี่คือพหุสัณฐาน
เปลี่ยนค่าและรันโปรแกรมด้วย คอมไพเลอร์ Python ออนไลน์ของ CodeUtility โดยไม่ต้องติดตั้ง Python
แบบฝึกหัดเพิ่มเติม
ลองแก้โค้ดตามคำแนะนำด้านล่าง การเปลี่ยนโค้ดแล้วดูผลลัพธ์จะช่วยให้เข้าใจบทเรียนได้ดีกว่าการอ่านอย่างเดียวมาก
- เปลี่ยนข้อมูลอินพุตแล้วทายผลลัพธ์ก่อนรัน
- เพิ่มการตรวจสอบข้อมูลว่างหรือข้อมูลที่ไม่ถูกต้อง
- แยกขั้นตอนการประมวลผลเป็นฟังก์ชันและทดสอบกับข้อมูลหลายชุด
ข้อผิดพลาดที่พบบ่อย
ลืมเรียก super().__init__
ถ้าไม่เรียก การตั้งค่าของคลาสแม่จะไม่ทำงาน และ attribute อย่าง owner จะหายไป
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
self.interest_rate = rate
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
super().__init__(owner, balance)
self.interest_rate = rate
เปลี่ยนข้อมูลที่ป้องกันไว้โดยตรง
การตั้ง _balance จากภายนอกข้ามการตรวจใน deposit()
account._balance = -500
account.deposit(50)
เรียนบทนี้จบแล้วใช่ไหม
ทำเครื่องหมายว่าเรียนแล้วเพื่อติดตามความคืบหน้า
ฝึกด้วยโจทย์
ใช้สิ่งที่เรียนในบทนี้แก้ปัญหาจริง ทุกโจทย์รันในเบราว์เซอร์ พร้อมการทดสอบทันทีและรีวิวจาก AI
โจทย์ทั้งหมด