OpenDev

A Developer's Little Corner
Random News

Match-Case trong Python: Cú pháp, cách sử dụng và ví dụ thực tế

OpenDev066 mins
python match case

Khi lập trình Python, if-elif-else gần như là một trong những cấu trúc đầu tiên mà chúng ta làm quen khi học về câu lệnh điều kiện. Với những bài toán đơn giản, if-elif-else hoạt động rất tốt. Tuy nhiên, khi chương trình phải xử lý nhiều trường hợp khác nhau, đặc biệt là khi cần kiểm tra cả cấu trúc của dữ liệu, đoạn code có thể trở nên dài và khó theo dõi.

Đó cũng là lý do match-case được giới thiệu trong Python 3.10.

Nếu chỉ nhìn qua, match-case khá giống với cấu trúc switch-case thường thấy trong nhiều ngôn ngữ lập trình khác. Nhưng thực tế, khả năng của match-case trong Python rộng hơn nhiều. Nó không chỉ kiểm tra một giá trị có bằng một giá trị khác hay không, mà còn có thể pattern matching với tuple, list, dictionary, object…

Trong bài viết này, chúng ta sẽ cùng tìm hiểu Match-Case trong Python từ những khái niệm cơ bản nhất đến các ví dụ thực tế. Mục tiêu không phải là biến mọi câu lệnh if-elif thành match-case, mà quan trọng hơn là hiểu khi nào nên sử dụng công cụ này và sử dụng như thế nào cho hợp lý.

1. Match-Case trong Python là gì?

1.1. Khái niệm Match-Case

match-case là một cấu trúc dùng để so khớp (matching) một giá trị với một hoặc nhiều pattern.

Cấu trúc này được Python giới thiệu từ phiên bản 3.10, nằm trong tính năng có tên Structural Pattern Matching.

Về cách hiểu đơn giản, chúng ta có thể hình dung:

  • match nhận dữ liệu cần kiểm tra.
  • case mô tả từng trường hợp mà chúng ta muốn xử lý.
  • Python lần lượt kiểm tra các case theo thứ tự từ trên xuống.
  • Khi tìm thấy pattern phù hợp, khối lệnh tương ứng sẽ được thực thi.

Ví dụ:

day = 2

match day:
    case 1:
        print("Thứ Hai")
    case 2:
        print("Thứ Ba")
    case 3:
        print("Thứ Tư")
    case _:
        print("Ngày khác")

Ở đây, Python lấy giá trị day là 2 và lần lượt so sánh với các pattern trong từng case. Khi gặp case 2, Python thực hiện:

Thứ Ba

Sau khi một case phù hợp được chọn, Python không tiếp tục thực hiện các case phía dưới.

1.2. Match-Case xuất hiện từ phiên bản Python nào?

match-case chính thức được đưa vào Python 3.10.

Điều này có nghĩa là nếu đang sử dụng Python 3.9 hoặc cũ hơn, bạn không thể sử dụng cú pháp này.

Có thể kiểm tra phiên bản Python bằng lệnh:

python --version

Hoặc:

python3 --version

Ví dụ kết quả:

Python 3.12.4

Như vậy môi trường này hoàn toàn có thể sử dụng match-case.

Đây là một chi tiết khá nhỏ nhưng rất quan trọng khi làm dự án thực tế. Nếu code chạy trên máy cá nhân với Python 3.12 nhưng môi trường production vẫn sử dụng Python 3.9, đoạn code chứa match-case sẽ không thể chạy.

1.3. Vì sao Python cần Match-Case?

Trước Python 3.10, khi muốn xử lý nhiều trường hợp, chúng ta thường sử dụng if-elif-else.

Ví dụ:

command = "start"

if command == "start":
    print("Khởi động")
elif command == "stop":
    print("Dừng")
elif command == "restart":
    print("Khởi động lại")
else:
    print("Lệnh không hợp lệ")

Đoạn code trên hoàn toàn hợp lệ và không có vấn đề gì.

