Encapsulation in Python

Encapsulation is a fundamental principle of Object-Oriented Programming (OOP) that restricts direct access to certain attributes and methods of an object. This concept helps to protect the internal state of an object and ensures that its data is modified only through well-defined interfaces. Encapsulation promotes modularity and enhances the maintainability of code by hiding the internal implementation details and exposing only what is necessary.

Key Concepts of Encapsulation

1. Access Modifiers: Encapsulation is implemented using access modifiers that control the visibility of class members (attributes and methods). In Python, the following conventions are used:

   • Public: Members that are accessible from outside the class.
   • Protected: Members that are intended for internal use (denoted by a single underscore _). They can be accessed from subclasses.
   • Private: Members that are not accessible from outside the class (denoted by a double underscore __). These members are name-mangled to prevent accidental access.

2. Getters and Setters: Methods that provide controlled access to private attributes. Getters retrieve the value of an attribute, while setters update its value.

Example of Encapsulation

Here’s a simple example demonstrating encapsulation using access modifiers, along with getters and setters:

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number  # Private attribute
        self.__balance = balance  # Private attribute

    # Getter for balance
    def get_balance(self):
        return self.__balance

    # Setter for balance
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited: ${amount}")
        else:
            print("Deposit amount must be positive.")

    # Method to withdraw money
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew: ${amount}")
        else:
            print("Insufficient balance or invalid amount.")

# Creating an instance of BankAccount
account = BankAccount("12345678", 1000)

# Accessing the balance through getter
print("Initial Balance:", account.get_balance())  # Output: Initial Balance: 1000

# Depositing money
account.deposit(500)  # Output: Deposited: $500
print("New Balance:", account.get_balance())  # Output: New Balance: 1500

# Withdrawing money
account.withdraw(200)  # Output: Withdrew: $200
print("Final Balance:", account.get_balance())  # Output: Final Balance: 1300

# Attempting to access a private attribute directly (will cause an error)
# print(account.__balance)  # Raises AttributeError

Explanation of the Example

• Private Attributes: The attributes __account_number and __balance are private, meaning they cannot be accessed directly from outside the BankAccount class.

• Getters and Setters: The get_balance method is a getter that allows external code to access the balance without directly exposing the __balance attribute. The deposit and withdraw methods act as setters that control how the balance is modified.

• Data Protection: By using encapsulation, the internal state of the BankAccount object is protected from unauthorized access and modifications. The account balance can only be changed through the defined methods, ensuring that all operations are valid.

Summary

• Encapsulation: The principle of restricting access to certain components of an object and protecting its internal state.
• Access Modifiers: Control the visibility of class members; public (accessible), protected (intended for internal use), and private (not accessible).
• Getters and Setters: Methods that provide controlled access to private attributes, allowing data protection while maintaining functionality.

Encapsulation is a crucial aspect of OOP that promotes data integrity, reduces complexity, and enhances the maintainability of code!