Lập trình hướng đối tượng trong Python

1. class — cú pháp tạo class

Class trong Python được khai báo bằng từ khóa class, theo sau là tên class (convention PascalCase) và dấu hai chấm. Body của class là một namespace — chứa attribute và method. Một class rỗng nhất có thể chỉ cần một dòng với pass.

class User:
    pass

# Tạo instance — KHÔNG có new keyword
u = User()
print(type(u))   # <class '__main__.User'>
print(isinstance(u, User))  # True

# Có thể gán attribute động vào instance (giống JS)
u.name = "Anh"
print(u.name)   # 'Anh'

Vì class chỉ là namespace, có thể tham chiếu class như một giá trị bình thường: gán biến, truyền vào hàm, trả về từ hàm. "Everything is an object" — đây là một câu thường được trích từ cộng đồng Python; kể cả class cũng là object (instance của metaclass type).

class User:
    pass

print(type(User))         # <class 'type'> — class là instance của type
print(isinstance(User, type))  # True

# Truyền class như giá trị
factories = [User, dict, list]
instances = [f() for f in factories]
print(instances)        # [<User ...>, {}, []]

2. __init__ — constructor và self

__init__ là initializer được Python gọi ngay sau khi tạo instance. Tham số đầu tiên luôn là self — tham chiếu tới instance vừa tạo. self không phải từ khóa; nó chỉ là convention, nhưng tuyệt đối đừng đổi tên (vi phạm PEP 8 và làm code khó đọc).

class User:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def greet(self) -> str:
        return f"Xin chào, tôi là {self.name}"

u = User("Anh", 22)
print(u.greet())   # 'Xin chào, tôi là Anh'

__init__ không phải là người tạo ra object. Việc tạo instance thực ra do __new__ đảm nhiệm (rất hiếm khi cần ghi đè). __init__ chỉ khởi tạo state lên object đã có. Đó là lý do __init__ không có return (thực ra return được nhưng phải là None).

3. Instance attribute vs class attribute

Có hai chỗ để gán attribute:

• Instance attribute: self.x = ... trong method (thường ở __init__). Mỗi instance có bản sao riêng.
• Class attribute: khai báo trực tiếp trong body class, ngoài method. Một bản chia sẻ giữa mọi instance.

class User:
    species = "human"      # class attribute — share
    count = 0             # class attribute

    def __init__(self, name):
        self.name = name    # instance attribute — riêng từng instance
        User.count += 1     # cập nhật class attr qua tên class

a = User("Anh")
b = User("Bình")
print(a.species, b.species)   # human human — chia sẻ
print(User.count)              # 2
print(a.name, b.name)         # Anh Bình — riêng

# SAI
class Cart:
    items = []                  # class attr — chia sẻ!

    def add(self, x):
        self.items.append(x)   # mutate list chung

c1, c2 = Cart(), Cart()
c1.add("A")
print(c2.items)             # ['A'] — Cart() khác cũng thấy!

# ĐÚNG
class Cart:
    def __init__(self):
        self.items = []        # instance attr — list riêng

Khi đọc a.x, Python tra cứu theo thứ tự: instance dict → class dict → MRO của các lớp cha. Vì vậy class attribute hoạt động như fallback nếu instance không có. Một khi gán a.x = ..., giá trị mới được tạo trong instance dict và che lấp class attribute (không ảnh hưởng class).

4. Ba loại method — instance / class / static

Python phân biệt 3 loại method qua decorator. Sự khác biệt nằm ở tham số đầu tiên tự pass:

from __future__ import annotations
from datetime import date

class User:
    def __init__(self, name: str, birth_year: int):
        self.name = name
        self.birth_year = birth_year

    # Instance method — dùng self
    def age(self) -> int:
        return date.today().year - self.birth_year

    # Class method — alternative constructor
    @classmethod
    def from_dict(cls, data: dict) -> User:
        return cls(name=data["name"], birth_year=data["birth_year"])

    # Static method — utility
    @staticmethod
    def is_adult_age(age: int) -> bool:
        return age >= 18

u = User.from_dict({"name": "Anh", "birth_year": 2003})
print(u.age())                  # 23
print(User.is_adult_age(17))      # False

5. Inheritance — class Admin(User)

Để kế thừa, đặt class cha trong dấu ngoặc: class Admin(User):. Subclass tự động thừa hưởng mọi method và attribute của parent. Override = định nghĩa lại method cùng tên trong subclass. Để gọi implementation của cha (ví dụ trong __init__ của subclass), dùng super().

class User:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hi, {self.name}"

class Admin(User):
    def __init__(self, name, level):
        super().__init__(name)   # chain init lên cha
        self.level = level

    def greet(self):                 # override
        base = super().greet()        # gọi version của cha
        return f"{base} [admin lv {self.level}]"

a = Admin("Anh", 2)
print(a.greet())   # 'Hi, Anh [admin lv 2]'
print(isinstance(a, User))  # True

Không cần truyền self hay class hiện tại vào super() — Python tự suy ra từ context. Trong Python 2, phải viết super(Admin, self).__init__(name), nhưng Python 3 đã đơn giản hóa.

