Metaclasses & Descriptors

ไม่มีคู่เทียบใน TypeScript — และนั่นคือประเด็น

descriptor กับ metaclass คือสองฟีเจอร์ระดับ runtime ที่ทรงพลังที่สุดของ Python ฝั่ง TypeScript มี decorator อยู่ (stage-3, ยัง experimental) แต่ทำได้จำกัดกว่ามาก

descriptor protocol และระบบ metaclass ของ Python ทำงานในชั้นที่ลึกกว่านั้น คือเข้าไปคุมว่าการเข้าถึง attribute และการสร้าง class เกิดขึ้นอย่างไรตอน runtime เข้าใจสองเรื่องนี้แล้วคุณจะเห็นภาพทันทีว่า @property, @dataclass และ ORM อย่าง SQLAlchemy ทำงานเบื้องหลังอย่างไร

Descriptors: การควบคุมการเข้าถึง attribute

descriptor คือออบเจ็กต์ใดก็ตามที่กำหนด __get__, __set__, หรือ __delete__ เมื่อ descriptor instance ถูก assign เป็น class attribute Python จะเรียก methods เหล่านี้แทนการ lookup ใน dictionary ทุกครั้งที่คุณเข้าถึง attribute บน instance

// TypeScript — closest analogy: getter/setter
class Temperature {
  private _celsius: number;

  constructor(celsius: number) {
    this._celsius = celsius;
  }

  get fahrenheit(): number {
    return this._celsius * 9/5 + 32;
  }

  set fahrenheit(value: number) {
    this._celsius = (value - 32) * 5/9;
  }
}

const t = new Temperature(100);
console.log(t.fahrenheit);  // 212
t.fahrenheit = 32;
console.log(t.fahrenheit);  // 32

# Python — descriptor protocol (reusable across classes)
class Validated:
    """Descriptor: ensures field is numeric."""
    def __set_name__(self, owner, name):
        self._name = name  # เรียกตอน class creation

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self   # class-level access
        return getattr(obj, f"_{self._name}", None)

    def __set__(self, obj, value):
        if not isinstance(value, (int, float)):
            raise TypeError(
                f"{self._name} must be numeric, "
                f"got {type(value).__name__}"
            )
        setattr(obj, f"_{self._name}", value)

class Product:
    price = Validated()      # descriptor instance เป็น class attr
    quantity = Validated()

    def __init__(self, price: float, quantity: int) -> None:
        self.price = price
        self.quantity = quantity

    def total(self) -> float:
        return self.price * self.quantity

item = Product(9.99, 3)
print(item.total())    # 29.97
item.price = "free"    # TypeError: price must be numeric

ข้อสังเกตสำคัญ: descriptor Validated สามารถ reuse กับคลาสต่างๆ และ attributes ต่างๆ ได้จำนวนมาก getter/setter ของ TypeScript เป็นแบบ per-class และ per-property — คุณไม่สามารถแชร์ definition เดียวได้

set_name: descriptor self-registration

Python เรียก __set_name__ ตอนสร้าง class (จังหวะที่ class body รัน) ทำให้ descriptor รู้ชื่อ attribute ที่ตัวเองถูก assign ไปให้ นี่คือเหตุผลที่คุณไม่ต้องเขียน price = Validated("price") เพราะ Python ใส่ชื่อให้เอง

ลองเล่น — descriptor demo

Open in an online REPL

class Validated:
    def __set_name__(self, owner, name):
        self._name = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, f"_{self._name}", None)

    def __set__(self, obj, value):
        if not isinstance(value, (int, float)):
            raise TypeError(
                f"{self._name} must be numeric, got {type(value).__name__}"
            )
        setattr(obj, f"_{self._name}", value)

class Product:
    price = Validated()
    quantity = Validated()

    def __init__(self, price: float, quantity: int) -> None:
        self.price = price
        self.quantity = quantity

    def total(self) -> float:
        return self.price * self.quantity

item = Product(9.99, 3)
print(f"Total: {item.total()}")

item.price = 19.99
print(f"Updated total: {item.total()}")

try:
    item.price = "free"
except TypeError as e:
    print(f"Caught: {e}")

🟦 Metaclasses: คลาสที่สร้างคลาส

ใน Python ทุกอย่างเป็น object รวมถึง class ด้วย พูดให้ตรงกว่านั้นคือ class เป็น instance ของ metaclass โดยมี type เป็น metaclass เริ่มต้น พอ Python เจอ statement class Foo: ... ก็จะเรียก type('Foo', bases, namespace) เพื่อสร้าง class object ขึ้นมา

คุณสามารถแทนที่ type ด้วย metaclass ของคุณเองโดยส่ง metaclass=MyMeta ซึ่งช่วยให้คุณ intercept และแก้ไขการสร้างคลาส — เพิ่มเมธอด, enforce conventions, หรือ implement patterns เช่น singleton

class SingletonMeta(type):
    """Metaclass ที่ ensure มีแค่หนึ่ง instance ต่อคลาส"""
    _instances: dict = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class AppConfig(metaclass=SingletonMeta):
    def __init__(self):
        self.debug = False

a = AppConfig()
b = AppConfig()
print(a is b)   # True — same object

Metaclasses ปรากฏที่ไหนในโลกจริง?

ORMs: SQLAlchemy ใช้ metaclass เพื่อประมวลผล Column() annotations และลงทะเบียน models
Django: models.Model ใช้ metaclass เพื่อสร้าง database schemas จาก class bodies
@dataclass: ไม่ใช่ metaclass แต่เป็น class decorator ที่ไปอ่าน __annotations__ แล้วสร้าง __init__ ให้ ซึ่งใกล้เคียงกับสิ่งที่ metaclass ทำ

กฎง่ายๆ: ถ้าคุณต้องการแก้ไขทุกคลาสในลำดับชั้นตอน creation time นั่นคือ use case ของ metaclass สำหรับทุกอย่างอื่น class decorator หรือ descriptor เรียบง่ายกว่าและอ่านง่ายกว่า