Classes

Classes: แนวคิดที่คุ้นเคย แต่ self ต้องเขียนชัดเจน

class ของ Python ให้ความรู้สึกใกล้เคียง class ของ TypeScript มาก มีทั้ง class, constructor, method และ inheritance ครบ จุดที่ TS developer มักสะดุดมีอยู่สามข้อ:

constructor ชื่อ __init__ ไม่ใช่ constructor
instance method ทุกตัวต้องประกาศ self เป็นพารามิเตอร์แรก เพราะ Python ไม่ฉีด this ให้โดยปริยาย
class attribute ที่แชร์กันทุก instance ประกาศไว้ที่ระดับ class body ไม่ใช่ใน constructor

การนิยามคลาส

// TypeScript
class Animal {
  static kingdom: string = "Animalia";  // class attribute

  name: string;
  sound: string;

  constructor(name: string, sound: string) {
    this.name = name;
    this.sound = sound;
  }

  speak(): string {
    return `${this.name} says ${this.sound}`;
  }

  toString(): string {
    return `Animal(name=${this.name})`;
  }
}

const cat = new Animal("Cat", "meow");
console.log(cat.speak());
console.log(Animal.kingdom);

# Python
class Animal:
    kingdom: str = "Animalia"  # class attribute (shared)

    def __init__(self, name: str, sound: str) -> None:
        self.name = name        # instance attributes
        self.sound = sound

    def speak(self) -> str:
        return f"{self.name} says {self.sound}"

    def __repr__(self) -> str:
        return f"Animal(name={self.name!r})"

cat = Animal("Cat", "meow")   # no "new" keyword
print(cat.speak())
print(Animal.kingdom)

Inheritance

Python ใช้ syntax แบบ single-inheritance เหมือน TypeScript super().__init__(...) แมปกับ super() ใน TS

// TypeScript
class Dog extends Animal {
  constructor(name: string) {
    super(name, "woof");
  }

  fetch(item: string): string {
    return `${this.name} fetches the ${item}!`;
  }
}

const rex = new Dog("Rex");
console.log(rex.speak());      // Rex says woof
console.log(rex.fetch("ball")); // Rex fetches the ball!
console.log(rex instanceof Animal); // true

# Python
class Dog(Animal):
    def __init__(self, name: str) -> None:
        super().__init__(name, "woof")

    def fetch(self, item: str) -> str:
        return f"{self.name} fetches the {item}!"

rex = Dog("Rex")
print(rex.speak())          # Rex says woof
print(rex.fetch("ball"))    # Rex fetches the ball!
print(isinstance(rex, Animal))  # True

Class methods และ static methods

// TypeScript
class Counter {
  private static count: number = 0;

  static increment(): void {
    Counter.count++;
  }

  static getCount(): number {
    return Counter.count;
  }
}

Counter.increment();
Counter.increment();
console.log(Counter.getCount());  // 2

# Python
class Counter:
    _count: int = 0  # underscore = "private" by convention

    @classmethod
    def increment(cls) -> None:
        cls._count += 1

    @classmethod
    def get_count(cls) -> int:
        return cls._count

Counter.increment()
Counter.increment()
print(Counter.get_count())   # 2

ลองเล่นดู

Open in an online REPL

class Animal:
    kingdom: str = "Animalia"

    def __init__(self, name: str, sound: str) -> None:
        self.name = name
        self.sound = sound

    def speak(self) -> str:
        return f"{self.name} says {self.sound}"

    def __repr__(self) -> str:
        return f"Animal(name={self.name!r})"


class Dog(Animal):
    def __init__(self, name: str) -> None:
        super().__init__(name, "woof")

    def fetch(self, item: str) -> str:
        return f"{self.name} fetches the {item}!"


rex = Dog("Rex")
print(rex.speak())
print(rex.fetch("ball"))
print(f"Is Animal? {isinstance(rex, Animal)}")
print(f"Kingdom: {Animal.kingdom}")
print(repr(rex))

🟦 self ต้องเขียนชัดเจน, __init__ คือ constructor, dunders คือ protocol

ใน TypeScript runtime ฉีด this ให้เอง คุณไม่เคยต้องประกาศ ส่วนใน Python self เป็นพารามิเตอร์จริงที่ต้องเขียนเป็น argument ตัวแรกของ instance method ทุกตัว ชื่อ self เป็นแค่ธรรมเนียม จะตั้งชื่ออื่นก็ได้ แต่ทั้งวงการใช้ self กันหมด

__init__ (อ่านว่า “dunder init”) เป็น initialiser ไม่ใช่ constructor เพราะตอนที่ __init__ เริ่มทำงาน object มีตัวตนอยู่แล้ว หน้าที่ของ __init__ คือตั้งค่าสถานะเริ่มต้นให้ object นั้น

Python ใช้ dunder methods (ขีดล่างสองตัว เช่น __repr__, __str__, __len__, __eq__) เป็นจุดเสียบเข้ากับพฤติกรรม built-in เทียบได้กับ interface ฝั่ง TypeScript อย่าง toString() หรือ Symbol.iterator:

class Point:
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y

    def __repr__(self) -> str:
        return f"Point({self.x}, {self.y})"

    def __add__(self, other: "Point") -> "Point":
        return Point(self.x + other.x, self.y + other.y)

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

a = Point(1, 2)
b = Point(3, 4)
print(a + b)          # Point(4, 6)
print(a == Point(1, 2))  # True