Q: OOP kya hai aur kyun use karte hain?
Ans: Object-Oriented Programming ek paradigm hai jahan code ko OBJECTS ke around organize kiya jaata hai — jo classes ke instances hote hain. Har object mein DATA (attributes) aur BEHAVIOR (methods) hote hain — dono ek saath encapsulated. OOP use karte hain kyunki: (1) Modularity — code organized aur reusable, (2) Real-world modeling — real objects easily represent kar sakte hain, (3) Scalability — large projects manage karna easier, (4) Code reusability — inheritance se, (5) Data security — encapsulation se. Python fully OOP support karta hai — everything in Python is an object.

Q: Python mein "everything is an object" — iska kya matlab?
Ans: Python mein har cheez internally ek object hai — numbers, strings, lists, functions, even modules! type(10) → int, type("hi") → str, type([1,2]) → list. Har object apna type/class rakhta hai aur uske methods available hote hain — "hello".upper(), [1,2].append(3). Isliye Python fundamentally object-oriented language hai. Numbers bhi objects hain — (10).__add__(5) → 15 (yeh actually + operator karta hai internally).

Q: Class aur Object mein kya difference hai?
Ans: Class ek BLUEPRINT ya template hai — batati hai object mein kya properties (attributes) aur behaviors (methods) honge. Class actual memory nahi leti — sirf definition hai. Object class ka INSTANCE hai — actual real-world entity jo memory mein exist karti hai. Class = "Car" ka blueprint. Object = "Honda City Red" — actual car. Ek class se multiple objects ban sakte hain — sabki apni alag data hoti hai. class Dog: definition hai, dog1 = Dog() object creation hai.

Q: Python class ka syntax kya hai?
Ans: class ClassName: keyword se class define hoti hai (colon important!). Class name PascalCase mein (Employee, BankAccount). Body indented hoti hai — attributes aur methods. Object banane ke liye: obj = ClassName(). Attribute access: obj.attribute. Method call: obj.method(). Empty class ke liye pass use karte hain. Methods ke first parameter hamesha self hota hai — jo current object ko refer karta hai.

Q: __init__ kya hai aur kaise kaam karta hai?
Ans: __init__ Python ka CONSTRUCTOR method hai — jab bhi naya object create hota hai, Python AUTOMATICALLY __init__ call karta hai. Iska purpose object ki attributes ko initial values ke saath initialize karna hai. First parameter hamesha self hota hai — jo naye object ko refer karta hai. Baaki parameters constructor call ke time pass hote hain: Employee("Jatin", 50000) — internally Employee.__init__(new_obj, "Jatin", 50000) call hota hai. Bina __init__ ke tumhe manually har object mein attributes assign karne padte — very tedious.

Q: __init__ ko constructor kyun kehte hain jab return nahi karta?
Ans: Actually Python mein REAL constructor __new__ method hai — jo actual object CREATE karta hai in memory. __init__ technically INITIALIZER hai — jo already-created object mein data set karta hai. Lekin Python community __init__ ko constructor bolti hai casually kyunki practical developers ke liye yeh same job karta hai — new object aata hai to __init__ chalta hai. Interviews mein bata sakte ho ki technically __new__ constructor hai, __init__ initializer hai — but conventionally __init__ ko constructor bolte hain.

Q: Instance variable aur Class variable mein kya difference hai?
Ans: Instance variable object-specific hai — har object ki apni alag copy hoti hai. __init__ ke andar self.variable = value se define hoti hai. Class variable class-wide shared hai — sab objects mein same copy. Class body mein directly define hoti hai (bina self ke). Instance variable personal data ke liye (name, age, balance). Class variable common data ke liye (company name, tax rate, counter). Access: instance var → sirf obj.var. Class var → ClassName.var OR obj.var. Modify karne mein farak — ClassName.var badal do toh sab objects mein change, obj.var badloge toh sirf us object ki naya instance var ban jaayega.

