Bỏ qua đến nội dung chính
Mục lục

Đóng gói trong Python (encapsulation): private, _ và __

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 14/17 · Chương 13

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

  • 7 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Đóng gói trong Python (encapsulation) là cách gom dữ liệu của một object với các phương thức xử lý nó, và cho bên ngoài làm việc qua phương thức thay vì sửa thẳng dữ liệu. Python không có từ khóa private: bạn đánh dấu thuộc tính nội bộ bằng gạch dưới đầu tên, và cần hiểu một gạch dưới với hai gạch dưới khác nhau ra sao.

Cần biết trước: hàm khởi tạo __init__ và self, thuộc tính của class và của object và kế thừa.

Vì sao cần đóng gói

Một class tài khoản có phương thức rut() kiểm số dư trước khi trừ. Nhưng thuộc tính so_du mở cho mọi dòng code, nên một dòng ở chỗ khác có thể bỏ qua phép kiểm:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def rut(self, so_tien):
        if so_tien > self.so_du:
            return False
        self.so_du -= so_tien
        return True

tk = TaiKhoan("Hà", 1000000)
print(tk.rut(5000000), tk.so_du)
tk.so_du -= 5000000
print(tk.so_du)

KẾT QUẢ

False 1000000
-4000000

rut() từ chối đúng, nhưng dòng tk.so_du -= 5000000 đi vòng qua nó và làm số dư âm. Đóng gói là thỏa thuận: dữ liệu nằm trong object, còn bên ngoài chỉ đổi nó qua các phương thức đã kiểm tra. Giống quầy giao dịch: khách đưa yêu cầu qua quầy, không ai tự mở két. Đổi rut(5000000) thành rut(400000) rồi chạy lại: dòng đầu in True 600000.

Một gạch dưới: quy ước "dùng nội bộ"

Tên thuộc tính bắt đầu bằng một gạch dưới, như _so_du, báo cho người đọc: đây là chi tiết bên trong class, đừng đọc hay sửa từ ngoài. Bên ngoài dùng phương thức so_du() để xem và rut() để đổi:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self._so_du = so_du
    def so_du(self):
        return self._so_du
    def rut(self, so_tien):
        if so_tien > self._so_du:
            return False
        self._so_du -= so_tien
        return True

tk = TaiKhoan("Hà", 1000000)
tk.rut(250000)
print(tk.so_du(), tk._so_du)

KẾT QUẢ

750000 750000

Python không chặn gì: tk._so_du vẫn đọc được, như dòng in cho thấy. Gạch dưới chỉ là lời nhắn giữa những người viết code, và các công cụ kiểm code cùng trình soạn thảo thường nhắc khi bạn dùng tên đó từ ngoài class. Người dùng class biết rằng chu và so_du() sẽ giữ nguyên, còn _so_du có thể đổi tên ở phiên bản sau. Đổi tk.rut(250000) thành tk.rut(2000000) rồi chạy lại: dòng in 1000000 1000000.

Hai gạch dưới: Python đổi tên thuộc tính

Tên bắt đầu bằng hai gạch dưới (và không kết thúc bằng hai gạch dưới), như __pin, được Python đổi tên khi viết trong thân class: self.__pin trong class TaiKhoan thật ra lưu với tên _TaiKhoan__pin. Việc đổi tên này gọi là name mangling:

python
class TaiKhoan:
    def __init__(self, chu, pin):
        self.chu = chu
        self.__pin = pin
    def kiem_pin(self, pin):
        return pin == self.__pin

tk = TaiKhoan("Minh", "2468")
print(tk.kiem_pin("2468"), tk.kiem_pin("1357"))
print(tk._TaiKhoan__pin)

KẾT QUẢ

True False
2468

Trong thân class, self.__pin dùng bình thường. Bên ngoài, tên __pin không còn, nhưng ai biết luật đổi tên vẫn đọc được qua _TaiKhoan__pin. Vì vậy Python không có private thật: hai gạch dưới làm việc truy cập nhầm khó hơn, không khóa được. Đổi kiem_pin("1357") thành kiem_pin("2468") rồi chạy lại: dòng đầu in True True.

Lỗi đọc còn dễ thấy, vì Python dừng chương trình. Lỗi gán thì khó thấy hơn nhiều.

Hai gạch dưới và class con

Lý do chính để có name mangling là tránh trùng tên giữa class cha và class con. Mỗi class lưu __phi dưới tên riêng của nó, nên class con đặt __phi không đè lên giá trị class cha dùng:

python
class TaiKhoan:
    def __init__(self):
        self.__phi = 11000
    def phi_co_ban(self):
        return self.__phi

class TaiKhoanVip(TaiKhoan):
    def __init__(self):
        super().__init__()
        self.__phi = 55000

