Explain the Python Oops Encapsulation with example.

Question

ICSM Computer · Answer

Encapsulation is one of the core principles of 
Object-Oriented Programming (OOP). It means binding data (variables) and
methods (functions) that operate on that data within a single unit — a
class.
It also helps in restricting direct access to the internal state of an object — protecting data from unintended modification.
In Python, encapsulation is implemented using:
Public members – accessible from anywhere.Protected members – prefix with _ (single underscore), meant for internal use.Private members – prefix with __ (double underscore), not accessible directly from outside the class.
Example of Encapsulation
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # Public attribute
        self._account_type = "Saving"  # Protected attribute
        self.__balance = balance    # Private attribute
    # Public method
    def deposit(self, amount):
        if amount andgt; 0:
            self.__balance += amount
            print(f"Deposited: {amount}")
        else:
            print("Invalid amount")
    # Public method to view balance (controlled access)
    def get_balance(self):
        return self.__balance
    # Public method to withdraw money
    def withdraw(self, amount):
        if amount andlt;= self.__balance:
            self.__balance -= amount
            print(f"Withdrawn: {amount}")
        else:
            print("Insufficient balance")
# Create object
account = BankAccount("Anna", 5000)
# Access public attribute
print("Owner:", account.owner)
# Access protected attribute (possible but discouraged)
print("Account Type:", account._account_type)
# Access private attribute directly (Not allowed)
# print(account.__balance)  #  AttributeError
# Access private data using public method (Encapsulated access)
print("Balance:", account.get_balance())
account.deposit(1000)
account.withdraw(2000)
print("Updated Balance:", account.get_balance())
Output
Owner: Anna
Account Type: Saving
Balance: 5000
Deposited: 1000
Withdrawn: 2000
Updated Balance: 4000
Why Encapsulation is Important
Data protection — prevents external code from directly changing critical variables.Controlled access — allows validation or checks before modifying data.Maintainability — you can change internal implementation without affecting other code.Abstraction support — hides internal details from users.
Accessing Private Variables (Name Mangling)
Even though private variables are not directly accessible, Python internally renames them:
print(account._BankAccount__balance)  # Accessible via name mangling (not recommended)

forum

Explain the Python Oops Encapsulation with example.

Manish Kumar

Can you answer this question?

1 Answers

Example of Encapsulation

Output

Why Encapsulation is Important

Accessing Private Variables (Name Mangling)

Liked By