Tuy nhiên, khi số lượng trường hợp tăng lên, chuỗi if-elif có thể trở nên dài. match-case cung cấp một cách biểu diễn khác, đặc biệt hữu ích khi bài toán có nhiều pattern rõ ràng hoặc cần kiểm tra cấu trúc dữ liệu.

Đây chính là điểm mà match-case bắt đầu trở nên thú vị.

2. Cú pháp cơ bản của Match-Case trong Python

2.1. Cấu trúc match-case

Cú pháp tổng quát:

match expression:
    case pattern_1:
        # code
    case pattern_2:
        # code
    case _:
        # code mặc định

Trong đó:

  • expression: biểu thức hoặc giá trị cần kiểm tra.
  • case: khai báo một trường hợp.
  • pattern: mẫu mà dữ liệu cần khớp.
  • _: pattern mặc định, thường dùng để xử lý trường hợp không khớp.

Ví dụ đơn giản:

status = 200

match status:
    case 200:
        print("Thành công")
    case 404:
        print("Không tìm thấy")
    case 500:
        print("Lỗi máy chủ")
    case _:
        print("Không xác định")

Điểm đáng chú ý là match không giống một vòng lặp. Nó thực hiện việc lựa chọn một case phù hợp dựa trên pattern.

2.2. Ví dụ Match-Case đơn giản

Hãy thử với một chương trình xác định thứ trong tuần:

day = 5

match day:
    case 1:
        print("Thứ Hai")
    case 2:
        print("Thứ Ba")
    case 3:
        print("Thứ Tư")
    case 4:
        print("Thứ Năm")
    case 5:
        print("Thứ Sáu")
    case 6:
        print("Thứ Bảy")
    case 7:
        print("Chủ Nhật")
    case _:
        print("Ngày không hợp lệ")

Với day = 5, chương trình sẽ in:

Thứ Sáu

Cách viết này khá trực quan. Người đọc có thể nhanh chóng nhìn vào danh sách case để biết chương trình đang xử lý những giá trị nào.

2.3. case _ có vai trò gì?

Trong match-case, _ là một wildcard pattern. Nó có thể khớp với bất kỳ giá trị nào mà các pattern trước đó không khớp.

Có thể xem nó tương tự vai trò của else trong một cấu trúc if-else, nhưng về mặt kỹ thuật, _ là một pattern chứ không phải một câu lệnh else.

Ví dụ:

color = "yellow"

match color:
    case "red":
        print("Màu đỏ")
    case "blue":
        print("Màu xanh")
    case "green":
        print("Màu xanh lá")
    case _:
        print("Màu khác")

Kết quả:

Màu khác

Thông thường, case _ nên đặt ở cuối. Nếu một pattern có khả năng khớp mọi giá trị được đặt trước các pattern cụ thể, những case phía sau có thể trở nên không thể tiếp cận.

3. Cách sử dụng Match-Case trong Python

Đây là phần quan trọng nhất khi học match-case. Thay vì chỉ xem nó như một phiên bản khác của switch-case, chúng ta sẽ thử nhìn vào những khả năng khiến tính năng này thực sự khác biệt.

3.1. Match với số

Trường hợp cơ bản nhất là match một giá trị số.

Ví dụ xử lý HTTP Status Code:

status = 200

match status:
    case 200:
        print("OK")
    case 404:
        print("Not Found")
    case 500:
        print("Server Error")
    case _:
        print("Unknown status")

Nếu status bằng 200, chương trình sẽ thực hiện case 200.

Cách này khá phù hợp với những bài toán có tập giá trị xác định, chẳng hạn:

  • HTTP status code.
  • Trạng thái đơn hàng.
  • Mã lựa chọn menu.
  • Mã lỗi.
  • Trạng thái thiết bị.

Tuy nhiên, nếu bài toán yêu cầu kiểm tra kiểu như:

Nếu điểm >= 80...
Nếu điểm >= 60...
Nếu điểm < 60...

thì if-elif thường sẽ tự nhiên hơn.

3.2. Match với chuỗi

