Define encapsulation in Python?

In Python, encapsulation can be demonstrated through the use of classes and methods. For instance, consider a class BankAccount that encapsulates account details. Here’s a simple implementation:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.__owner = owner  # Private attribute
        self.__balance = balance  # Private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError('Deposit amount must be positive')

    def get_balance(self):
        return self.__balance

In this example, __owner and __balance are private attributes, meaning they cannot be accessed directly from outside the class. Instead, methods like deposit() and get_balance() provide controlled access to these attributes. This ensures that the balance cannot be modified arbitrarily, maintaining the integrity of the account data.

To further illustrate encapsulation, we can enhance the BankAccount class by adding getter and setter methods. This approach allows controlled access to private attributes. Here’s how you can implement it:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.__owner = owner
        self.__balance = balance

    def set_balance(self, amount):
        if amount >= 0:
            self.__balance = amount
        else:
            raise ValueError('Balance cannot be negative')

    def get_balance(self):
        return self.__balance

In this implementation, the set_balance() method allows the balance to be updated only if the new amount is non-negative. This encapsulation mechanism prevents invalid data from being set directly, thus protecting the state of the object. By using these methods, we adhere to the encapsulation principle, ensuring that any changes to the balance are validated.

Encapsulation is not just a theoretical concept; it has practical implications in software development. For instance, in a project management application, encapsulation can be used to manage user access to sensitive project data. Consider the following example:

class Project:
    def __init__(self, project_name):
        self.__project_name = project_name
        self.__tasks = []  # Private list of tasks

    def add_task(self, task):
        self.__tasks.append(task)

    def get_tasks(self):
        return self.__tasks

In this Project class, the task list is kept private to prevent external manipulation. Users of this class can only add tasks through the add_task() method and retrieve them using get_tasks(). This encapsulation ensures that the integrity of the task list is maintained and that no external code can interfere with it. By using encapsulation, developers can create secure, maintainable systems that protect critical data, making it a vital principle in software design.