6. Multiple inheritance và MRO C3

Python cho phép kế thừa nhiều class: class C(A, B):. Khi tra cứu method, Python đi theo MRO (Method Resolution Order) — thứ tự duyệt class. Thuật toán dùng là C3 linearization, đảm bảo: (a) class con trước class cha; (b) thứ tự khai báo bên trái sang phải; (c) tính nhất quán (monotonic).

class A:
    def who(self): return "A"

class B:
    def who(self): return "B"

class C(A, B):
    pass

print(C().who())          # 'A' — A đứng trước B trong khai báo
print([k.__name__ for k in C.__mro__])
# ['C', 'A', 'B', 'object']

MRO trở nên thú vị (và đôi khi bối rối) với diamond inheritance — hai class cha chia sẻ một ông nội. C3 đảm bảo class ông nội chỉ xuất hiện một lần ở cuối.

class Animal:
    def describe(self): return "animal"

class Swimmer(Animal):
    def describe(self): return "swimmer-" + super().describe()

class Flyer(Animal):
    def describe(self): return "flyer-" + super().describe()

class Duck(Swimmer, Flyer):
    pass

print(Duck.__mro__)
# (Duck, Swimmer, Flyer, Animal, object)
print(Duck().describe())
# 'swimmer-flyer-animal' — super() đi đúng theo MRO

Nếu C3 không tìm được thứ tự nhất quán, Python từ chối khai báo class và ném TypeError: Cannot create a consistent method resolution order. Trường hợp đó thường do thứ tự base class mâu thuẫn — cần đổi lại thứ tự khai báo.

7. Dunder method — "double underscore" magic

Dunder method (đọc là "dander", viết tắt "double underscore") là các method tên kiểu __xxx__ mà Python tự gọi khi gặp syntax tương ứng. Override dunder = cho phép class của bạn hòa nhập với syntax ngôn ngữ: +, ==, len(), for ... in, print()...

7.1. __repr__ vs __str__

Convention quan trọng: __repr__ dành cho developer — nên hiển thị chi tiết, tốt nhất là một biểu thức Python hợp lệ có thể eval() lại thành object tương đương. __str__ dành cho người dùng cuối — gọn, đẹp. Nếu chỉ định nghĩa __repr__, Python tự lấy nó làm __str__.

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

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

    def __str__(self):
        return f"({self.x}, {self.y})"

p = Point(1, 2)
print(repr(p))   # Point(x=1, y=2)
print(str(p))    # (1, 2)
print(p)         # (1, 2) — print gọi __str__

7.2. __eq__ và __hash__ — luôn đi cùng nhau

Mặc định, hai instance khác nhau không bằng nhau dù state giống hệt — Python so sánh bằng id (địa chỉ object). Để so sánh theo giá trị, override __eq__. Nhưng có một quy tắc bắt buộc:

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))   # tuple đã hashable

a, b = Point(1, 2), Point(1, 2)
print(a == b)         # True
print({a, b})         # {Point(x=1, y=2)} — set giữ 1 phần tử

Trả về NotImplemented (không phải NotImplementedError!) trong __eq__ khi không biết cách so sánh với kiểu khác — Python sẽ thử other.__eq__(self), rất quan trọng để hỗ trợ subclass và so sánh hai chiều.

7.3. __iter__, __contains__, __getitem__

class Deck:
    def __init__(self):
        self.cards = ["A♠", "K♠", "Q♠", "J♠"]

    def __len__(self):
        return len(self.cards)

    def __getitem__(self, i):
        return self.cards[i]

    def __contains__(self, card):
        return card in self.cards

d = Deck()
print(len(d))            # 4
print(d[0])             # 'A♠'
print("A♠" in d)        # True
for c in d:                # for-loop tự dùng __getitem__ nếu không có __iter__
    print(c)

7.4. __call__ — instance như là hàm

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, x):
        return x * self.factor

double = Multiplier(2)
print(double(5))       # 10 — instance gọi như hàm
print(callable(double)) # True

__call__ rất hữu ích cho stateful callable — như decorator có config, hàm tính có cache, partial function. Đó cũng là lý do functools.partial trả về một object có __call__.

8. @property — method behave như attribute

@property cho phép truy cập một method không cần dấu ngoặc () — y hệt attribute. Dùng cho computed value (giá trị tính từ field khác) và validation (kiểm tra khi gán).

class Circle:
    def __init__(self, radius):
        self.radius = radius   # dùng setter nếu có

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("radius phải >= 0")
        self._radius = value

    @property
    def area(self):
        from math import pi
        return pi * self._radius ** 2

c = Circle(3)
print(c.radius)   # 3 — không có ()
print(c.area)     # 28.274... — computed
c.radius = 5      # setter chạy validation
# c.radius = -1  → ValueError

Nếu chỉ có @property không có setter — attribute trở thành read-only. Có thể thêm @xxx.deleter để custom del obj.xxx.

9. @dataclass — giảm boilerplate

Mỗi khi viết class để giữ dữ liệu, ta phải gõ lại __init__, __repr__, __eq__ giống nhau. Python 3.7 đưa ra @dataclass — decorator generate những method này tự động dựa trên type annotation của class.

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    email: str = ""         # default value

