Câu lệnh Match-Case trong Python

Câu lệnh match-case là một tính năng mới được giới thiệu trong Python 3.10, mang lại một cách tiếp cận mạnh mẽ và linh hoạt để xử lý các cấu trúc điều kiện phức tạp. Tính năng này tương tự như câu lệnh switch-case trong các ngôn ngữ lập trình khác như C, C++, và Java, nhưng với nhiều cải tiến và khả năng mở rộng hơn. Trong bài viết này, chúng ta sẽ tìm hiểu chi tiết về câu lệnh match-case, cách sử dụng nó, và các ví dụ minh họa cụ thể.

Tổng quan về câu lệnh Match-Case

Câu lệnh match-case cho phép bạn so sánh giá trị của một biểu thức với một loạt các mẫu (patterns) và thực thi khối mã tương ứng với mẫu khớp. Cú pháp cơ bản của câu lệnh match-case như sau:

match expression:
    case pattern1:
        # Code block for pattern1
    case pattern2:
        # Code block for pattern2
    ...
    case patternN:
        # Code block for patternN
    case _:
        # Default code block (optional)

Trong đó:

expression là biểu thức cần so sánh.
pattern1, pattern2, ..., patternN là các mẫu để so sánh với giá trị của expression.
case _ là khối mã mặc định được thực thi nếu không có mẫu nào khớp.

Ví dụ cơ bản về Match-Case

Hãy bắt đầu với một ví dụ đơn giản để minh họa cách sử dụng câu lệnh match-case:

def get_day_name(day_number):
    match day_number:
        case 0:
            return "Monday"
        case 1:
            return "Tuesday"
        case 2:
            return "Wednesday"
        case 3:
            return "Thursday"
        case 4:
            return "Friday"
        case 5:
            return "Saturday"
        case 6:
            return "Sunday"
        case _:
            return "Invalid day number"

print(get_day_name(3))  # Output: Thursday
print(get_day_name(6))  # Output: Sunday
print(get_day_name(7))  # Output: Invalid day number

Trong ví dụ này, hàm get_day_name nhận một số nguyên day_number và trả về tên của ngày tương ứng. Nếu day_number không nằm trong khoảng từ 0 đến 6, hàm sẽ trả về "Invalid day number".

Các trường hợp kết hợp trong Match-Case

Đôi khi, bạn có thể muốn thực hiện cùng một hành động cho nhiều mẫu khác nhau. Trong trường hợp này, bạn có thể kết hợp các mẫu bằng cách sử dụng toán tử | (hoặc):

def access_level(user_role):
    match user_role:
        case "admin" | "manager":
            return "Full access"
        case "guest":
            return "Limited access"
        case _:
            return "No access"

print(access_level("admin"))   # Output: Full access
print(access_level("guest"))   # Output: Limited access
print(access_level("unknown")) # Output: No access

Trong ví dụ này, nếu user_role là "admin" hoặc "manager", hàm access_level sẽ trả về "Full access". Nếu user_role là "guest", hàm sẽ trả về "Limited access". Nếu không, hàm sẽ trả về "No access".

Sử dụng danh sách làm đối số trong Match-Case

Câu lệnh match-case cũng hỗ trợ so sánh các cấu trúc dữ liệu phức tạp như danh sách. Dưới đây là một ví dụ về cách sử dụng danh sách làm đối số trong match-case:

def process_list(data):
    match data:
        case [x, y, z]:
            return f"List with three elements: {x}, {y}, {z}"
        case [x, y]:
            return f"List with two elements: {x}, {y}"
        case [x]:
            return f"List with one element: {x}"
        case []:
            return "Empty list"
        case _:
            return "Unknown structure"

print(process_list([1, 2, 3]))  # Output: List with three elements: 1, 2, 3
print(process_list([1, 2]))     # Output: List with two elements: 1, 2
print(process_list([1]))        # Output: List with one element: 1
print(process_list([]))         # Output: Empty list
print(process_list([1, 2, 3, 4])) # Output: Unknown structure

Trong ví dụ này, hàm process_list nhận một danh sách data và trả về chuỗi mô tả cấu trúc của danh sách đó. Nếu danh sách có ba phần tử, hàm sẽ trả về "List with three elements". Nếu danh sách có hai phần tử, hàm sẽ trả về "List with two elements", và tương tự cho các trường hợp khác.

Sử dụng "if" trong câu lệnh Case

Câu lệnh match-case cho phép bạn sử dụng điều kiện if trong các khối case để thực hiện các phép so sánh phức tạp hơn. Dưới đây là một ví dụ:

def calculate_interest(details):
    match details:
        case [amount, duration] if amount < 10000:
            return amount * 0.1 * duration
        case [amount, duration] if amount >= 10000:
            return amount * 0.15 * duration
        case _:
            return "Invalid details"

print(calculate_interest([5000, 5]))   # Output: 2500.0
print(calculate_interest([15000, 3]))  # Output: 6750.0
print(calculate_interest([10000, 2]))  # Output: 3000.0

Trong ví dụ này, hàm calculate_interest nhận một danh sách details chứa số tiền và thời gian. Nếu số tiền nhỏ hơn 10000, hàm sẽ tính lãi suất 10%. Nếu số tiền lớn hơn hoặc bằng 10000, hàm sẽ tính lãi suất 15%.

Sử dụng Match-Case với Từ điển

Câu lệnh match-case cũng có thể được sử dụng để so sánh các từ điển. Dưới đây là một ví dụ:

def process_dict(data):
    match data:
        case {"name": name, "age": age}:
            return f"Name: {name}, Age: {age}"
        case {"name": name}:
            return f"Name: {name}, Age: unknown"
        case _:
            return "Unknown structure"

print(process_dict({"name": "Alice", "age": 30}))  # Output: Name: Alice, Age: 30
print(process_dict({"name": "Bob"}))               # Output: Name: Bob, Age: unknown
print(process_dict({"age": 25}))                   # Output: Unknown structure

Trong ví dụ này, hàm process_dict nhận một từ điển data và trả về chuỗi mô tả cấu trúc của từ điển đó. Nếu từ điển chứa cả "name" và "age", hàm sẽ trả về "Name: {name}, Age: {age}". Nếu từ điển chỉ chứa "name", hàm sẽ trả về "Name: {name}, Age: unknown".

Sử dụng Match-Case với Lớp

Câu lệnh match-case cũng hỗ trợ so sánh các đối tượng lớp. Dưới đây là một ví dụ:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def process_person(person):
    match person:
        case Person(name, age):
            return f"Name: {name}, Age: {age}"
        case _:
            return "Unknown structure"

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(process_person(p1))  # Output: Name: Alice, Age: 30
print(process_person(p2))  # Output: Name: Bob, Age: 25
print(process_person("Unknown"))  # Output: Unknown structure

Trong ví dụ này, hàm process_person nhận một đối tượng person và trả về chuỗi mô tả cấu trúc của đối tượng đó. Nếu đối tượng là một instance của lớp Person, hàm sẽ trả về "Name: {name}, Age: {age}".

Kết luận

Câu lệnh match-case trong Python 3.10 mang lại một cách tiếp cận mạnh mẽ và linh hoạt để xử lý các cấu trúc điều kiện phức tạp. Nó cung cấp một cách viết mã ngắn gọn và dễ đọc hơn so với các câu lệnh if-elif-else truyền thống. Bằng cách sử dụng match-case, bạn có thể dễ dàng so sánh các giá trị, cấu trúc dữ liệu phức tạp, và đối tượng lớp, giúp mã của bạn trở nên rõ ràng và dễ bảo trì hơn.