Đóng gói (Encapsulation) trong Python: Hướng dẫn toàn diện

Đóng gói là một nguyên tắc cốt lõi của lập trình hướng đối tượng trong Python. Nó bảo vệ lớp của bạn khỏi các thay đổi hoặc xoá nhầm và thúc đẩy khả năng tái sử dụng cũng như bảo trì mã. Hãy xem định nghĩa lớp đơn giản sau:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")

Nhiều lập trình viên Python định nghĩa lớp như thế này. Tuy nhiên, đây còn xa mới là thực hành tốt nhất mà những Pythonista chuyên nghiệp tuân theo. Vấn đề của lớp này lộ rõ khi bạn thử sửa dữ liệu của nó:

iphone.os = "Android"
print(iphone.os)

Android

Hãy tưởng tượng một chiếc iPhone chạy Android — thật gây sốc! Rõ ràng, chúng ta cần đặt ra một số ranh giới trong lớp để người dùng không thể thay đổi thuộc tính theo ý thích.

Nếu họ quyết định thay đổi, các thay đổi đó phải theo điều kiện của chúng ta, tuân theo quy tắc của chúng ta. Nhưng chúng ta vẫn muốn các thuộc tính .os hoặc .brand giữ nguyên bề ngoài.

Tất cả điều này có thể được thúc đẩy nhờ đóng gói và trong hướng dẫn này, chúng ta sẽ học tất cả về nó. Bắt đầu nhé!

Đóng gói được thực hiện trong Python như thế nào?

Python hỗ trợ đóng gói thông qua quy ước và thực hành lập trình hơn là các bộ định danh truy cập bắt buộc. Bạn thấy đấy, nguyên lý nền tảng đằng sau phần lớn thiết kế mã Python là “Chúng ta đều là người lớn ở đây.” Chúng ta chỉ có thể triển khai đóng gói như một quy ước và kỳ vọng các nhà phát triển Python khác tin tưởng và tôn trọng mã của chúng ta.

Trong các ngôn ngữ OOP khác như Java và C++, đóng gói được buộc chặt bằng các bộ định danh truy cập như public, private hoặc protected, còn Python thì không có:

Vì vậy, hầu hết, nếu không muốn nói là tất cả, các kỹ thuật đóng gói tôi sắp chỉ cho bạn đều là quy ước của Python. Chúng có thể dễ dàng bị phá vỡ nếu bạn muốn. Nhưng tôi tin bạn sẽ tôn trọng và tuân theo chúng trong các dự án phát triển của mình.

Bộ định danh truy cập trong Python

Giả sử chúng ta có lớp đơn giản này:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)

20

Nó có một thuộc tính height có thể in ra. Vấn đề là chúng ta cũng có thể đổi nó thành bất cứ thứ gì mình muốn:

pine.height = 50
pine.height

50

pine.height = "Grandma"
pine.height

'Grandma'

Vậy làm sao để nói với người dùng rằng việc thay đổi height là không được phép? Chúng ta có thể biến nó thành một thành viên được bảo vệ (protected) bằng cách thêm một dấu gạch dưới ở trước:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height

20

Giờ đây, những người hiểu quy ước này sẽ biết rằng họ chỉ nên truy cập thuộc tính và chúng ta đang mạnh mẽ không khuyến khích họ sử dụng và sửa đổi nó. Nhưng nếu họ muốn, họ vẫn có thể sửa, đúng vậy.

Vậy làm sao để ngăn điều đó? Bằng cách dùng một quy ước khác — biến thuộc tính thành thành viên riêng tư (private) bằng cách thêm hai dấu gạch dưới ở trước:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height

AttributeError: 'Tree' object has no attribute '__height'

Bây giờ, Python sẽ báo lỗi nếu ai đó cố truy cập thuộc tính này, chứ đừng nói đến sửa đổi nó.

Nhưng bạn có nhận ra điều chúng ta vừa làm không? Chúng ta đã ẩn đi thông tin duy nhất liên quan đến đối tượng khỏi người dùng. Lớp của chúng ta vừa trở nên vô dụng vì nó không có thuộc tính công khai.

Vậy làm sao để công khai chiều cao cây cho người dùng nhưng vẫn kiểm soát cách họ truy cập và sửa đổi? Ví dụ, chúng ta muốn chiều cao cây nằm trong một khoảng nhất định và chỉ nhận giá trị số nguyên. Làm sao buộc điều đó?

Lúc này, người bạn dùng Java của bạn có thể góp ý rằng hãy dùng phương thức getter và setter. Vậy hãy thử trước:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()

20

Theo cách này, bạn tạo một thuộc tính riêng tư __height nhưng cho phép người dùng truy cập và sửa nó một cách có kiểm soát bằng các phương thức get_height và set_height.

pine.set_height(25)

pine.get_height()

25

Trước khi đặt giá trị mới, set_height đảm bảo chiều cao mới nằm trong khoảng cho phép và là số.

pine.set_height("Password")

TypeError: Tree height must be an integer

Nhưng các phương thức này có vẻ quá nặng cho một thao tác đơn giản. Hơn nữa, viết mã như thế này cũng không đẹp:

# Tăng chiều cao thêm 5
pine.set_height(pine.get_height() + 5)

Chẳng phải sẽ đẹp và dễ đọc hơn nếu ta có thể viết thế này:

pine.height += 5

mà vẫn buộc đúng kiểu dữ liệu và khoảng giá trị cho height? Câu trả lời là có và chúng ta sẽ học cách làm điều đó trong phần tiếp theo.

Sử dụng bộ trang trí @property trong các lớp Python

Chúng ta giới thiệu một kỹ thuật mới — tạo property cho các thuộc tính:

class Tree:
   def __init__(self, height):
       # Trước tiên, tạo một thuộc tính riêng tư hoặc được bảo vệ
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height