u1 = User("Anh", 22)
u2 = User("Anh", 22)
print(u1)               # User(name='Anh', age=22, email='')
print(u1 == u2)         # True — __eq__ auto theo field

Mặc định @dataclass tạo: __init__, __repr__, __eq__. Các tham số đáng nhớ:

from dataclasses import dataclass

@dataclass(frozen=True, slots=True)
class Point:
    x: float
    y: float

p = Point(1.0, 2.0)
print({p})              # {Point(x=1.0, y=2.0)} — hashable vì frozen
# p.x = 9  →  FrozenInstanceError
# p.z = 0  →  AttributeError (slots không cho thêm attr)

from dataclasses import dataclass, field

@dataclass
class Cart:
    items: list[str] = field(default_factory=list)
    discount: float = 0.0

10. Abstract Base Class — abc

Khi muốn ép subclass phải implement một method nhất định, dùng abc.ABC + decorator @abstractmethod. Class có @abstractmethod không thể tạo instance trực tiếp.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

# Shape()  →  TypeError: Can't instantiate abstract class Shape
print(Square(3).area())   # 9

ABC tương đương interface ở các ngôn ngữ khác — nhưng vẫn được implement bằng class, nên có thể chứa method có sẵn (concrete method) lẫn @abstractmethod. Đó là lý do thường được gọi là "abstract base class" thay vì "interface": vừa làm khung vừa cung cấp logic chung.

11. typing.Protocol — structural typing

PEP 544 (Python 3.8+) đưa ra typing.Protocol — cho phép khai báo "type theo cấu trúc": "bất kỳ class nào có method X, Y với signature đúng đều coi là SupportsX". Không cần inherit — đây là structural typing, giống interface trong TypeScript / Go.

from typing import Protocol

class SupportsArea(Protocol):
    def area(self) -> float: ...

class Box:                       # không inherit SupportsArea
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self) -> float:
        return self.w * self.h

def describe(s: SupportsArea) -> str:
    return f"area = {s.area()}"

print(describe(Box(2, 3)))   # 'area = 6' — mypy chấp nhận

12. Duck typing — "Nếu kêu quack quack thì là vịt"

Câu thành ngữ nguyên gốc: "If it walks like a duck and it quacks like a duck, then it must be a duck." Áp dụng vào Python: ta thường không quan tâm đối tượng là class gì, chỉ quan tâm nó có method/attribute cần thiết hay không. Đó là duck typing.

def play_sound(animal):
    # Không quan tâm animal là class gì, chỉ cần có .speak()
    return animal.speak()

class Duck:
    def speak(self): return "quack"

class Robot:
    def speak(self): return "beep"

print(play_sound(Duck()))    # 'quack'
print(play_sound(Robot()))   # 'beep' — Robot không phải Duck nhưng OK

# LBYL — không "Pythonic"
if hasattr(obj, "speak") and callable(obj.speak):
    obj.speak()

# EAFP — Pythonic
try:
    obj.speak()
except AttributeError:
    handle_no_speak()

Bài tập

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age})"
    def __eq__(self, other):
        if not isinstance(other, User): return NotImplemented
        return (self.name, self.age) == (other.name, other.age)
    def __hash__(self):
        return hash((self.name, self.age))

from dataclasses import dataclass

@dataclass
class Product(Serializable):
    sku: str
    name: str
    price: float

print(Product("P001", "Book", 19.99).to_json())
# {"sku": "P001", "name": "Book", "price": 19.99}

Quiz

Tổng kết

Sau chương 5, bạn đã master:

• Class & __init__: cú pháp, self, instance vs class attribute, bẫy mutable.
• Ba loại method: instance, @classmethod (alternative constructor), @staticmethod (namespace utility).
• Inheritance: class B(A), override, super().__init__ chain.
• Multiple inheritance & MRO: C3 linearization, __mro__, diamond.
• Dunder methods: __repr__/__str__, __eq__/__hash__ luôn đi đôi, __len__, __iter__, __contains__, __getitem__, __call__.
• @property: computed value, validation, read-only attribute.
• @dataclass: frozen, slots, field(default_factory=...).
• ABC vs Protocol: nominal vs structural typing; duck typing & EAFP làm tinh thần cốt lõi.

Kết nối

• Chương 6 (Iterators & Generators) — đào sâu __iter__/__next__, iterable protocol và yield để tạo class lazy.
• Chương 7 (Decorators & Context Managers) — @functools.wraps bảo toàn metadata khi decorator class method; __enter__/__exit__ cho with statement.
• Chương 9 (Typing & Static Analysis) — Protocol đi với Generic, TypedDict, type narrowing qua isinstance; PEP 695 Generic syntax (3.12+).
• JavaScript Chương 4 (Objects, Prototypes & Classes) — đối chiếu mô hình prototype của JS với class-as-namespace của Python.
• Dart Chương 4 (Class Modifiers) — Dart 3 đưa ra sealed/base/final/interface class, đối lập với phong cách tự do của Python (không có private thật sự, không có sealed).