Q: self kya hai aur kyun zaroori hai?
Ans: self ek REFERENCE hai current object (instance) ka. Har instance method ka first parameter self hota hai — jo Python AUTOMATICALLY pass karta hai jab tum method call karte ho. emp.greet() ko Python internally Employee.greet(emp) mein convert karta hai — emp automatically self ban jaata hai. self zaroori hai kyunki: (1) Method ko batata hai "kis object ka data use karna hai." (2) self.attribute se object ki instance variables access karte hain. (3) Same method different objects mein different data ke saath work karta hai self ki wajah se. Bina self ke Python nahi jaan sakta ki "current object kaunsa hai."

Q: Kya self ka naam kuch aur rakh sakte hain?
Ans: Technically HAAN — Python koi restriction nahi hai, tum this, obj, xyz kuch bhi likh sakte ho, code chal jaayega. LEKIN — Python community convention self use karti hai (PEP 8 style guide). Doosre developers tumhara code padhenge toh this dekhkar confuse honge. Django, Flask, Pandas, saari major libraries self use karti hain. Interviews mein "self" ke alawa kuch use karoge toh red flag hai. Rule: ALWAYS use "self" — kabhi naam change mat karo.

Q: Instance method, Class method, aur Static method mein kya difference hai?
Ans: Teen types ke methods hain: (1) Instance method — first parameter self, koi decorator nahi. Object-specific data access karta hai. (2) Class method — first parameter cls, @classmethod decorator. Class-level data access karta hai (class variables). Factory methods banane ke liye common. (3) Static method — koi first parameter nahi, @staticmethod decorator. Na instance na class ka data access karta hai — sirf utility function jo class ke andar rakha hai organization ke liye. Instance method sabse common. Class method factory pattern ke liye. Static method utilities ke liye.

Q: Static method aur regular function mein kya difference hai?
Ans: Technically kaam SAME karte hain — dono independent functions hain. Difference sirf ORGANIZATION mein hai. Static method class ke andar hoti hai — logically related utilities ko group karne ke liye. Example: MathUtils.is_prime(7) vs standalone is_prime(7). Static method: (1) Namespace organization — code cleaner. (2) IDE support better — class ke methods dikhte hain. (3) Refactoring easier — future mein instance method mein convert kar sakte ho agar zaroori ho. Regular function: standalone hoti hai — top-level. Both are equally valid — depends on code architecture and preference.

📘 Definition: The 4 Pillars of OOP are the fundamental principles that define object-oriented programming: Encapsulation, Inheritance, Polymorphism, and Abstraction. These four concepts work together to make OOP powerful, flexible, and reusable. Every OOP language (Python, Java, C++) implements these pillars in some form.

🎯 Samjho Hinglish Mein: 4 Pillars = OOP ke 4 stambh (foundations) jinke bina OOP OOP nahi. (1) Encapsulation = data ko protect karo, private banao. (2) Inheritance = parent class se properties inherit karo (baap-beta relationship). (3) Polymorphism = "poly" = many, "morph" = forms — ek naam ke method different classes mein different kaam kare. (4) Abstraction = complex details hide karo, sirf essential dikhao. Yeh 4 concepts har OOP interview mein 100% puchhe jaate hain — memorize karo!

📋 The 4 Pillars — Quick Overview:

💬 Interview Q&A:

📘 Definition: Encapsulation is the OOP principle of BUNDLING data (attributes) and methods together in a class, and RESTRICTING direct access to some of the object's components. Python uses naming conventions for access levels: Public (normal name — self.name) — accessible everywhere. Protected (single underscore — self._name) — convention says "don't access from outside," but Python doesn't enforce. Private (double underscore — self.__name) — Python does name mangling to make access harder.

🎯 Samjho Hinglish Mein: Encapsulation = capsule jaisa — dawai andar hai, tum baahar se cover dekhte ho. Real example: Bank account — tum balance directly modify nahi kar sakte, sirf deposit() aur withdraw() methods se access hota hai. Yeh data security hai. Python mein 3 levels: Public (name) — sab access kar sakte. Protected (_name) — "please don't touch" (convention, Python enforce nahi karta). Private (__name) — Python name mangling karta hai, access harder. Java/C++ jaisi strict private nahi hoti Python mein — "we are all adults here" philosophy.