17

Chúng ta muốn người dùng truy cập một thuộc tính ẩn tên __height như thể đó là thuộc tính bình thường tên height. Để làm vậy, ta định nghĩa một phương thức tên height trả về self.__height và trang trí nó với @property.

Bây giờ, ta có thể gọi height và truy cập thuộc tính riêng tư:

pine.height

17

Nhưng phần hay nhất là người dùng không thể sửa nó:

pine.height = 15

AttributeError: can't set attribute 'height'
Vì vậy, ta thêm một phương thức khác tên height(self, new_height) được bọc bởi bộ trang trí height.setter. Bên trong phương thức này, ta triển khai logic buộc kiểu dữ liệu và khoảng giá trị mong muốn cho height:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")

Giờ đây, khi người dùng cố sửa thuộc tính height, @height.setter sẽ được gọi, đảm bảo giá trị truyền vào là hợp lệ:
pine = Tree(10)

pine.height = 33  # Gọi @height.setter
pine.height = 45  # Sẽ phát sinh lỗi

ValueError: Invalid height for a pine tree

Chúng ta cũng có thể tuỳ biến cách thuộc tính height được truy cập qua dấu chấm với @height.getter:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # Bạn có thể trả về một phiên bản tuỳ biến của height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height

'This tree is 33 meters'
Mặc dù chúng ta tạo pine với chiều cao kiểu số nguyên, ta vẫn có thể biến đổi giá trị trả về nhờ @height.getter.
Đó là các ví dụ cho cách chúng ta có thể thúc đẩy đóng gói trong một lớp Python. Hãy nhớ, đóng gói vẫn chỉ là quy ước vì chúng ta vẫn có thể phá vỡ thành viên riêng tư __height bên trong:
pine._Tree__height = "Gotcha!"

pine.height

'This tree is Gotcha! meters'
Mọi thứ trong lớp Python đều là công khai, các phương thức riêng tư cũng vậy. Đây không phải là lỗi thiết kế mà là minh chứng cho cách tiếp cận “Chúng ta đều là người lớn ở đây”.
Dưới đây là tóm lược các bộ định danh truy cập trong Python mà chúng ta vừa xem:



Bộ định danh/Quy ước
Mô tả
Ví dụ




Công khai (Public)
Mức truy cập mặc định; thuộc tính và phương thức có thể truy cập từ bên ngoài lớp
self.attribute


Được bảo vệ (Protected)
Ký hiệu bằng một dấu gạch dưới; quy ước cho biết quyền truy cập bị hạn chế một phần
self._attribute


Riêng tư (Private)
Ký hiệu bằng hai dấu gạch dưới; đổi tên (name mangling) cung cấp hạn chế truy cập ở mức nhất định
self.__attribute


Property
Cung cấp truy cập có kiểm soát tới thuộc tính riêng tư bằng @property decorator
@property def attribute(self):


Property chỉ đọc
Không có @attribute.setter; cho phép truy cập chỉ đọc một thuộc tính
@property def attribute(self):



Thực hành tốt khi triển khai đóng gói
Có một số thực hành tốt bạn có thể làm theo để đảm bảo mã của mình tương thích với mã do các OOPista giàu kinh nghiệm khác viết:

Tạo các thuộc tính hoặc phương thức được bảo vệ hoặc riêng tư nếu chúng chỉ được bạn sử dụng. Các thành viên được bảo vệ hoặc riêng tư sẽ bị loại khỏi tài liệu và báo hiệu cho người khác rằng chúng có thể được bạn, với vai trò nhà phát triển, thay đổi mà không cần thông báo, do đó không khuyến khích họ sử dụng.
Bạn không phải lúc nào cũng cần tạo property cho mọi thuộc tính của lớp. Với các lớp lớn có nhiều thuộc tính, việc viết các phương thức attr.getter và attr.setter có thể trở thành cực hình.
Cân nhắc đưa ra cảnh báo mỗi khi người dùng truy cập một thành viên được bảo vệ (_).
Hạn chế dùng thành viên riêng tư, vì chúng có thể khiến mã khó đọc với những người không quen quy ước.
Ưu tiên sự rõ ràng hơn mập mờ. Vì đóng gói nhằm cải thiện khả năng bảo trì mã và bảo vệ dữ liệu, đừng hoàn toàn che giấu các chi tiết triển khai quan trọng của lớp.
Nếu bạn muốn tạo property chỉ đọc, đừng triển khai phương thức @attr.setter. Người dùng có thể truy cập property nhưng không thể sửa nó.
Luôn nhớ rằng đóng gói là một quy ước, không phải phần cú pháp bị bắt buộc trong Python.
Với các lớp đơn giản, cân nhắc dùng dataclass cho phép bật đóng gói lớp chỉ với một dòng mã. Tuy nhiên, dataclass phù hợp với các lớp đơn giản hơn có thuộc tính và phương thức dự đoán được. Xem hướng dẫn về dataclass này để tìm hiểu thêm.

Kết luận và Tài nguyên tham khảo thêm
Trong hướng dẫn này, chúng ta đã học một trong những trụ cột của lập trình hướng đối tượng trong Python: đóng gói.
Đóng gói cho phép bạn định nghĩa quyền truy cập có kiểm soát đến dữ liệu được lưu bên trong các đối tượng của lớp. Điều này giúp bạn viết mã sạch, dễ đọc và hiệu quả, đồng thời ngăn thay đổi hoặc xoá nhầm dữ liệu của lớp.
Dưới đây là một số tài nguyên liên quan giúp nâng cao kiến thức OOP của bạn:

Hướng dẫn OOP trong Python
Lập trình hướng đối tượng trong Python
Cách làm chủ Python — Hướng dẫn từ chuyên gia