match-case cũng rất phù hợp khi xử lý chuỗi.

Ví dụ:

command = "start"

match command:
    case "start":
        print("Khởi động")
    case "stop":
        print("Dừng chương trình")
    case "restart":
        print("Khởi động lại")
    case _:
        print("Lệnh không hợp lệ")

Đây là một trường hợp khá phổ biến trong các chương trình CLI, hệ thống xử lý command hoặc những ứng dụng có nhiều trạng thái.

Ví dụ khác:

role = "admin"

match role:
    case "admin":
        print("Quyền quản trị")
    case "editor":
        print("Quyền biên tập")
    case "user":
        print("Quyền người dùng")
    case _:
        print("Role không hợp lệ")

Điểm mạnh ở đây nằm ở khả năng đọc. Khi mở đoạn code, chúng ta có thể nhanh chóng nhìn thấy toàn bộ những trường hợp mà chương trình đang xử lý.

3.3. Gộp nhiều pattern trong một case

Python cho phép sử dụng toán tử | để biểu diễn nhiều pattern trong cùng một case.

Ví dụ:

status = "processing"

match status:
    case "pending" | "processing":
        print("Đang xử lý")
    case "success":
        print("Thành công")
    case "failed":
        print("Thất bại")
    case _:
        print("Trạng thái không xác định")

Trong trường hợp này, cả "pending" và "processing" đều dẫn đến cùng một khối xử lý.

Cách này đặc biệt hữu ích khi nhiều giá trị có cùng cách xử lý.

Thay vì:

if status == "pending":
    print("Đang xử lý")
elif status == "processing":
    print("Đang xử lý")

chúng ta có thể biểu diễn trực tiếp ý tưởng:

case "pending" | "processing":

Nhìn vào code, người đọc cũng dễ dàng hiểu rằng hai trạng thái này thuộc cùng một nhóm xử lý.

3.4. Sử dụng điều kiện với if trong case

match-case cũng hỗ trợ guard, tức là điều kiện bổ sung sau pattern.

Ví dụ:

age = 25

match age:
    case age if age < 18:
        print("Trẻ vị thành niên")
    case age if age >= 18:
        print("Người trưởng thành")

Ở đây, age trong pattern được capture giá trị và điều kiện if được sử dụng để quyết định pattern đó có thực sự được chọn hay không.

Tuy nhiên, với ví dụ đơn giản như trên, cá nhân mình cho rằng if-else vẫn dễ đọc hơn:

if age < 18:
    print("Trẻ vị thành niên")
else:
    print("Người trưởng thành")

Điều này cho thấy một nguyên tắc khá quan trọng: biết sử dụng match-case không có nghĩa là phải sử dụng nó ở mọi nơi.

3.5. Match với list và tuple

Đây mới là một trong những khả năng đáng chú ý của Structural Pattern Matching.

Ví dụ:

point = (10, 20)

match point:
    case (0, 0):
        print("Gốc tọa độ")
    case (x, y):
        print(f"Điểm: {x}, {y}")

Nếu point = (10, 20), pattern (x, y) sẽ khớp và các giá trị sẽ được capture:

x = 10
y = 20

Chúng ta cũng có thể kiểm tra số lượng phần tử trong list:

numbers = [1, 2, 3]

match numbers:
    case []:
        print("Danh sách rỗng")
    case [x]:
        print(f"Một phần tử: {x}")
    case [x, y]:
        print(f"Hai phần tử: {x}, {y}")
    case [x, y, z]:
        print(f"Ba phần tử: {x}, {y}, {z}")

Điều này khác khá nhiều so với cách sử dụng if-elif thông thường. Thay vì phải tự kiểm tra len(numbers), chúng ta có thể mô tả trực tiếp hình dạng dữ liệu mà mình mong đợi.

Ví dụ với một API trả về dữ liệu có cấu trúc khác nhau, khả năng này có thể giúp code rõ ràng hơn đáng kể.

3.6. Match với dictionary

match-case cũng có thể match theo cấu trúc dictionary.

