Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Learn encapsulation in Python — public, protected, and private attributes, name mangling, getter/setter methods, the @property decorator, and data validation patterns.
🧠 Real-World Analogy — ATM Machine
When you use an ATM, you only need to press buttons — you don't know how the circuits work inside, what mechanism dispenses cash, or how the balance is stored in the database. That's encapsulation — internal details are hidden, only a clean interface is exposed. This is Encapsulation — hiding internal implementation and exposing only the necessary interface.
🏷️ Access Modifiers in Python
| Notation | Type | Who Can Access |
|---|---|---|
name | Public | Everyone |
_name | Protected (convention) | Class + subclasses (convention only) |
__name | Private (name-mangled) | Only the class itself |
⚠️ Python doesn't enforce access control — it uses conventions and name mangling as guardrails.
✅ Example 1 — Public, Protected, Private
Example
class Employee:
company = "WoHoTech" # public class variable
def __init__(self, name, department, salary, pin):
self.name = name # public
self._department = department # protected (convention)
self.__salary = salary # private (name-mangled)
self.__pin = pin # private
def get_details(self):
return f"{self.name} | {self._department} | ₹{self.__salary:,}"
def _internal_code(self):
return f"EMP-{self.name[:3].upper()}-{self._department[:2].upper()}"
def __verify_pin(self, pin): # private method
return self.__pin == pin
def change_salary(self, new_salary, pin):
if self.__verify_pin(pin):
self.__salary = new_salary
print(f"✅ Salary updated to ₹{new_salary:,}")
else:
print("❌ Wrong PIN. Salary not changed.")
emp = Employee("Arjun", "Engineering", 75000, 1234)
print(emp.name) # ✅ public — works
print(emp._department) # ⚠️ accessible but convention says "don't"
print(emp.get_details()) # ✅ via public method
print(emp._internal_code()) # ⚠️ accessible but protected by convention
# Private access — name mangling
# print(emp.__salary) # ❌ AttributeError!
print(emp._Employee__salary) # 🔓 name mangling: _ClassName__attr (bypass, avoid!)
emp.change_salary(90000, 1234) # correct PIN
emp.change_salary(90000, 9999) # wrong PIN
Output:
Example
Arjun
Engineering
Arjun | Engineering | ₹75,000
EMP-ARJ-EN
75000
✅ Salary updated to ₹90,000
❌ Wrong PIN. Salary not changed.
🏦 Example 2 — Bank Account with Getter/Setter
Example
class BankAccount:
def __init__(self, owner, initial_balance=0):
self.__owner = owner
self.__balance = 0
self.__transactions = []
if initial_balance > 0:
self.deposit(initial_balance)
# ── Getters ────────────────────────────────
def get_owner(self):
return self.__owner
def get_balance(self):
return self.__balance
def get_transactions(self):
return list(self.__transactions) # return copy, not reference
# ── Setter with validation ──────────────────
def set_owner(self, new_name):
if not new_name or not isinstance(new_name, str):
raise ValueError("Owner name must be a non-empty string.")
self.__owner = new_name.strip().title()
# ── Business methods ────────────────────────
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit amount must be positive.")
self.__balance += amount
self.__transactions.append({"type": "deposit", "amount": amount})
print(f" + Deposited ₹{amount:,} | Balance: ₹{self.__balance:,}")
def withdraw(self, amount):
if amount <= 0:
raise ValueError("Withdrawal amount must be positive.")
if amount > self.__balance:
raise ValueError(f"Insufficient funds. Balance: ₹{self.__balance:,}")
self.__balance -= amount
self.__transactions.append({"type": "withdrawal", "amount": amount})
print(f" - Withdrew ₹{amount:,} | Balance: ₹{self.__balance:,}")
def statement(self):
print(f"\n{'='*45}")
print(f" Account: {self.__owner}")
print(f" Balance: ₹{self.__balance:,}")
print(f" {'Type':12} {'Amount':>10}")
print(f" {'-'*24}")
for t in self.__transactions:
sign = "+" if t["type"] == "deposit" else "-"
print(f" {t['type']:12} {sign}₹{t['amount']:>8,}")
print(f"{'='*45}\n")
acc = BankAccount("Rahul Sharma", 10000)
acc.deposit(5000)
acc.withdraw(3000)
acc.deposit(2000)
acc.withdraw(500)
acc.statement()
print(f"Owner: {acc.get_owner()}")
print(f"Balance: ₹{acc.get_balance():,}")
acc.set_owner("rahul kumar sharma") # validates and title-cases
print(f"Updated owner: {acc.get_owner()}")
try:
acc.withdraw(100000)
except ValueError as e:
print(f"Error: {e}")
Output:
| + Deposited ₹10,000 | Balance | ₹10,000 |
| + Deposited ₹5,000 | Balance | ₹15,000 |
| - Withdrew ₹3,000 | Balance | ₹12,000 |
| + Deposited ₹2,000 | Balance | ₹14,000 |
| - Withdrew ₹500 | Balance | ₹13,500 |
| Account | Rahul Sharma |
| Balance | ₹13,500 |
| Owner | Rahul Sharma |
| Balance | ₹13,500 |
| Updated owner | Rahul Kumar Sharma |
| Error | Insufficient funds. Balance: ₹13,500 |
🎯 The @property Decorator (Pythonic Way)
The Pythonic way to create getters/setters in Python is the @property decorator. You can access it like an attribute, but validation runs internally.python example
class Temperature:
def __init__(self, celsius=0):
self._celsius = celsius # use single underscore internally
@property
def celsius(self): # getter
return self._celsius
@celsius.setter
def celsius(self, value): # setter with validation
if value < -273.15:
raise ValueError(f"Temperature below absolute zero ({value}°C) is impossible!")
self._celsius = value
@celsius.deleter
def celsius(self): # deleter
print("Deleting temperature...")
del self._celsius
@property
def fahrenheit(self): # derived (read-only) property
return (self._celsius * 9/5) + 32
@property
def kelvin(self): # derived (read-only) property
return self._celsius + 273.15
def __str__(self):
return (f"{self._celsius}°C = {self.fahrenheit:.2f}°F = {self.kelvin:.2f} K")
t = Temperature(100)
print(t)
t.celsius = 37 # setter called — looks like attribute assignment!
print(t)
t.celsius = 0
print(t)
# Validation
try:
t.celsius = -300 # below absolute zero
except ValueError as e:
print(f"Error: {e}")
# Read-only: can't set fahrenheit directly
try:
t.fahrenheit = 200
except AttributeError as e:
print(f"Error: {e}")Output:
Example
100°C = 212.00°F = 373.15 K
37°C = 98.60°F = 310.15 K
0°C = 32.00°F = 273.15 K
Error: Temperature below absolute zero (-300°C) is impossible!
Error: can't set attribute
💊 Example 3 — Medicine Dosage System
Example
class Medicine:
MAX_DAILY_DOSE = 4000 # mg
def __init__(self, name, dose_mg, frequency_per_day):
self.name = name
self._dose_mg = None
self._frequency = None
self.dose_mg = dose_mg # use setter
self.frequency_per_day = frequency_per_day # use setter
@property
def dose_mg(self):
return self._dose_mg
@dose_mg.setter
def dose_mg(self, value):
if not (1 <= value <= 1000):
raise ValueError(f"Single dose must be 1–1000 mg. Got {value} mg.")
self._dose_mg = value
@property
def frequency_per_day(self):
return self._frequency
@frequency_per_day.setter
def frequency_per_day(self, value):
if not (1 <= value <= 8):
raise ValueError(f"Frequency must be 1–8 times/day. Got {value}.")
self._frequency = value
@property
def total_daily_dose(self): # computed, read-only
return self._dose_mg * self._frequency
@property
def is_safe(self):
return self.total_daily_dose <= Medicine.MAX_DAILY_DOSE
def __str__(self):
safety = "✅ SAFE" if self.is_safe else "⚠️ EXCEEDS MAX"
return (f"{self.name}: {self.dose_mg}mg × {self.frequency_per_day}/day "
f"= {self.total_daily_dose}mg/day [{safety}]")
meds = [
Medicine("Paracetamol", 500, 4),
Medicine("Ibuprofen", 400, 3),
Medicine("Aspirin", 300, 6),
]
for m in meds:
print(m)
# Validation tests
print("\n── Validation Tests ──")
try:
bad_med = Medicine("Unknown", 1500, 4) # too high single dose
except ValueError as e:
print(f"Error: {e}")
try:
meds[0].frequency_per_day = 12 # too frequent
except ValueError as e:
print(f"Error: {e}")
Output:
| Paracetamol | 500mg × 4/day = 2000mg/day [✅ SAFE] |
| Ibuprofen | 400mg × 3/day = 1200mg/day [✅ SAFE] |
| Aspirin | 300mg × 6/day = 1800mg/day [✅ SAFE] |
| Error | Single dose must be 1–1000 mg. Got 1500 mg. |
| Error | Frequency must be 1–8 times/day. Got 12. |
🎯 __slots__ — Memory Optimization + Restriction
Example
class Point:
__slots__ = ["x", "y"] # only these attributes allowed
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(3, 4)
print(p.x, p.y)
try:
p.z = 10 # ❌ AttributeError — __slots__ prevents new attrs
except AttributeError as e:
print(f"Error: {e}")
# Benefits: ~40% less memory, faster attribute access
# Drawback: can't add new attributes dynamically
🔍 Name Mangling Deep Dive
python example
class Parent:
def __init__(self):
self.__secret = "Parent's secret" # mangled to _Parent__secret
def reveal(self):
return self.__secret # works inside the class
class Child(Parent):
def __init__(self):
super().__init__()
self.__secret = "Child's secret" # mangled to _Child__secret (DIFFERENT!)
def reveal_child(self):
return self.__secret # accesses _Child__secret
p = Parent()
c = Child()
print(p.reveal()) # Parent's secret
print(c.reveal()) # Parent's secret (from Parent's reveal)
print(c.reveal_child()) # Child's secret
# Peek behind the curtain:
print(vars(c))
# {'_Parent__secret': "Parent's secret", '_Child__secret': "Child's secret"}🇮🇳 Hindi Explanation (हिंदी में समझें)
Encapsulation kya hai? Encapsulation means bundling data (attributes) and code (methods) into a single unit (class), and hiding internal details. Only the necessary interface should be exposed.
How to make things private in Python? Double underscore__varmakes an attribute private — Python internally changes its name (_ClassName__var). This is name mangling. Single underscore_varis just a convention ("please don't touch this") — no actual restriction.
Why do we use@property?@propertylets you have attribute-style access (obj.temp) with validation and computation — without method call syntax. This is Python's cleanest encapsulation pattern.
❓ Interview Questions
Q1: What is encapsulation? Why is it important?
Answer: Encapsulation is the bundling of data (attributes) and behavior (methods) within a class, while hiding internal implementation details. It's important because:
- Protects data integrity (validation in setters)
- Reduces complexity (only expose what's needed)
- Allows internal changes without breaking external code
- Prevents unintended modification of state
Q2: How does Python implement private attributes?
Answer: Python uses name mangling for double-underscore attributes. self.__balance becomes self._BankAccount__balance. This makes accidental access harder but doesn't truly prevent it. It's a strong convention rather than strict enforcement.
Q3: What is the difference between _x, __x, and x?
Answer:
x— Public: accessible from anywhere_x— Protected: convention signals "internal use / subclasses only"; Python doesn't enforce it__x— Private: name-mangled to_ClassName__x; harder to access from outside, not inherited by subclasses under the original name
Q4: What is the @property decorator? How is it different from a regular getter?
Answer: @property creates a managed attribute that is accessed like a plain attribute but calls a getter function under the hood. Benefits over regular get_x(): cleaner syntax (obj.x vs obj.get_x()), backward-compatible (can convert plain attributes to properties), and adds @x.setter and @x.deleter support.
Q5: What is __slots__? When should you use it?
Answer: __slots__ restricts which attributes an instance can have. Benefits: ~40% memory reduction (no __dict__ per object), faster attribute access. Use when creating millions of objects (e.g., data records, game entities). Downside: can't add new attributes dynamically; mixins/multiple inheritance becomes complex.
Q6: Can you access a private attribute from outside the class?
Answer: Technically yes — via name mangling: obj._ClassName__attr. But this is strongly discouraged. The mangling exists to prevent *accidental* access, not to provide true security. Python philosophy: "we are all consenting adults."
Q7: How do you make a read-only property?
Answer: Define only the @property getter without a @x.setter. Trying to assign to it raises AttributeError: can't set attribute.
🧪 Practice Exercises
- Person Card: Create a
Personclass withname(no empty string),age(0–120),email(must contain @) using@propertywith validation. - Stock Price: Create a
Stockclass withpriceproperty that must be positive and auto-records historical prices in a private list. - Circle: Create a
Circlewithradiusproperty. Auto-computeareaanddiameteras read-only properties. - Password Manager: Create a class where
passwordcan only be set (not read), stores a hash, and hasverify(pin)method. - Thermostat: Create a
Thermostatwheretemperaturecan be set in Celsius, read in both Celsius and Fahrenheit, with min/max clamping.
💡 Next Topic → Abstraction: Learn to use abstract classes,ABC,@abstractmethod, and design clean interfaces.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Encapsulation in Python.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, object, oriented, programming
Related Python Master Course Topics
Continue learning this concept
Object Oriented ProgrammingAbstraction in PythonMaster abstraction in Python — abstract base classes (ABC), @abstractmethod, interface design, abstract properties, concrete vs abstract classes, and real-world design patterns.Object Oriented ProgrammingClasses and Objects in PythonMaster the foundation of Object-Oriented Programming — learn how to define classes, create objects, use attributes and methods, and understand how Python models real-world entities as code.Object Oriented ProgrammingConstructors in PythonDeep dive into Python constructors — __init__, __new__, default parameters, class method constructors, constructor chaining, and destructor __del__ with real-world examples.Object Oriented ProgrammingInheritance in PythonMaster Python inheritance — single, multiple, multilevel, and hierarchical inheritance, MRO (Method Resolution Order), super(), mixins, and real-world class hierarchies.Object Oriented ProgrammingMagic Methods (Dunder Methods) in PythonMaster PythonObject Oriented ProgrammingMethod Overriding in PythonDeep dive into Python method overriding — redefining parent class methods in child classes, using super(), cooperative multiple inheritance, MRO interaction, and real-world design patterns.