📋 Access Modifiers:

💻 Examples:

# Example 1: Public, Protected, Private class Employee: def __init__(self, name, salary): self.name = name # Public — accessible everywhere self._department = "IT" # Protected — convention only self.__salary = salary # Private — Python name mangling
text

def show_salary(self):
    # Inside class — direct access works
    print(f"{self.name}'s salary: ₹{self.__salary}")
emp = Employee("Jatin", 50000)

# Public — free access
print(emp.name) # Jatin ✅

# Protected — technically works but shouldn't be used
print(emp._department) # IT ⚠️ (works but bad practice)

# Private — direct access fails!
# print(emp.__salary) → AttributeError!

emp.show_salary() # Jatin's salary: ₹50000 ✅ (from inside class)

# Example 2: Getter and Setter — proper way to access private class BankAccount:
     def __init__(self, holder, balance): self.holder = holder self.__balance = balance # Private — cannot access directly # Getter — safe way to READ private data def get_balance(self):
     return self.__balance # Setter — safe way to MODIFY with validation def deposit(self, amount):
     if amount <= 0:
     print("❌ Invalid amount!") return self.__balance += amount print(f"✅ Deposited ₹{amount}") def withdraw(self, amount):
     if amount > self.__balance:
     print("❌ Insufficient balance!") return self.__balance -= amount print(f"✅ Withdrew ₹{amount}") acc = BankAccount("Jatin", 5000) # Cannot modify directly — ENCAPSULATION protects data! # acc.__balance = 999999 → Won't affect actual __balance # MUST go through methods — validation enforced! acc.deposit(3000) # ✅ Deposited ₹3000 acc.withdraw(1000) # ✅ Withdrew ₹1000 acc.deposit(-500) # ❌ Invalid amount! print(f"Balance: ₹{acc.get_balance()}") # Balance: ₹7000

# Example 3: Name mangling — Python's private trick class Person:
     def __init__(self, name): self.name = name self.__age = 25 # Private p = Person("Jatin") # Direct access fails # print(p.__age) → AttributeError! # See what Python does internally print(p.__dict__) # {'name': 'Jatin', '_Person__age': 25} # Notice: __age became _Person__age (name mangling!) # Access via mangled name (WORKS but violates encapsulation!) print(p._Person__age) # 25 (technically accessible) # Python mein "true private" nahi hai — sirf harder to access # Community trusts developers to respect the convention

💬 Interview Q&A:

📘 Definition: Inheritance is the OOP mechanism where a NEW class (child/subclass) inherits attributes and methods from an EXISTING class (parent/superclass). This promotes code REUSABILITY and creates a hierarchy. Syntax: class Child(Parent):. Python supports: Single Inheritance (one parent), Multi-level (chain of parents), Multiple Inheritance (multiple parents), Hierarchical (multiple children from one parent). Use super() to call parent's methods.

🎯 Samjho Hinglish Mein: Inheritance = baap-beta relationship. Child class parent class ki saari properties aur methods automatically inherit karti hai — bina dobara likhe. Real example: Animal parent class hai (eat, sleep methods). Dog child class extends Animal — Dog ko free mein eat aur sleep mil gaya, plus apna bark method add kar diya. Code reuse hoti hai, hierarchy bnti hai. super() se parent ke methods call kar sakte ho. Types: Single (Dog → Animal), Multi-level (Puppy → Dog → Animal), Multiple (Bat → Bird + Mammal).

📋 Types of Inheritance:

1. Single Inheritance: Animal → Dog (Dog inherits from Animal)
Multi-level Inheritance: Animal → Dog → Puppy
(Chain — Puppy inherits from Dog, Dog from Animal)

Multiple Inheritance: Bird ─┐
├→ Bat
Mammal┘
(Bat inherits from both Bird and Mammal)

Hierarchical: Animal ─┬→ Dog
├→ Cat
└→ Fish
(Multiple children from one parent)

Syntax: class Child(Parent1, Parent2, ...):
Use super() to access parent's methods

💻 Examples:

# Example 1: Single Inheritance class Animal: def __init__(self, name): self.name = name
text