Ví dụ:

user = {
    "name": "An",
    "role": "admin"
}

match user:
    case {"role": "admin"}:
        print("Quản trị viên")
    case {"role": "user"}:
        print("Người dùng")
    case _:
        print("Không xác định")

Ở đây, chúng ta không cần kiểm tra thủ công:

if user.get("role") == "admin":

Thay vào đó, pattern:

{"role": "admin"}

mô tả trực tiếp cấu trúc mà chúng ta muốn tìm.

Một điểm quan trọng là dictionary pattern không yêu cầu dictionary chỉ chứa đúng những key được viết trong pattern. Pattern trên vẫn có thể khớp với dictionary có thêm các key khác.

Ví dụ:

user = {
    "name": "An",
    "role": "admin",
    "age": 25
}

vẫn có thể khớp với:

case {"role": "admin"}:

3.7. Match với object/class

Một khả năng khác của pattern matching là làm việc với object.

Ví dụ:

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

Sau đó:

user = User("An", "admin")

match user:
    case User(name, "admin"):
        print(f"{name} là admin")
    case User(name, "user"):
        print(f"{name} là user")
    case _:
        print("Role không xác định")

Nếu object phù hợp với pattern User(name, "admin"), giá trị tên sẽ được capture vào biến name.

Đây là một ví dụ cho thấy match-case không đơn thuần là công cụ để thay thế `switch-case. Nó có thể hiểu và so khớp cấu trúc của dữ liệu.

4. Match-Case khác gì If-Elif-Else trong Python?

4.1. So sánh về cú pháp

Với cùng một bài toán xử lý command, chúng ta có thể viết:

Sử dụng if-elif:

if command == "start":
    print("Khởi động")
elif command == "stop":
    print("Dừng")
elif command == "restart":
    print("Khởi động lại")
else:
    print("Lệnh không hợp lệ")

Hoặc sử dụng match-case:

match command:
    case "start":
        print("Khởi động")
    case "stop":
        print("Dừng")
    case "restart":
        print("Khởi động lại")
    case _:
        print("Lệnh không hợp lệ")

Hai cách đều có thể giải quyết bài toán.

Điểm khác biệt nằm ở cách chúng ta mô tả vấn đề.

if-elif thiên về kiểm tra điều kiện.

match-case thiên về xác định dữ liệu đang thuộc pattern nào.

4.2. So sánh về khả năng xử lý pattern

Đây là điểm match-case thực sự nổi bật.

if-elif rất linh hoạt với các điều kiện:

if age < 18:
    ...
elif age < 60:
    ...
else:
    ...

Trong khi đó, match-case có lợi thế khi dữ liệu có cấu trúc:

match point:
    case (0, 0):
        ...
    case (x, y):
        ...

Hoặc:

match user:
    case {"role": "admin"}:
        ...

Hay:

match command:
    case ("create", "user"):
        ...

Vì vậy, hai cấu trúc này không hoàn toàn cạnh tranh trực tiếp với nhau.

4.3. Match-Case có phải là Switch-Case không?

Nếu đến từ C, C++, JavaScript hoặc một ngôn ngữ có switch-case, bạn có thể cảm thấy match-case rất quen thuộc.

Điểm tương đồng là đều cho phép chương trình lựa chọn một nhánh dựa trên giá trị.

Tuy nhiên, gọi match-case đơn giản là switch-case của Python sẽ chưa thật sự chính xác.

Lý do là Structural Pattern Matching cho phép Python xử lý nhiều dạng pattern phức tạp hơn việc chỉ kiểm tra một giá trị có bằng một giá trị khác hay không.

Ví dụ:

match data:
    case [x, y]:
        print(x, y)

Ở đây Python đang kiểm tra cấu trúc của một list và đồng thời capture dữ liệu.

Đó là lý do khi học match-case, chúng ta nên hiểu khái niệm pattern matching, thay vì chỉ ghi nhớ rằng đây là một dạng switch-case.

4.4. Khi nào nên dùng Match-Case thay cho If-Elif?

Theo mình, có thể bắt đầu bằng một nguyên tắc khá đơn giản.

Nên cân nhắc match-case khi:

  • Có nhiều giá trị hoặc trạng thái cụ thể cần xử lý.
  • Cần kiểm tra nhiều pattern.
  • Dữ liệu có cấu trúc như tuple, list hoặc dictionary.
  • Xử lý command hoặc event.
  • Xử lý các message có cấu trúc.
  • Muốn code thể hiện rõ từng trường hợp.

Nên ưu tiên if-elif khi:

  • Điều kiện dựa trên khoảng giá trị.
  • Có nhiều phép toán logic.
  • Điều kiện phức tạp.
  • Bài toán chủ yếu là kiểm tra True/False.
  • Dùng match-case không giúp code dễ hiểu hơn.

Một developer tốt không phải là người sử dụng được nhiều tính năng nhất, mà là người biết chọn đúng công cụ cho đúng bài toán.

5. Ví dụ thực tế sử dụng Match-Case trong Python

5.1. Xây dựng menu chương trình

Một ví dụ rất dễ hình dung là chương trình menu:

choice = input("Chọn chức năng: ")

match choice:
    case "1":
        print("Thêm sản phẩm")
    case "2":
        print("Xóa sản phẩm")
    case "3":
        print("Xem sản phẩm")
    case _:
        print("Lựa chọn không hợp lệ")

Với những chương trình CLI đơn giản, cách viết này khá trực quan.

Khi mở code, developer có thể nhanh chóng thấy các lựa chọn mà chương trình hỗ trợ.

5.2. Xử lý HTTP Status Code

Đối với backend developer, HTTP status code là một ví dụ thực tế hơn:

status = 404

match status:
    case 200:
        print("Request thành công")
    case 400:
        print("Bad Request")
    case 401:
        print("Unauthorized")
    case 404:
        print("Not Found")
    case 500:
        print("Server Error")
    case _:
        print("Status không xác định")

Nếu hệ thống có nhiều trạng thái cố định cần xử lý, match-case giúp danh sách các trường hợp được thể hiện khá rõ ràng.

5.3. Xử lý command trong ứng dụng

Chúng ta có thể tận dụng khả năng pattern matching với tuple để xử lý command:

command = ("create", "user")

match command:
    case ("create", "user"):
        print("Tạo user")
    case ("delete", "user"):
        print("Xóa user")
    case ("update", "user"):
        print("Cập nhật user")
    case _:
        print("Command không hợp lệ")

Đây là kiểu tình huống mà match-case bắt đầu thể hiện ưu thế rõ ràng.

Thay vì phải viết nhiều điều kiện:

if command[0] == "create" and command[1] == "user":
    ...

chúng ta có thể mô tả trực tiếp pattern:

case ("create", "user"):

Code ngắn hơn, nhưng quan trọng hơn là ý nghĩa của code cũng rõ hơn.

6. Những lưu ý quan trọng khi sử dụng Match-Case

6.1. Match-Case yêu cầu Python 3.10+

Đây là điều đầu tiên cần nhớ.

Nếu project đang chạy Python 3.9 hoặc thấp hơn, không thể sử dụng cú pháp match-case.

Trong môi trường team hoặc production, nên kiểm tra version Python của toàn bộ hệ thống trước khi áp dụng.

6.2. Thứ tự các case rất quan trọng

Các case được kiểm tra theo thứ tự xuất hiện.

Ví dụ:

value = 10

match value:
    case x:
        print("Có giá trị")
    case 10:
        print("Mười")

Ở đây case x là một capture pattern có khả năng khớp với giá trị và gán giá trị đó vào x.

Vì vậy, case 10 phía sau sẽ không còn cơ hội được xử lý.

Đây là một trong những điểm người mới rất dễ nhầm.

Khi viết pattern matching, cần đặt những pattern cụ thể trước những pattern tổng quát.

6.3. Không nên lạm dụng Match-Case

Việc Python cung cấp một tính năng mới không có nghĩa là chúng ta phải sử dụng nó trong mọi trường hợp.

Ví dụ:

if temperature > 30:
    print("Nóng")
else:
    print("Mát")

Rõ ràng và dễ hiểu.

Không cần thiết phải biến nó thành một cấu trúc match-case phức tạp.

Nguyên tắc mình thường ưu tiên là: nếu match-case làm code dễ đọc hơn thì sử dụng; nếu nó khiến code khó hiểu hơn thì if-elif vẫn là lựa chọn tốt.

6.4. Chú ý với biến capture

Một trong những điểm dễ gây hiểu nhầm nhất là:

case x:

Người mới có thể nghĩ rằng nó tương đương với:

value == x

Nhưng không phải.

x trong trường hợp này là một capture pattern. Python có thể lấy giá trị đang được match và gán vào x.

Đây là khác biệt quan trọng giữa pattern matching và cách so sánh giá trị thông thường.

7. Ưu điểm và hạn chế của Match-Case trong Python

7.1. Ưu điểm

match-case có một số ưu điểm đáng chú ý:

Thứ nhất, code rõ ràng khi có nhiều pattern.

Các trường hợp được đặt thành từng case riêng biệt, giúp developer dễ quan sát.

Thứ hai, giảm chuỗi if-elif trong những bài toán phù hợp.

Đặc biệt khi xử lý nhiều trạng thái hoặc command.

Thứ ba, có khả năng match cấu trúc dữ liệu.

Đây là ưu điểm quan trọng nhất. Chúng ta có thể match tuple, list, dictionary và object.

Thứ tư, phù hợp với việc xử lý command, event hoặc dữ liệu có cấu trúc.

Khi dữ liệu đầu vào có nhiều dạng khác nhau, pattern matching có thể giúp code thể hiện rõ hơn logic xử lý.

7.2. Hạn chế

Tất nhiên, match-case cũng không phải giải pháp hoàn hảo cho mọi tình huống.

Đầu tiên, nó yêu cầu Python 3.10 trở lên.

Thứ hai, cú pháp pattern matching có thể hơi khó tiếp cận đối với người mới học Python.

Thứ ba, những pattern quá phức tạp có thể khiến code khó đọc nếu developer chưa quen.

Cuối cùng, match-case không thay thế if-elif. Hai công cụ này phục vụ những kiểu bài toán khác nhau và hoàn toàn có thể tồn tại song song trong cùng một project.

8. Một số lỗi thường gặp khi dùng Match-Case

8.1. Sử dụng Python phiên bản cũ

Nếu chạy code match-case trên Python trước 3.10, chương trình có thể báo lỗi cú pháp.

Vì vậy, hãy kiểm tra:

python --version

trước khi sử dụng.

8.2. Nhầm giữa giá trị và pattern

Đây là lỗi về tư duy phổ biến nhất.

Ví dụ:

case x:

không có nghĩa đơn giản là:

case giá_trị_x:

mà x có thể là biến được capture từ giá trị đang match.

Trong khi:

case 10:

lại là literal pattern cho giá trị 10.

Hiểu được sự khác nhau này sẽ giúp việc học match-case dễ dàng hơn rất nhiều.

8.3. Đặt case _ sai vị trí

Ví dụ không nên viết:

match status:
    case _:
        print("Mặc định")
    case 200:
        print("OK")

Bởi vì _ có thể khớp mọi giá trị, khiến case 200 phía sau trở nên không thể tiếp cận.

Thông thường, hãy đặt:

case _:

ở cuối.

8.4. Viết pattern quá phức tạp

Pattern matching rất mạnh, nhưng chính vì mạnh nên developer có thể dễ bị cuốn vào việc viết những pattern quá cầu kỳ.

Nếu một đoạn match-case mất nhiều thời gian để người khác đọc và hiểu, đó có thể là dấu hiệu cần đơn giản hóa.

Code tốt không chỉ là code chạy đúng, mà còn phải dễ đọc, dễ bảo trì và dễ tiếp tục phát triển.

9. Match-Case trong Python có nên sử dụng không?

Câu trả lời ngắn gọn là: Có, nhưng không nên sử dụng một cách máy móc.

Khi mới tiếp cận match-case, mình nghĩ rất nhiều developer sẽ có cảm giác đây đơn giản là một phiên bản khác của switch-case. Nhưng khi bắt đầu sử dụng pattern matching với tuple, list, dictionary hoặc object, chúng ta mới thấy được giá trị thực sự của tính năng này.

Điểm mình đánh giá cao nhất ở match-case không phải là việc nó giúp thay thế vài dòng if-elif.

Giá trị lớn hơn nằm ở khả năng mô tả cấu trúc dữ liệu mà chương trình đang mong đợi.

Ví dụ:

match command:
    case ("create", "user"):
        ...
    case ("delete", "user"):
        ...

Nhìn vào đoạn code, gần như ngay lập tức chúng ta hiểu được hệ thống đang xử lý những command nào.

Tuy nhiên, với những bài toán như:

if score >= 90:
    ...
elif score >= 80:
    ...
elif score >= 70:
    ...

if-elif vẫn là lựa chọn tự nhiên hơn.

Vì vậy, thay vì đặt câu hỏi:

“Match-case có tốt hơn if-elif không?”

mình nghĩ câu hỏi phù hợp hơn là:

“Bài toán hiện tại đang cần kiểm tra điều kiện hay cần so khớp pattern?”

Nếu cần kiểm tra điều kiện logic, if-elif thường rất phù hợp.

Nếu cần phân loại dữ liệu dựa trên pattern hoặc cấu trúc, match-case có thể là lựa chọn sáng giá.

10. Kết luận

match-case là một tính năng quan trọng được Python giới thiệu từ phiên bản 3.10, mang đến cách tiếp cận mới cho việc xử lý các trường hợp khác nhau trong chương trình.

Ở mức cơ bản, chúng ta có thể sử dụng:

match value:
    case 1:
        ...
    case 2:
        ...
    case _:
        ...

Nhưng khi tìm hiểu sâu hơn, match-case còn có thể xử lý nhiều dạng pattern với tuple, list, dictionary và object. Đây chính là điểm khiến Structural Pattern Matching trở thành một tính năng đáng chú ý của Python hiện đại.

Tuy nhiên, match-case không phải là sự thay thế hoàn toàn cho if-elif-else.

Nếu bài toán chỉ đơn giản là kiểm tra điều kiện, if-elif vẫn rất dễ đọc và hiệu quả. Ngược lại, khi chương trình cần xử lý nhiều pattern hoặc dữ liệu có cấu trúc, match-case có thể giúp code rõ ràng và dễ tổ chức hơn.

Nếu bạn đang học Python, mình khuyên không cần cố gắng thay toàn bộ if-elif bằng match-case. Hãy bắt đầu từ những bài toán đơn giản như xử lý command hoặc status, sau đó thử match với tuple, list và dictionary.

Khi hiểu được cách Python thực sự “so khớp pattern”, bạn sẽ thấy match-case thú vị hơn rất nhiều so với một cấu trúc rẽ nhánh thông thường.

Tài liệu tham khảo

[1] Python Software Foundation, “Structural Pattern Matching: Specification,” Python Documentation, 2026. https://peps.python.org/pep-0634/

[2] Python Software Foundation, “Structural Pattern Matching: Tutorial,” Python Documentation, 2026. https://peps.python.org/pep-0636/

[3] Python Software Foundation, “The match statement,” Python 3 Documentation, 2026. https://docs.python.org/3/reference/compound_stmts.html#the-match-statement

[4] Python Software Foundation, “What’s New In Python 3.10,” Python Documentation, 2026. https://docs.python.org/3/whatsnew/3.10.html

[5] Python Software Foundation, “Python 3.10.0 documentation,” Python Documentation, 2026. https://docs.python.org/3.10/

Để lại một bình luận

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *

Related News