Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

Home Forums Explain the Python Oops Encapsulation with example. – MindStick
Ask Question

1 Answers

ICSM Computer
ICSM Computer 02 Nov 2025
Report Abuse

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 > 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 <= 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)
advertising
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md