OOP中的封裝是什麼？如何在Python中實施它？

在Python中，實現封裝主要通過命名約定和屬性訪問控制來保護數據並限制直接訪問。使用單下劃線（_variable）表示受保護成員，雙下劃線（__variable）實現名稱混淆以增強私有性；通過定義getter和setter方法或使用@property裝飾器控制對內部屬性的訪問；最終目標是鼓勵更安全的使用模式而非完全阻止訪問。

Encapsulation in object-oriented programming (OOP) is the idea of​​ bundling data (variables) and the code that operates on that data (methods) into a single unit — like a class. It also helps restrict direct access to some components of an object, which is key for keeping data safe and preventing unintended or harmful modifications.

In Python, encapsulation isn't enforced as strictly as in some other languages like Java, but you can still implement it using naming conventions and class structures.

Using Private Variables with Underscores

By convention, you can indicate that a variable or method should be treated as private by adding an underscore _ or double underscore __ at the beginning of its name:

• Single underscore ( _variable ) suggests internal use (protected).
• Double underscore ( __variable ) makes Python "mangle" the name to avoid accidental access.

Example:

 class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner # public
        self._balance = balance # protected
        self.__secret_code = 1234 # private

account = BankAccount("Alice", 500)
print(account.owner) # works fine
print(account._balance) # accessible, but not recommended
print(account.__secret_code) # raises AttributeError

Note: You can still access __secret_code if you really want to (like account._BankAccount__secret_code ), but the point is to discourage accidental access.

Controlling Access with Getter and Setter Methods

To safely interact with private variables, you can define getter and setter methods. This lets you add validation or logic before changing values.

Example:

 class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self._balance = balance

    def get_balance(self):
        return self._balance

    def set_balance(self, amount):
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

You could then do:

 account = BankAccount("Bob", 1000)
account.set_balance(1500)
print(account.get_balance()) # prints 1500

This gives you control over how data is updated without exposing the internal state directly.

Using Properties for Cleaner Syntax

Python provides a cleaner way to handle getters and setters using the @property decorator. This lets you access and modify attributes like regular variables while still maintaining encapsulation.

Example:

 class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):
        return self._balance

    @balance.setter
    def balance(self, amount):
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

Now you can do this instead:

 account = BankAccount("Charlie", 800)
account.balance = 900 # uses the setter
print(account.balance) # uses the getter

This looks more natural and keeps your code readable while enforcing encapsulation.

So, implementing encapsulation in Python comes down to:

• Using underscores to signal privacy
• Writing getters/setters or using @property to manage access
• Making sure data changes go through controlled paths

It's not about making things impossible to access, but about encouraging better usage patterns and protecting internal logic.基本上就這些。

以上是OOP中的封裝是什麼？如何在Python中實施它？的詳細內容。更多資訊請關注PHP中文網其他相關文章！