Encapsulation is one of the core principles of Object-Oriented Programming (OOP) in Python. It helps you protect data and control access to it inside a class.
In simple words:
Encapsulation means wrapping data (variables) and methods (functions) into a single unit (class) and restricting direct access to some components.
🔹 What is Encapsulation in Python?
Encapsulation is:
- Bundling data + methods together inside a class
- Restricting direct access to internal data
- Allowing controlled access through methods
👉 Think of it like a capsule medicine 💊
- You use it easily
- But you cannot see or change its internal ingredients directly
🔹 Why Do We Use Encapsulation?
Encapsulation helps to:
- ✔ Protect data from accidental modification
- ✔ Improve security
- ✔ Control how data is accessed or modified
- ✔ Make code more maintainable and clean
🔹 How Encapsulation Works in Python
Python uses access modifiers (by convention):
| Type | Symbol | Meaning |
|---|---|---|
| Public | var | Accessible everywhere |
| Protected | _var | Internal use (convention) |
| Private | __var | Strongly restricted access |
🔹 1. Public Variables
Public variables can be accessed from anywhere.
class Student:
def __init__(self):
self.name = "John"
Usage:
s = Student()
print(s.name)
Output:
John
🔹 2. Protected Variables (_single underscore)
Protected variables are meant for internal use only (but still accessible).
class Student:
def __init__(self):
self._age = 20
Usage:
s = Student()
print(s._age)
Output:
20
👉 Note: This is a convention, not strict protection.
🔹 3. Private Variables (__double underscore)
Private variables cannot be accessed directly outside the class.
class Student:
def __init__(self):
self.__marks = 90
Try accessing:
s = Student()
print(s.__marks) # ❌ Error
🔹 Access Private Data Using Methods
To access private variables safely, use getter and setter methods.
class Student:
def __init__(self):
self.__marks = 90
def get_marks(self):
return self.__marks
def set_marks(self, value):
if value >= 0:
self.__marks = value
Usage:
s = Student()
print(s.get_marks())
s.set_marks(95)
print(s.get_marks())
Output:
90
95
🔹 Real-Life Example of Encapsulation
class BankAccount:
def __init__(self):
self.__balance = 1000
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient balance")
def get_balance(self):
return self.__balance
Usage:
account = BankAccount()
account.deposit(500)
account.withdraw(200)
print(account.get_balance())
Output:
1300
🔹 Why Private Variables Are Important?
- Prevents accidental modification
- Protects sensitive data (e.g., bank balance, passwords)
- Ensures controlled access
🔹 Encapsulation Using Getter and Setter
Getter → Read data
Setter → Modify data
Example:
class User:
def __init__(self):
self.__username = "admin"
def get_username(self):
return self.__username
def set_username(self, name):
self.__username = name
🔹 Encapsulation vs Abstraction
| Feature | Encapsulation | Abstraction |
|---|---|---|
| Focus | Data protection | Hiding implementation |
| Goal | Secure data | Simplify usage |
| Achieved by | Private variables | Abstract classes |
| Level | Data level | Design level |
🔹 Benefits of Encapsulation
✅ 1. Data protection
Prevents unauthorized access.
✅ 2. Better control
You decide how data is modified.
✅ 3. Improved maintainability
Code becomes easier to manage.
✅ 4. Flexibility
Internal implementation can change without affecting users.
🔹 Common Mistakes
❌ Trying to access private variable directly:
print(obj.__balance) # Error
❌ Thinking _var is fully private:
- It is only a convention, not strict protection.
🚀 Conclusion
Python Encapsulation is a powerful OOP concept that helps you:
- Protect sensitive data
- Control access to class variables
- Build secure and clean applications
It is widely used in:
- Banking systems
- Authentication systems
- Large-scale software applications
){kind=link}
0 Comments