Python Attribute, Method และ Encapsulation



Encapsulation คือแนวคิดของการ “ห่อ” ข้อมูลกับโค้ดที่จัดการข้อมูลนั้นไว้ด้วยกัน แล้วควบคุมว่าโค้ดข้างนอกเข้าถึงอะไรได้บ้าง เป้าหมายคือป้องกันไม่ให้มีใครไปแก้ข้อมูลภายในจนอยู่ในสถานะที่ผิดพลาด

ปัญหาเมื่อ attribute เปิดหมด

class BankAccount:
    def __init__(self, balance):
        self.balance = balance


acc = BankAccount(1000)
acc.balance = -5000        # ใคร ๆ ก็ตั้งเป็นติดลบได้ ไม่มีอะไรห้าม

ยอดเงินติดลบไม่สมเหตุสมผล แต่โค้ดข้างนอกแก้ได้อิสระ เราอยากบังคับว่าการเปลี่ยน balance ต้องผ่านกฎบางอย่าง

ระดับการเข้าถึงใน Python

Python ไม่มี private / public แบบภาษาอื่น แต่ใช้ธรรมเนียมการตั้งชื่อ

ชื่อความหมาย (ตามธรรมเนียม)
nameสาธารณะ ใช้ได้อิสระ
_nameภายใน — “อย่าแตะจากข้างนอกนะ” (แต่ทำได้ ไม่มีการบังคับ)
__namePython เปลี่ยนชื่อจริงเป็น _ClassName__name (name mangling) เข้าถึงตรง ๆ จากข้างนอกยากขึ้น

_ ตัวเดียว: เครื่องหมายบอกใบ้

class Config:
    def __init__(self):
        self._cache = {}        # ตั้งใจให้เป็นเรื่องภายใน
        self.name = "app"       # เปิดให้ใช้

_cache ยังเข้าถึงได้จากข้างนอก แต่การขึ้นต้นด้วย _ เป็นการส่งสัญญาณว่า “นี่เป็นรายละเอียดภายใน อาจเปลี่ยนได้ อย่าพึ่งพา”

__ สองตัว: name mangling

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance


acc = BankAccount(1000)
print(acc.get_balance())    # 1000
print(acc.__balance)        # AttributeError
print(acc._BankAccount__balance)   # 1000  (ยังเข้าถึงได้ถ้าตั้งใจ)

__balance ไม่ได้ “private จริง” แต่ Python เปลี่ยนชื่อให้ยากต่อการชนและยากต่อการเผลอแตะ

getter / setter ด้วยเมท็อด

ควบคุมการอ่าน/เขียนผ่านเมท็อด แล้วใส่กฎไว้ในนั้น

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def get_balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("จำนวนเงินต้องมากกว่า 0")
        self._balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("จำนวนเงินต้องมากกว่า 0")
        if amount > self._balance:
            raise ValueError("ยอดเงินไม่พอ")
        self._balance -= amount


acc = BankAccount("สมชาย", 1000)
acc.deposit(500)
print(acc.get_balance())    # 1500
acc.withdraw(10000)         # ValueError: ยอดเงินไม่พอ

ตอนนี้ไม่มีทางที่ balance จะติดลบหรือถูกตั้งค่ามั่ว ๆ เพราะทุกการเปลี่ยนแปลงผ่านเมท็อดที่มีการตรวจสอบ

แบบ Pythonic: ใช้ @property

การเขียน get_balance() แบบ Java ไม่ใช่สไตล์ Python ทั่วไป Python มี @property ที่ทำให้เรียกเหมือน attribute ธรรมดาแต่ยังมีการควบคุม (มีบทเจาะลึกถัดไป ตัวอย่างพอให้เห็นภาพ)

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("ต่ำกว่าศูนย์สัมบูรณ์ไม่ได้")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9 / 5 + 32


t = Temperature(25)
print(t.celsius)       # 25   เรียกเหมือน attribute
print(t.fahrenheit)    # 77.0 คำนวณให้อัตโนมัติ
t.celsius = 30         # ผ่าน setter มีการตรวจสอบ
t.celsius = -300       # ValueError

แนวคิดหลัก

Encapsulation ที่ดีคือการออกแบบให้คลาสมี “หน้าบ้าน” (public methods) ที่ชัดเจนและปลอดภัย ส่วน “หลังบ้าน” (_ attributes, logic ภายใน) ซ่อนไว้ คนใช้คลาสไม่ต้องรู้ว่าข้างในทำงานยังไง แค่เรียกเมท็อดที่เปิดให้

ประโยชน์:

  • แก้ logic ภายในได้โดยไม่กระทบโค้ดที่เรียกใช้
  • ข้อมูลอยู่ในสถานะที่ถูกต้องเสมอ เพราะทุกการเปลี่ยนแปลงผ่านการตรวจสอบ

ตัวอย่างรวม: คิวงาน

class TaskQueue:
    def __init__(self, max_size=5):
        self._tasks = []
        self._max_size = max_size

    def add(self, task):
        if len(self._tasks) >= self._max_size:
            raise ValueError("คิวเต็ม")
        self._tasks.append(task)

    def next(self):
        if not self._tasks:
            return None
        return self._tasks.pop(0)

    @property
    def is_empty(self):
        return len(self._tasks) == 0

    @property
    def size(self):
        return len(self._tasks)


q = TaskQueue(max_size=3)
q.add("ส่งอีเมล")
q.add("สำรองข้อมูล")
print(q.size)        # 2
print(q.next())      # ส่งอีเมล
print(q.is_empty)    # False

เช็คความเข้าใจก่อนข้ามบท

  • อธิบายได้ว่าทำไมการปล่อยให้แก้ attribute ได้ทุกทางอาจทำให้ข้อมูลผิดกฎ
  • ใช้ method หรือ @property เพื่อควบคุมการอ่านและเขียนค่าได้
  • ลองเพิ่ม validation ไม่ให้ยอดเงินหรือจำนวนคิวติดลบ

สรุป

  • Python ไม่มี private จริง ใช้ธรรมเนียมชื่อ: _x = ภายใน, __x = name mangling
  • ควบคุมการเปลี่ยนแปลงข้อมูลผ่านเมท็อดที่มีการตรวจสอบ ไม่ให้แก้ attribute ตรง ๆ
  • @property ทำให้เรียกเหมือน attribute แต่ยังคุมได้ — เป็นสไตล์ Python
  • ออกแบบให้ “หน้าบ้าน” ชัดเจน ปลอดภัย ส่วน “หลังบ้าน” ซ่อน

บทถัดไปว่าด้วยการสืบทอด (Inheritance) และ super()