Trong Python, các phương thức có thể được phân loại dựa trên cách chúng liên kết với lớp hoặc đối tượng. Hiểu rõ sự khác biệt giữa phương thức bind (bound methods) và phương thức non-bind (unbound methods) là rất quan trọng để viết mã Python hiệu quả và dễ bảo trì.

Phương thức Bind (Bound Methods)

Phương thức bind là những phương thức được liên kết với một đối tượng (instance) cụ thể của lớp. Khi bạn gọi một phương thức bind thông qua một đối tượng, đối tượng đó sẽ tự động được truyền vào phương thức dưới dạng tham số đầu tiên (thường được đặt tên là self).

1. Phương thức thông thường (Instance Methods)

Đây là loại phương thức bind phổ biến nhất. Chúng được định nghĩa trực tiếp trong lớp mà không có bất kỳ decorator nào. Chúng có thể truy cập và sửa đổi trạng thái của đối tượng thông qua tham số self.

class Car:
    def __init__(self, model):
        self.model = model

    def drive(self, distance):
        # Phương thức này truy cập thuộc tính 'model' của đối tượng
        print(f"{self.model} đang di chuyển quãng đường {distance} km.")

# Sử dụng phương thức bind thông qua đối tượng
my_car = Car("Sedan")
my_car.drive(100)
# Output: Sedan đang di chuyển quãng đường 100 km.

# Khi gọi thông qua lớp, chúng ta cần truyền đối tượng vào tham số đầu tiên
Car.drive(my_car, 50)
# Output: Sedan đang di chuyển quãng đường 50 km.

2. Phương thức lớp (Class Methods) với decorator @classmethod

Phương thức lớp được bind với lớp thay vì một đối tượng cụ thể. Chúng nhận lớp làm tham số đầu tiên (thường được đặt tên là cls). Chúng hữu ích khi bạn muốn thực hiện các thao tác liên quan đến lớp, chẳng hạn như tạo đối tượng theo các cách khác nhau hoặc truy cập các thuộc tính của lớp.

class Employee:
    company_name = "TechCorp"

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

    @classmethod
    def create_employee(cls, name):
        # Phương thức lớp có thể truy cập thuộc tính của lớp
        print(f"Đang tạo nhân viên cho công ty: {cls.company_name}")
        return cls(name)

    def display_info(self):
        print(f"Nhân viên: {self.name}, Công ty: {Employee.company_name}")

# Gọi phương thức lớp thông qua lớp
emp1 = Employee.create_employee("Alice")
emp1.display_info()
# Output:
# Đang tạo nhân viên cho công ty: TechCorp
# Nhân viên: Alice, Công ty: TechCorp

# Phương thức lớp cũng có thể gọi thông qua đối tượng, nhưng tham số 'cls' vẫn là lớp
emp2 = Employee("Bob")
emp2.create_employee("Charlie") # Vẫn trả về đối tượng Employee mới
# Output: Đang tạo nhân viên cho công ty: TechCorp

Phương thức Không Bind (Non-Bind Methods)

Phương thức không bind, hay còn gọi là phương thức tĩnh (static methods), không được liên kết trực tiếp với lớp hay đối tượng. Chúng hoạt động giống như các hàm thông thường được định nghĩa bên trong một lớp. Chúng không nhận tham số self hoặc cls một cách tự động.

1. Phương thức tĩnh (Static Methods) với decorator @staticmethod

Phương thức tĩnh thường được sử dụng khi một hàm logic liên quan đến lớp nhưng không cần truy cập hoặc sửa đổi trạng thái của lớp hay đối tượng. Chúng có thể được gọi thông qua cả lớp và đối tượng.

class Calculator:
    @staticmethod
    def add(x, y):
        # Không truy cập self hoặc cls
        return x + y

    @staticmethod
    def multiply(x, y):
        return x * y

# Gọi phương thức tĩnh thông qua lớp
sum_result = Calculator.add(10, 5)
print(f"Kết quả cộng: {sum_result}")
# Output: Kết quả cộng: 15

# Gọi phương thức tĩnh thông qua đối tượng (ít phổ biến hơn)
my_calculator = Calculator()
product_result = my_calculator.multiply(10, 5)
print(f"Kết quả nhân: {product_result}")
# Output: Kết quả nhân: 50

Sự khác biệt chính và Trường hợp sử dụng

• Phương thức Bind (Instance Methods): Liên kết với đối tượng. Cần self. Sử dụng khi cần truy cập hoặc sửa đổi thuộc tính của đối tượng.
• Phương thức Bind (Class Methods): Liên kết với lớp. Cần cls. Sử dụng cho các factory methods, hoặc khi cần thao tác với thuộc tính cấp lớp.
• Phương thức Không Bind (Static Methods): Không liên kết với lớp hay đối tượng. Không nhận self hoặc cls tự động. Sử dụng cho các hàm tiện ích liên quan đến lớp nhưng không phụ thuộc vào trạng thái của lớp hay đối tượng.

Ví dụ về các trường hợp sử dụng thực tế

1. Phương thức lớp - Factory Method

Tạo đối tượng với các cấu hình mặc định.

import datetime

class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email

    @classmethod
    def from_email(cls, email):
        # Tạo username dựa trên phần đầu của email
        username = email.split('@')[0]
        return cls(username, email)

    @classmethod
    def today(cls, username):
        # Tạo người dùng với ngày đăng ký hôm nay (ví dụ minh họa, không có thuộc tính ngày trong lớp)
        print(f"Đang tạo người dùng {username} với ngày hiện tại.")
        return cls(username, f"{username}@example.com")

user1 = User.from_email("john.doe@example.com")
print(f"User 1: {user1.username}, {user1.email}")
# Output: User 1: john.doe, john.doe@example.com

user2 = User.today("jane.smith")
print(f"User 2: {user2.username}, {user2.email}")
# Output:
# Đang tạo người dùng jane.smith với ngày hiện tại.
# User 2: jane.smith, jane.smith@example.com

2. Phương thức tĩnh - Lớp tiện ích

Khi bạn có một tập hợp các hàm tiện ích không yêu cầu bất kỳ trạng thái nào.

import math

class MathUtils:
    @staticmethod
    def circle_area(radius):
        return math.pi * radius**2

    @staticmethod
    def factorial(n):
        if n == 0:
            return 1
        else:
            return n * MathUtils.factorial(n-1)

area = MathUtils.circle_area(5)
print(f"Diện tích hình tròn bán kính 5: {area:.2f}")
# Output: Diện tích hình tròn bán kính 5: 78.54

fact = MathUtils.factorial(5)
print(f"Giai thừa của 5: {fact}")
# Output: Giai thừa của 5: 120

Mỗi loại phương thức phục vụ một mục đích riêng biệt trong thiết kế hướng đối tượng, giúp tổ chức mã nguồn một cách rõ ràng và hiệu quả.