def eat(self):
    print(f"{self.name} is eating")

def sleep(self):
    print(f"{self.name} is sleeping")
# Dog inherits from Animal
class Dog(Animal):
def bark(self):
print(f"{self.name} says Woof!")

dog = Dog("Bruno")
dog.eat() # Bruno is eating (inherited from Animal!)
dog.sleep() # Bruno is sleeping (inherited!)
dog.bark() # Bruno says Woof! (Dog's own method)

# Dog got 3 methods — 2 inherited, 1 own

# Example 2: super() — call parent's methods class Employee:
     def __init__(self, name, salary): self.name = name self.salary = salary def display(self):
     print(f"Name: {self.name}, Salary: ₹{self.salary}") class Manager(Employee):
     def __init__(self, name, salary, team_size): # Call parent's __init__ using super() super().__init__(name, salary) # Add manager-specific attribute self.team_size = team_size def display(self): # Call parent's display first super().display() print(f"Team Size: {self.team_size}") mgr = Manager("Jatin", 100000, 5) mgr.display() # Name: Jatin, Salary: ₹100000 # Team Size: 5 # super() prevents code duplication!

# Example 3: Multi-level & Multiple Inheritance # Multi-level: Animal → Dog → Puppy class Animal:
     def breathe(self):
     print("Breathing...") class Dog(Animal):
     def bark(self):
     print("Woof!") class Puppy(Dog): # Puppy → Dog → Animal (chain) def play(self):
     print("Playing...") puppy = Puppy() puppy.breathe() # From Animal (grandparent!) puppy.bark() # From Dog (parent) puppy.play() # From Puppy itself # Multiple Inheritance class Bird:
     def fly(self):
     print("Flying...") class Swimmer:
     def swim(self):
     print("Swimming...") class Duck(Bird, Swimmer): # Multiple parents! def quack(self):
     print("Quack Quack!") duck = Duck() duck.fly() # From Bird duck.swim() # From Swimmer duck.quack() # From Duck itself # Duck inherited from BOTH classes!

💬 Interview Q&A:

📘 Definition: Polymorphism ("many forms") is the OOP principle where the SAME method name can behave DIFFERENTLY in different classes. The most common form in Python is Method Overriding — a child class provides its OWN implementation of a method that's already defined in the parent class. When called on the child object, Python uses the child's version. This allows uniform interface but different behaviors.

🎯 Samjho Hinglish Mein: Polymorphism = "poly" (many) + "morph" (forms) — ek naam ke method ke alag-alag roop. Real example: speak() method — Dog mein "Woof", Cat mein "Meow", Cow mein "Moo". Same method naam speak(), but har class mein different implementation. Method Overriding tab hoti hai jab child class parent ke method ko REDEFINE karti hai. Parent class ke saare children ko treat kar sakte ho uniformly — sabke saath same method call karo, sabhi apne tarike se respond karenge.

💻 Examples:

# Example 1: Method Overriding — classic example class Animal: def speak(self): print("Some generic animal sound")
class Dog(Animal):
def speak(self): # Override parent's speak
print("Woof! Woof!")

class Cat(Animal):
def speak(self): # Override parent's speak
print("Meow!")

class Cow(Animal):
def speak(self):
print("Moo!")

# Polymorphism in action — SAME method, DIFFERENT behavior
animals = [Dog(), Cat(), Cow(), Animal()]

for animal in animals:
animal.speak() # Each speaks differently!

# Woof! Woof!
# Meow!
# Moo!
# Some generic animal sound

# Example 2: Extending parent's method with super() class Employee:
     def __init__(self, name, salary): self.name = name self.salary = salary def show_info(self):
     print(f"Name: {self.name}") print(f"Salary: ₹{self.salary}") class Manager(Employee):
     def __init__(self, name, salary, team_size): super().__init__(name, salary) self.team_size = team_size # Override + extend parent's method def show_info(self): super().show_info() # Call parent's method first print(f"Team Size: {self.team_size}") # Add extra info print(f"Role: Manager") class Developer(Employee):
     def __init__(self, name, salary, language): super().__init__(name, salary) self.language = language def show_info(self): super().show_info() print(f"Language: {self.language}") print(f"Role: Developer") emp1 = Manager("Jatin", 100000, 5) emp2 = Developer("Priya", 80000, "Python") emp1.show_info() print("---") emp2.show_info() # Manager output: # Name: Jatin, Salary: ₹100000, Team Size: 5, Role: Manager # Developer output: # Name: Priya, Salary: ₹80000, Language: Python, Role: Developer

# Example 3: Polymorphism with different classes (Duck Typing) # Even without inheritance — if class has same method, it works! class Rectangle:
     def __init__(self, length, width): self.length = length self.width = width def area(self):
     return self.length * self.width class Circle:
     def __init__(self, radius): self.radius = radius def area(self):
     return 3.14 * self.radius ** 2 class Triangle:
     def __init__(self, base, height): self.base = base self.height = height def area(self):
     return 0.5 * self.base * self.height # Uniform interface — all shapes have area() method shapes = [ Rectangle(10, 5), Circle(7), Triangle(6, 4) ] for shape in shapes:
     print(f"{type(shape).__name__} area: {shape.area()}") # Rectangle area: 50 # Circle area: 153.86 # Triangle area: 12.0 # No inheritance needed — just same method name (Duck Typing!) # "If it walks like a duck and quacks like a duck, it's a duck"

💬 Interview Q&A:

📘 Definition: Abstraction is the OOP principle of HIDING complex implementation details and exposing only ESSENTIAL features. An Abstract Class is a class that CANNOT be instantiated directly — it serves as a blueprint for other classes. It contains abstract methods (methods without implementation) that MUST be implemented by child classes. Python provides the abc module (Abstract Base Classes) with ABC class and @abstractmethod decorator.

🎯 Samjho Hinglish Mein: Abstraction = complex cheezein chhupao, sirf important dikhao. Real example: Car chalate ho — steering, brake, accelerator use karte ho, but engine ke andar kya ho raha hai woh tumhe nahi pata (aur nahi jaanna chahiye). Abstract class ek "contract" hai — batati hai "yeh methods honi CHAHIYE" but implementation child class deti hai. Payment abstract class me process_payment() abstract method ho — CreditCard, UPI, Wallet — sab child classes ko yeh implement karna PADEGA. Bina implement kiye instantiate nahi kar sakte.

💻 Examples:

# Example 1: Abstract Class basics from abc import ABC, abstractmethod
class Animal(ABC): # Inherit from ABC = Abstract

text

@abstractmethod
def speak(self):   # Abstract method — no implementation
    pass

@abstractmethod
def move(self):
    pass

# Regular method — can have implementation
def sleep(self):
    print("Sleeping...")
# Cannot instantiate abstract class directly!
# animal = Animal() → TypeError: Can't instantiate abstract class

# Child MUST implement abstract methods
class Dog(Animal):
def speak(self):
print("Woof!")

text

def move(self):
    print("Running...")
class Bird(Animal):
def speak(self):
print("Tweet!")

text

def move(self):
    print("Flying...")
# Now child classes can be instantiated!
dog = Dog()
dog.speak() # Woof!
dog.move() # Running...
dog.sleep() # Sleeping... (from Animal)

bird = Bird()
bird.speak() # Tweet!
bird.move() # Flying...

# Example 2: Payment system — real-world abstraction from abc import ABC, abstractmethod class Payment(ABC):
     def __init__(self, amount): self.amount = amount @abstractmethod def process_payment(self): pass def show_receipt(self):
     print(f"✅ Payment of ₹{self.amount} successful") class CreditCard(Payment):
     def process_payment(self):
     print(f"💳 Processing ₹{self.amount} via Credit Card...") self.show_receipt() class UPI(Payment):
     def process_payment(self):
     print(f"📱 Processing ₹{self.amount} via UPI...") self.show_receipt() class Wallet(Payment):
     def process_payment(self):
     print(f"👝 Processing ₹{self.amount} via Wallet...") self.show_receipt() # Uniform interface — all payment methods work the same way payments = [ CreditCard(1000), UPI(500), Wallet(200) ] for payment in payments: payment.process_payment() print() # 💳 Processing ₹1000 via Credit Card... # ✅ Payment of ₹1000 successful # 📱 Processing ₹500 via UPI... # ✅ Payment of ₹500 successful # 👝 Processing ₹200 via Wallet... # ✅ Payment of ₹200 successful

# Example 3: What happens if child DOESN'T implement abstract method? from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self): pass @abstractmethod def perimeter(self): pass class Circle(Shape):
     def __init__(self, radius): self.radius = radius def area(self):
     return 3.14 * self.radius ** 2 # ⚠️ FORGOT to implement perimeter()! # Try to create Circle # circle = Circle(5) # → TypeError: Can't instantiate abstract class Circle # with abstract method perimeter # Fix — implement BOTH abstract methods class Circle(Shape):
     def __init__(self, radius): self.radius = radius def area(self):
     return 3.14 * self.radius ** 2 def perimeter(self): # Now implemented! return 2 * 3.14 * self.radius circle = Circle(5) print(circle.area()) # 78.5 print(circle.perimeter()) # 31.4

💬 Interview Q&A:

📘 Definition: Dunder Methods (double underscore methods) also called Magic Methods or Special Methods — are predefined methods with double underscores like __init__, __str__, __len__. Python calls them AUTOMATICALLY in specific situations. They allow you to define how your objects behave with built-in operations like print(), len(), ==, +. This makes custom classes work like built-in types.

📋 Common Dunder Methods:

💻 Examples:

# Example 1: __str__ and __repr__ class Employee: def __init__(self, name, salary): self.name = name self.salary = salary
text

# For end users — readable
def __str__(self):
    return f"{self.name} — ₹{self.salary}"

# For developers — detailed, unambiguous
def __repr__(self):
    return f"Employee(name='{self.name}', salary={self.salary})"
emp = Employee("Jatin", 50000)

# Without dunder methods:
# print(emp) →  (useless!)

# With str and repr:
print(emp) # Jatin — ₹50000 (uses str)
print(str(emp)) # Jatin — ₹50000 (uses str)
print(repr(emp)) # Employee(name='Jatin', salary=50000) (uses repr)

# Example 2: __len__ and __eq__ class Team:
     def __init__(self, name, members): self.name = name self.members = members # Enable len(team) — returns number of members def __len__(self):
     return len(self.members) # Enable team1 == team2 — compare by name def __eq__(self, other):
     return self.name == other.name def __str__(self):
     return f"Team {self.name} with {len(self)} members" team1 = Team("Data Team", ["Jatin", "Priya", "Rahul"]) team2 = Team("Data Team", ["Amit", "Neha"]) print(len(team1)) # 3 (uses __len__) print(len(team2)) # 2 print(team1 == team2) # True (same name, uses __eq__) print(team1) # Team Data Team with 3 members

# Example 3: Custom + operator (__add__) class Vector:
     def __init__(self, x, y): self.x = x self.y = y def __str__(self):
     return f"Vector({self.x}, {self.y})" # Enable v1 + v2 def __add__(self, other):
     return Vector(self.x + other.x, self.y + other.y) # Enable v1 - v2 def __sub__(self, other):
     return Vector(self.x - other.x, self.y - other.y) # Enable v1 * scalar def __mul__(self, scalar):
     return Vector(self.x * scalar, self.y * scalar) v1 = Vector(2, 3) v2 = Vector(4, 5) # Use operators like built-in types! v3 = v1 + v2 # Uses __add__ print(v3) # Vector(6, 8) v4 = v2 - v1 # Uses __sub__ print(v4) # Vector(2, 2) v5 = v1 * 3 # Uses __mul__ print(v5) # Vector(6, 9) # Custom class works like built-in — POWERFUL!

💬 Interview Q&A:

📘 Definition: The @property decorator allows you to define methods that can be accessed like attributes (without parentheses). It provides a Pythonic way to implement getters and setters — controlling how attributes are accessed, modified, or deleted. Use @property for getter, @attribute.setter for setter, and @attribute.deleter for deleter. This gives you data validation, computed properties, and encapsulation with clean syntax.

🎯 Samjho Hinglish Mein: Regular attribute (obj.name) directly access hoti hai — koi validation nahi. Method (obj.get_name()) parentheses ke saath call hoti hai — feel unnatural. @property beech ka rasta hai — METHOD hai internally, but ATTRIBUTE ki tarah access hoti hai (obj.name) — no parentheses! Validation, computation, encapsulation — sab possible with clean syntax. Java jaisi getName()/setName() boilerplate se bachao — Python mein @property use karo. Professional Python code mein bahut common hai.

💻 Examples:

# Example 1: Basic @property — read-only attribute class Circle: def __init__(self, radius): self.radius = radius
text

@property
def area(self):   # Computed property!
    return 3.14 * self.radius ** 2

@property
def diameter(self):
    return 2 * self.radius
c = Circle(5)

# Access like ATTRIBUTE — no parentheses!
print(c.area) # 78.5 (looks like attribute but calls method!)
print(c.diameter) # 10

# Try to set — TypeError!
# c.area = 100 → AttributeError: can't set attribute
# Read-only property banaayi hai — protects from accidental modification

# Example 2: Getter, Setter, and Deleter with validation class Employee:
     def __init__(self, name, salary): self.name = name self._salary = salary # Underscore — internal # Getter @property def salary(self):
     print("Reading salary...") return self._salary # Setter with validation! @salary.setter def salary(self, value):
     if value < 0: raise ValueError("Salary cannot be negative!") if value > 10000000: raise ValueError("Salary too high! Suspicious!") print(f"Setting salary to ₹{value}") self._salary = value # Deleter @salary.deleter def salary(self):
     print("Deleting salary...") del self._salary emp = Employee("Jatin", 50000) # Get — calls getter print(emp.salary) # Reading salary... 50000 # Set — calls setter with validation emp.salary = 60000 # Setting salary to ₹60000 print(emp.salary) # Reading salary... 60000 # Validation prevents invalid values # emp.salary = -1000 → ValueError: Salary cannot be negative! # Delete — calls deleter del emp.salary # Deleting salary...

# Example 3: Real-world — Temperature converter class Temperature:
     def __init__(self, celsius): self._celsius = celsius @property def celsius(self):
     return self._celsius @celsius.setter def celsius(self, value):
     if value < -273.15: raise ValueError("Below absolute zero!") self._celsius = value # Computed property — Fahrenheit derived from Celsius @property def fahrenheit(self):
     return (self._celsius * 9/5) + 32 @fahrenheit.setter def fahrenheit(self, value): self._celsius = (value - 32) * 5/9 temp = Temperature(25) print(f"Celsius: {temp.celsius}°C") # 25°C print(f"Fahrenheit: {temp.fahrenheit}°F") # 77°F # Set fahrenheit — automatically updates celsius! temp.fahrenheit = 100 print(f"Celsius: {temp.celsius}°C") # ~37.78°C print(f"Fahrenheit: {temp.fahrenheit}°F") # 100°F # Validation works # temp.celsius = -300 → ValueError: Below absolute zero!

💬 Interview Q&A:

Python Handbook ka complete journey — Basics se lekar OOP tak — sab kuch cover ho gaya:

🎉 Python Handbook — COMPLETE!

Python ki complete journey — Variables se lekar OOP tak, Strings se lekar Decorators tak — sab kuch cover ho gaya. Ab tum Python ka master ho — Data Analysis, Web Development, Machine Learning, Automation — kahin bhi apply kar sakte ho. Previously completed on Data Insights: MySQL Masterclass (7 Parts), Pandas, NumPy (3 Parts), Data Cleaning + Statistics, Matplotlib, Seaborn, Plotly, Excel Masterclass (8 Parts), Power BI Masterclass (7 Parts), SQL Interview Questions (Basic + Intermediate + Advanced), Case Studies, Career Roadmap — aur ab Python Handbook (10 Parts) COMPLETE!

Happy Learning & Keep Coding! 🚀
— Data Insights by Jatin Analytics