พื้นฐาน Python

การเขียนโปรแกรมเชิงวัตถุใน Python

ในบทเรียนนี้ คุณจะรู้จักการห่อหุ้ม การสืบทอด การเขียนเมธอดทับ และพหุสัณฐาน ผ่านตัวอย่างบัญชีธนาคารใน Python

  • ระดับเริ่มต้น
  • อ่าน 4 นาที
  • ตัวอย่างที่รันได้ 1 ตัวอย่าง

การเขียนโปรแกรมเชิงวัตถุใน 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: ใช้การทำงานเดียวกันกับหลายชนิดโดยแต่ละชนิดมีพฤติกรรมเหมาะสม

การออกแบบตัวอย่าง

  1. BankAccount เป็นเจ้าของยอดเงินและตรวจสอบการฝาก
  2. SavingsAccount ใช้สัญญาของคลาสฐาน
  3. SavingsAccount override month_end เพื่อเพิ่มดอกเบี้ย
  4. ลูปจัดการทุกบัญชีผ่านอินเทอร์เฟซเดียวกัน
คำแนะนำ: ใช้ composition เมื่อออบเจ็กต์เพียงใช้อีกออบเจ็กต์ และใช้ inheritance เมื่อคลาสลูกแทนคลาสแม่ได้อย่างถูกต้อง

ใช้เมื่อไร?

  • อ็อบเจกต์หลายชนิดที่มีพฤติกรรมส่วนใหญ่ร่วมกัน: ประเภทบัญชี รูปทรง ตัวละครในเกม
  • โค้ดที่ต้องทำงานกับชนิดใหม่ในภายหลังโดยไม่ต้องเขียนใหม่
  • ปกป้องข้อมูลที่ต้องถูกต้องเสมอ เช่น ยอดเงินที่ติดลบไม่ได้

เมื่อไรยังไม่จำเป็น

  • สคริปต์เล็กๆ ที่มีไม่กี่ฟังก์ชัน: คลาสและ inheritance เพิ่มโครงสร้างที่คุณไม่ต้องการ
  • สายการสืบทอดที่ลึก (A จาก B จาก C จาก D): ตามยาก ควรใช้ composition

ตัวอย่างพื้นฐาน

รันโค้ด →
main.py
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})")
สร้างปุ่ม Run สำหรับตัวอย่างนี้

ผลลัพธ์จากการรัน

Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)

หลัก OOP ทั้งสี่ในการใช้งานจริง

ตัวอย่างเหล่านี้แสดงวิธีที่ Python ใช้ encapsulation, abstraction, inheritance และ polymorphism ในโค้ดทั่วไป

Encapsulation

รันโค้ด →

รวมสถานะและพฤติกรรมและควบคุมการเข้าถึง

encapsulation.py
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

รันโค้ด →

แสดงอินเทอร์เฟซที่จำเป็นและซ่อนรายละเอียด

abstraction.py
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 จริง

inheritance.py
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

รันโค้ด →

ใช้การทำงานเดียวกันกับหลายชนิดโดยแต่ละชนิดมีพฤติกรรมเหมาะสม

polymorphism.py
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

แบบฝึกหัดเพิ่มเติม

ลองแก้โค้ดตามคำแนะนำด้านล่าง การเปลี่ยนโค้ดแล้วดูผลลัพธ์จะช่วยให้เข้าใจบทเรียนได้ดีกว่าการอ่านอย่างเดียวมาก

  1. เปลี่ยนข้อมูลอินพุตแล้วทายผลลัพธ์ก่อนรัน
  2. เพิ่มการตรวจสอบข้อมูลว่างหรือข้อมูลที่ไม่ถูกต้อง
  3. แยกขั้นตอนการประมวลผลเป็นฟังก์ชันและทดสอบกับข้อมูลหลายชุด
รันในคอมไพเลอร์ 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

โจทย์ทั้งหมด