vip = TaiKhoanVip()
print(vip.phi_co_ban(), vip._TaiKhoanVip__phi)

KẾT QUẢ

11000 55000

phi_co_ban() viết trong TaiKhoan, nên self.__phi trong đó là _TaiKhoan__phi; class con lưu số của nó vào _TaiKhoanVip__phi. Với một gạch dưới, cả hai sẽ dùng chung _phi và class con đè mất giá trị của class cha, giống ghi đè phương thức nhưng xảy ra với dữ liệu mà không ai định. Vì thế hai gạch dưới hợp với class sẽ được người khác kế thừa; trong code hằng ngày, một gạch dưới là đủ. Đổi self.__phi = 55000 thành self.__phi = 99000 rồi chạy lại: dòng in 11000 99000, phí cơ bản vẫn giữ nguyên.

Kiểm tra nhanh

  1. Trong ví dụ mã PIN của Minh, thêm dòng print(tk.chu, tk._TaiKhoan__pin == "2468") vào cuối. Dòng đó in gì?

    • Báo lỗi AttributeError, vì __pin là private
    • Minh True
    • Minh False
  2. Class TaiKhoan gán self.__pin = pin trong __init__. Dòng print(tk.__pin) viết ngoài class cho kết quả gì?

    • In mã PIN
    • In None
    • Báo lỗi AttributeError
  3. Những câu nào đúng về thuộc tính _so_du có một gạch dưới?

    • Đọc được từ ngoài class bằng tk._so_du
    • Python báo lỗi khi gán nó từ ngoài class
    • Gạch dưới báo cho người đọc rằng đây là chi tiết nội bộ của class
    • Python đổi tên nó thành _TaiKhoan_so_du
  4. Trong khung bẫy gán tk.__pin = "0000" từ ngoài, tk.kiem_pin("2468") trả về gì?

    • True
    • False
    • Báo lỗi AttributeError
Đúng hết lần đầu +15 XP

Bài tập

Viết tài khoản giữ kín mã PIN và số dư

Viết thân ba phương thức của class TaiKhoan:

  • __init__(self, chu, pin, so_du=0): gán chu cho thuộc tính công khai chu; giữ mã PIN trong thuộc tính hai gạch dưới __pin, và số dư trong thuộc tính nội bộ một gạch dưới _so_du. Không tạo thuộc tính pin công khai.

  • so_du(self): trả về số dư hiện tại.

  • rut(self, pin, so_tien): nếu pin khớp mã PIN và so_tien không lớn hơn số dư thì trừ tiền và trả về True; nếu không thì giữ nguyên số dư và trả về False. Rút đúng bằng số dư thì được.

Trả về: so_du() một int, rut() một bool.

python
class TaiKhoan:
    def __init__(self, chu, pin, so_du=0):
        pass  # Viết thân các phương thức thay cho các dòng pass
    def so_du(self):
        pass
    def rut(self, pin, so_tien):
        pass

Tóm tắt

  • Đóng gói: dữ liệu ở trong object, bên ngoài đổi nó qua phương thức có kiểm tra.

  • Python không có private thật; gạch dưới đầu tên là cách đánh dấu.

  • _ten (một gạch dưới) là quy ước "dùng nội bộ": Python không đổi tên, không chặn.

  • __ten (hai gạch dưới) được đổi thành _TenClass__ten trong thân class; đọc tk.__ten từ ngoài gây AttributeError.

  • Gán tk.__ten từ ngoài tạo thuộc tính mới, giá trị thật không đổi.

  • Name mangling giúp class cha và class con dùng cùng một tên mà không đè nhau.

Câu hỏi thường gặp

Thuộc tính private trong Python có thật sự kín không?

Không. Hai gạch dưới chỉ đổi tên thành _TaiKhoan__pin, và ai biết luật vẫn đọc được. Python dựa vào thỏa thuận giữa người viết code hơn là khóa. Dữ liệu cần giữ bí mật thật, như mật khẩu, không nên nằm trong object ở dạng gốc chưa băm, mà lưu dạng đã băm.

Nên dùng một gạch dưới hay hai gạch dưới?

Thường dùng một gạch dưới: đủ để báo "nội bộ" và dễ gỡ lỗi. Dùng hai gạch dưới khi viết class để người khác kế thừa và muốn tránh class con vô tình đè tên, như ví dụ phí của TaiKhoanVip. Cách class con gọi lại class cha thuộc bài kế thừa.

Muốn đọc số dư như một thuộc tính mà vẫn kiểm tra khi gán thì làm sao?

Python có @property: bạn viết tk.so_du như đọc thuộc tính, nhưng thật ra một phương thức chạy và có thể kiểm giá trị khi gán. Bài property dạy cách đó; bài này dùng phương thức so_du() cho rõ.

Chủ đề

encapsulation python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập