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
Top 25+ Python interview questions and detailed answers covering Python basics, OOP, data structures, exceptions, and advanced topics with Hindi explanations for job interviews.
Introduction
Yeh guide top Python interview questions aur unke detailed answers cover karta hai. Yeh questions freshers se leke experienced developers tak sabke liye useful hain.
Q2: Mutable aur Immutable objects ka difference kya hai?
Answer:
- Mutable: Created ke baad change ho sakta hai (list, dict, set)
- Immutable: Created ke baad change NAHI ho sakta (int, float, str, tuple, frozenset)
Example
# Mutable — list
my_list = [1, 2, 3]
my_list[0] = 100
print(my_list) # [100, 2, 3] — changed!
# Immutable — string
my_str = "hello"
try:
my_str[0] = "H" # TypeError!
except TypeError as e:
print(f"Error: {e}")
# Immutable — tuple
my_tuple = (1, 2, 3)
try:
my_tuple[0] = 100 # TypeError!
except TypeError as e:
print(f"Error: {e}")
# "Changing" immutable creates new object
a = "hello"
b = a
a = a + " world" # New string created
print(b) # "hello" — b still points to original
print(id(a) == id(b)) # False — different objects
# Why important? Default arguments!
def bad_func(items=[]): # Mutable default — BUG!
items.append("new")
return items
def good_func(items=None): # Correct way
if items is None:
items = []
items.append("new")
return items
print(bad_func()) # ['new']
print(bad_func()) # ['new', 'new'] — same list reused!
print(good_func()) # ['new']
print(good_func()) # ['new'] — fresh list each time!
Q3: *args aur **kwargs kya hain?
Answer: *args arbitrary positional arguments tuple mein collect karta hai. **kwargs arbitrary keyword arguments dictionary mein collect karta hai.
Example
def flexible_function(*args, **kwargs):
print(f"args: {args}") # Tuple
print(f"kwargs: {kwargs}") # Dictionary
flexible_function(1, 2, 3, name="Alice", age=25)
# Output:
# args: (1, 2, 3)
# kwargs: {'name': 'Alice', 'age': 25}
# Practical example
def create_user(username, email, *roles, **settings):
user = {"username": username, "email": email, "roles": list(roles)}
user.update(settings)
return user
user = create_user("alice", "alice@email.com", "admin", "editor",
active=True, theme="dark")
print(user)
# {'username': 'alice', 'email': 'alice@email.com', 'roles': ['admin', 'editor'],
# 'active': True, 'theme': 'dark'}
# Unpacking with * and **
numbers = [1, 2, 3, 4, 5]
print(*numbers) # 1 2 3 4 5 — unpack list
settings = {"a": 1, "b": 2}
def func(a, b): return a + b
print(func(**settings)) # 3 — unpack dict
Q4: Python mein list, tuple, set aur dict ka difference kya hai?
Answer:
| Feature | List | Tuple | Set | Dict |
|---|---|---|---|---|
| Mutable | ✅ | ❌ | ✅ | ✅ |
| Ordered | ✅ | ✅ | ❌ | ✅(3.7+) |
| Duplicates | ✅ | ✅ | ❌ | Keys: ❌ |
| Syntax | [] | () | {} | {k:v} |
| Indexing | ✅ | ✅ | ❌ | By key |
Example
# List — ordered, mutable, allows duplicates
lst = [1, 2, 2, 3, 4]
lst.append(5)
print(lst[0]) # 1
# Tuple — ordered, immutable, allows duplicates
tpl = (1, 2, 2, 3)
# tpl.append(5) # AttributeError!
print(tpl[0]) # 1
# Set — unordered, mutable, NO duplicates
st = {1, 2, 2, 3, 4}
print(st) # {1, 2, 3, 4} — duplicates removed!
st.add(5)
# print(st[0]) # TypeError — no indexing!
# Dict — key-value, ordered (3.7+), unique keys
dct = {"name": "Alice", "age": 25}
print(dct["name"]) # Alice
dct["email"] = "alice@example.com"
# Use cases
coordinates = (10.5, 20.3) # Tuple — immutable point
unique_tags = {"python", "django", "rest"} # Set — unique values
user_info = {"name": "Bob", "age": 30} # Dict — structured data
items = [1, 2, 3, 1, 2] # List — ordered with duplicates
Q5: Lambda functions kya hain?
Answer: Lambda ek anonymous function hai — ek single line mein define hota hai, bina def keyword ke.
Example
# Regular function
def add(a, b):
return a + b
# Lambda equivalent
add_lambda = lambda a, b: a + b
print(add(3, 4)) # 7
print(add_lambda(3, 4)) # 7
# Common uses
numbers = [5, 2, 8, 1, 9, 3]
# sort with key
sorted_nums = sorted(numbers, key=lambda x: x)
print(sorted_nums) # [1, 2, 3, 5, 8, 9]
# Sort list of dicts
students = [{"name": "Alice", "score": 95}, {"name": "Bob", "score": 82}]
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
# map() with lambda
squares = list(map(lambda x: x**2, numbers))
print(squares) # [25, 4, 64, 1, 81, 9]
# filter() with lambda
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # [2, 8]
# When NOT to use lambda
# ❌ Complex logic — use regular function instead
# ❌ Multiple statements — lambda only allows one expression
Q6: List Comprehension kya hai? Generator Expression se kya fark hai?
Example
# List Comprehension — eagerly evaluated, list return karta hai
squares_list = [x**2 for x in range(10) if x % 2 == 0]
print(squares_list) # [0, 4, 16, 36, 64]
print(type(squares_list)) # <class 'list'>
# Generator Expression — lazily evaluated, generator return karta hai
squares_gen = (x**2 for x in range(10) if x % 2 == 0)
print(type(squares_gen)) # <class 'generator'>
print(list(squares_gen)) # [0, 4, 16, 36, 64]
import sys
print(f"List size: {sys.getsizeof(squares_list)} bytes") # ~136 bytes
print(f"Gen size: {sys.getsizeof(squares_gen)} bytes") # ~112 bytes — always small!
# Dict comprehension
word_lengths = {word: len(word) for word in ["python", "java", "javascript"]}
print(word_lengths) # {'python': 6, 'java': 4, 'javascript': 10}
# Set comprehension
unique_lengths = {len(word) for word in ["cat", "bat", "rat", "elephant"]}
print(unique_lengths) # {3, 8}
# Nested comprehension
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# When to use which?
# List comp: when you need all values at once, small data
# Generator: when processing large data, only need one value at a time
Q7: Python mein Exception Handling kaise karte hain?
Example
# Basic try-except-finally
def divide(a, b):
try:
result = a / b
except ZeroDivisionError:
print("Cannot divide by zero!")
return None
except TypeError as e:
print(f"Type error: {e}")
return None
else:
print(f"Success: {result}") # Only if no exception
return result
finally:
print("This ALWAYS runs") # Cleanup code
divide(10, 2) # Success + finally
divide(10, 0) # ZeroDivisionError + finally
divide(10, "a") # TypeError + finally
# Multiple exceptions in one except
try:
x = int(input("Enter a number: ") if False else "abc")
except (ValueError, TypeError) as e:
print(f"Input error: {e}")
# Exception hierarchy
# BaseException
# ├── SystemExit
# ├── KeyboardInterrupt
# └── Exception
# ├── ValueError
# ├── TypeError
# ├── ZeroDivisionError
# ├── IndexError
# ├── KeyError
# └── ... many more
# Custom exceptions
class InsufficientFundsError(Exception):
def __init__(self, amount, balance):
self.amount = amount
self.balance = balance
super().__init__(f"Cannot withdraw ₹{amount}. Balance: ₹{balance}")
def withdraw(account_balance, amount):
if amount > account_balance:
raise InsufficientFundsError(amount, account_balance)
return account_balance - amount
try:
new_balance = withdraw(1000, 1500)
except InsufficientFundsError as e:
print(f"Error: {e}")
print(f"Tried to withdraw: ₹{e.amount}")
Q8: Python mein decorators kya hain?
python example
import functools
import time
# Simple decorator
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() - start
print(f"{func.__name__} took {elapsed:.4f}s")
return result
return wrapper
@timer
def slow_function(n):
return sum(range(n))
result = slow_function(1000000)
# Output: slow_function took 0.0234s
# Decorator with arguments
def retry(max_attempts=3):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(max_attempts):
try:
return func(*args, **kwargs)
except Exception as e:
if attempt == max_attempts - 1:
raise
print(f"Attempt {attempt+1} failed: {e}")
return wrapper
return decorator
import random
@retry(max_attempts=3)
def unreliable():
if random.random() < 0.7:
raise ValueError("Failed!")
return "Success!"
# try:
# print(unreliable())
# except ValueError:
# print("All retries failed")Q9: Python mein shallow copy aur deep copy kya hai?
Example
import copy
original = {"name": "Alice", "scores": [95, 87, 92], "address": {"city": "Delhi"}}
# Assignment — same object
ref = original
ref["name"] = "Bob"
print(original["name"]) # "Bob" — same object!
# Shallow copy — new outer object, shared nested objects
shallow = copy.copy(original)
shallow["name"] = "Charlie"
shallow["scores"].append(100) # Modifies original's nested list!
print(original["name"]) # "Bob" — outer dict separate
print(original["scores"]) # [95, 87, 92, 100] — nested list SHARED!
# Deep copy — completely independent copy
deep = copy.deepcopy(original)
deep["scores"].append(999)
deep["address"]["city"] = "Mumbai"
print(original["scores"]) # [95, 87, 92, 100] — unchanged!
print(original["address"]["city"]) # "Delhi" — unchanged!
# For lists
lst = [[1, 2], [3, 4]]
shallow_lst = lst.copy() # or lst[:]
deep_lst = copy.deepcopy(lst)
shallow_lst[0].append(99) # Modifies original!
print(lst) # [[1, 2, 99], [3, 4]]
deep_lst[0].append(999) # Independent copy
print(lst) # [[1, 2, 99], [3, 4]] — unchanged by deep copy
Q10: Python mein is aur == ka difference kya hai?
Example
# == checks VALUE equality
# is checks IDENTITY (same object in memory)
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b) # True — same values
print(a is b) # False — different objects!
print(a is c) # True — same object (c = a)
print(id(a)) # e.g., 140234567890
print(id(b)) # different id
print(id(c)) # same as id(a)
# Integer caching (-5 to 256)
x = 100
y = 100
print(x is y) # True — cached!
x = 1000
y = 1000
print(x is y) # False — not cached!
# Use 'is' only for:
# - None comparison: if x is None
# - Singleton patterns: if x is True/False/None
# NEVER use 'is' for value comparison!
# Correct None check
def process(value=None):
if value is None: # Correct
print("No value provided")
# NOT: if value == None # Works but not Pythonic
Q11: Python mein GIL kya hai?
python example
"""
GIL (Global Interpreter Lock):
- CPython interpreter mein ek mutex lock hai
- Ek waqt mein sirf ek thread Python bytecode execute kar sakta hai
- Thread safety ke liye exist karta hai (Python objects ko protect karta hai)
- CPU-bound tasks: threading se speedup NAHI (GIL blocks)
- I/O-bound tasks: threading se speedup milta hai (I/O ke dauran GIL release)
Solutions:
- CPU-bound: use multiprocessing (separate GIL per process)
- I/O-bound: use threading or asyncio
"""
import threading
import time
# GIL effect on CPU-bound
def cpu_work():
total = sum(i * i for i in range(1_000_000))
start = time.time()
cpu_work()
cpu_work()
print(f"Sequential: {time.time() - start:.2f}s")
t1 = threading.Thread(target=cpu_work)
t2 = threading.Thread(target=cpu_work)
start = time.time()
t1.start(); t2.start()
t1.join(); t2.join()
print(f"Threaded: {time.time() - start:.2f}s") # Similar or SLOWER!
# GIL released during I/O
import time
def io_simulation():
time.sleep(1) # GIL released during sleep!
start = time.time()
t1 = threading.Thread(target=io_simulation)
t2 = threading.Thread(target=io_simulation)
t1.start(); t2.start()
t1.join(); t2.join()
print(f"I/O threaded: {time.time() - start:.2f}s") # ~1s, not 2s!Q12: Python mein generators aur iterators kya hain?
Example
# Iterator Protocol
class Counter:
def __init__(self, stop):
self.current = 0
self.stop = stop
def __iter__(self):
return self
def __next__(self):
if self.current >= self.stop:
raise StopIteration
self.current += 1
return self.current
for num in Counter(3):
print(num) # 1 2 3
# Generator — simpler iterator using yield
def count_gen(stop):
for i in range(1, stop + 1):
yield i
for num in count_gen(3):
print(num) # 1 2 3
# Memory comparison
import sys
lst = [i**2 for i in range(1000000)] # 8+ MB
gen = (i**2 for i in range(1000000)) # 112 bytes!
print(f"List: {sys.getsizeof(lst):,} bytes")
print(f"Generator: {sys.getsizeof(gen)} bytes")
Q13: Python mein namespaces aur scope (LEGB) kya hai?
python example
# LEGB Rule: Local > Enclosing > Global > Built-in
x = "Global" # Global scope
def outer():
x = "Enclosing" # Enclosing scope
def inner():
x = "Local" # Local scope
print(f"Inner: {x}") # Local
inner()
print(f"Outer: {x}") # Enclosing
outer()
print(f"Global: {x}") # Global
# global keyword
count = 0
def increment():
global count
count += 1
increment()
increment()
print(f"Count: {count}") # 2
# nonlocal keyword
def make_counter():
n = 0
def counter():
nonlocal n
n += 1
return n
return counter
c = make_counter()
print(c()) # 1
print(c()) # 2
print(c()) # 3Q14: Python mein map(), filter(), reduce() kya hain?
Example
from functools import reduce
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# map() — function apply karo har element pe
squared = list(map(lambda x: x**2, numbers))
print(squared) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# filter() — condition se filter karo
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # [2, 4, 6, 8, 10]
# reduce() — single value mein reduce karo
product = reduce(lambda x, y: x * y, numbers)
print(product) # 3628800 (10!)
total = reduce(lambda x, y: x + y, numbers)
print(total) # 55
# Modern Python — list comprehensions (preferred)
squared_comp = [x**2 for x in numbers]
evens_comp = [x for x in numbers if x % 2 == 0]
# All three combined
result = reduce(
lambda x, y: x + y,
filter(lambda x: x % 2 == 0, map(lambda x: x**2, numbers))
)
print(result) # 220 (4+16+36+64+100)
Q15: Python mein class methods, static methods aur instance methods kya hain?
Example
class Employee:
company_name = "WoHoTech" # Class variable
employee_count = 0
def __init__(self, name, salary):
self.name = name # Instance variable
self.salary = salary
Employee.employee_count += 1
# Instance method — self parameter, instance access
def get_details(self):
return f"{self.name} earns ₹{self.salary}"
# Class method — cls parameter, class-level access
@classmethod
def get_company_info(cls):
return f"{cls.company_name}: {cls.employee_count} employees"
@classmethod
def from_dict(cls, data):
"""Alternative constructor"""
return cls(data["name"], data["salary"])
# Static method — no self/cls, utility function
@staticmethod
def is_valid_salary(salary):
return 0 < salary <= 10_000_000
# Usage
emp1 = Employee("Alice", 75000)
emp2 = Employee.from_dict({"name": "Bob", "salary": 60000})
print(emp1.get_details()) # Instance method
print(Employee.get_company_info()) # Class method
print(Employee.is_valid_salary(-100)) # Static method: False
# Calling on instance also works
print(emp1.is_valid_salary(50000)) # True — but prefer Employee.is_valid_salary()
Q16: Python mein __init__ aur __new__ ka difference kya hai?
python example
class MyClass:
def __new__(cls, *args, **kwargs):
print(f"__new__ called — creating instance of {cls}")
instance = super().__new__(cls) # Object create karo
return instance # Must return instance!
def __init__(self, value):
print(f"__init__ called — initializing with value={value}")
self.value = value
obj = MyClass(42)
# Output:
# __new__ called — creating instance of <class '__main__.MyClass'>
# __init__ called — initializing with value=42
print(obj.value) # 42
"""
__new__: Object CREATION — memory allocate karta hai
__init__: Object INITIALIZATION — attributes set karta hai
Mostly __init__ hi use karte hain.
__new__ use karo jab: Singleton pattern, immutable subclassing (int, str)
"""
# Singleton using __new__
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # True — same object!Q17: Python mein with statement aur context managers kya hain?
python example
# Without context manager — risky
f = open("test.txt", "w")
f.write("Hello")
f.close() # What if exception occurs before this?
# With context manager — safe
with open("test.txt", "w") as f:
f.write("Hello")
# File automatically closed, even if exception occurs
# Custom context manager
class DatabaseContext:
def __enter__(self):
print("Connecting to database...")
self.connection = "DB Connection"
return self.connection
def __exit__(self, exc_type, exc_val, exc_tb):
print("Disconnecting from database...")
if exc_type:
print(f"Error occurred: {exc_val}")
return False # Don't suppress exceptions
with DatabaseContext() as db:
print(f"Using: {db}")
# Using contextlib.contextmanager
from contextlib import contextmanager
@contextmanager
def timer():
import time
start = time.time()
yield
print(f"Time taken: {time.time() - start:.4f}s")
with timer():
total = sum(range(1_000_000))Q18: Python mein type hints kya hain?
Example
from typing import List, Dict, Optional, Union, Tuple, Any, Callable
# Basic type hints
def greet(name: str) -> str:
return f"Hello, {name}!"
def add(a: int, b: int) -> int:
return a + b
def process(data: List[int]) -> Dict[str, int]:
return {"sum": sum(data), "count": len(data)}
# Optional — value ya None
def find_user(user_id: int) -> Optional[dict]:
users = {1: {"name": "Alice"}}
return users.get(user_id)
# Union — multiple types
def flexible(x: Union[int, str]) -> str:
return str(x)
# Modern Python 3.10+ syntax
def modern_func(x: int | str | None) -> int | str:
return x or 0
# Callable
def apply(func: Callable[[int], int], value: int) -> int:
return func(value)
result = apply(lambda x: x * 2, 5)
print(result) # 10
# Benefits of type hints:
# - Better IDE autocompletion
# - Earlier bug detection (mypy)
# - Self-documenting code
# - NOT enforced at runtime (use mypy for static checking)
# Runtime checking with isinstance
def safe_add(a, b):
if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
raise TypeError("Both arguments must be numbers")
return a + b
Q19: Python mein enumerate() aur zip() kya karte hain?
Example
fruits = ["apple", "banana", "cherry"]
prices = [50, 30, 75]
# enumerate() — index ke saath iterate
print("enumerate():")
for i, fruit in enumerate(fruits):
print(f" {i}: {fruit}")
# 0: apple, 1: banana, 2: cherry
# Start index change karo
for i, fruit in enumerate(fruits, start=1):
print(f" {i}. {fruit}")
# 1. apple, 2. banana, 3. cherry
# zip() — parallel iteration
print("\nzip():")
for fruit, price in zip(fruits, prices):
print(f" {fruit}: ₹{price}")
# apple: ₹50, banana: ₹30, cherry: ₹75
# zip creates tuples
pairs = list(zip(fruits, prices))
print(pairs) # [('apple', 50), ('banana', 30), ('cherry', 75)]
# Unzip
f, p = zip(*pairs)
print(list(f)) # ['apple', 'banana', 'cherry']
print(list(p)) # [50, 30, 75]
# zip with different lengths — stops at shortest
a = [1, 2, 3, 4, 5]
b = [10, 20]
print(list(zip(a, b))) # [(1, 10), (2, 20)]
# zip_longest — pad with None
from itertools import zip_longest
print(list(zip_longest(a, b, fillvalue=0))) # Pads shorter list
Q20: Python mein any() aur all() kya karte hain?
Example
numbers = [1, 2, 3, 4, 5]
scores = [95, 88, 72, 91, 65]
# any() — koi bhi ek True hai toh True
print(any(x > 90 for x in scores)) # True (95, 91 > 90)
print(any(x > 100 for x in scores)) # False
# all() — saare True hain tabhi True
print(all(x > 60 for x in scores)) # True (all > 60)
print(all(x > 70 for x in scores)) # False (65 < 70)
# Practical uses
users = [
{"name": "Alice", "active": True},
{"name": "Bob", "active": True},
{"name": "Charlie", "active": False},
]
print(any(u["active"] for u in users)) # True — any active user
print(all(u["active"] for u in users)) # False — not all active
# Validation
def validate_password(password):
checks = [
len(password) >= 8,
any(c.isupper() for c in password),
any(c.islower() for c in password),
any(c.isdigit() for c in password),
]
return all(checks)
print(validate_password("Python123")) # True
print(validate_password("weak")) # False
Q21: Python mein __str__ aur __repr__ ka difference kya hai?
python example
class Student:
def __init__(self, name, marks):
self.name = name
self.marks = marks
def __str__(self):
"""Human-readable representation (for users)"""
return f"{self.name} — Marks: {self.marks}%"
def __repr__(self):
"""Developer-friendly representation (for debugging)"""
return f"Student(name='{self.name}', marks={self.marks})"
s = Student("Alice", 95)
print(str(s)) # Alice — Marks: 95% (uses __str__)
print(repr(s)) # Student(name='Alice', marks=95) (uses __repr__)
# In f-strings
print(f"{s}") # Alice — Marks: 95% (calls __str__)
print(f"{s!r}") # Student(name='Alice', marks=95) (forces __repr__)
# Rule: __repr__ should ideally be eval()-able
s2 = eval(repr(s)) # Should recreate the object
print(s2.name) # AliceQ22: Python mein walrus operator := kya hai?
Example
# Walrus operator (:=) — Python 3.8+
# Assignment Expression — value assign karo AND use karo
# Traditional
data = [1, 2, 3, 4, 5]
n = len(data)
if n > 3:
print(f"List has {n} elements")
# With walrus operator
if (n := len(data)) > 3:
print(f"List has {n} elements")
# In while loop
import random
# Traditional
number = random.randint(1, 10)
while number != 5:
print(f"Got {number}")
number = random.randint(1, 10)
# With walrus
while (number := random.randint(1, 10)) != 5:
print(f"Got {number}")
print("Got 5!")
# In list comprehension with filtering
numbers = [1, 12, 3, 15, 7, 20, 2]
# Only include and double numbers > 10
doubled = [doubled for x in numbers if (doubled := x * 2) > 20]
print(doubled) # [24, 30, 40]
Q23: Python mein dataclasses kya hain?
Example
from dataclasses import dataclass, field
from typing import List
@dataclass
class Product:
name: str
price: float
stock: int = 0
tags: List[str] = field(default_factory=list) # Mutable default
def discount_price(self, percent: float) -> float:
return self.price * (1 - percent / 100)
p = Product("Laptop", 75000.0, 10, ["electronics", "computing"])
print(p) # Product(name='Laptop', price=75000.0, stock=10, tags=['electronics', 'computing'])
print(p.discount_price(10)) # 67500.0
# Auto-generated methods: __init__, __repr__, __eq__
p2 = Product("Laptop", 75000.0, 10, ["electronics", "computing"])
print(p == p2) # True — __eq__ auto-generated!
# Frozen dataclass (immutable)
@dataclass(frozen=True)
class Point:
x: float
y: float
def distance_from_origin(self):
return (self.x**2 + self.y**2) ** 0.5
pt = Point(3.0, 4.0)
print(pt.distance_from_origin()) # 5.0
# pt.x = 10 # FrozenInstanceError!
Q24: Python mein slots kya hain?
Example
import sys
# Regular class — uses __dict__
class RegularClass:
def __init__(self, x, y):
self.x = x
self.y = y
# Class with __slots__ — no __dict__, memory efficient
class SlottedClass:
__slots__ = ['x', 'y']
def __init__(self, x, y):
self.x = x
self.y = y
reg = RegularClass(1, 2)
slotted = SlottedClass(1, 2)
print(f"Regular: {sys.getsizeof(reg.__dict__) + sys.getsizeof(reg)} bytes")
print(f"Slotted: {sys.getsizeof(slotted)} bytes") # Much smaller!
# Can't add new attributes to slotted class
try:
slotted.z = 3 # AttributeError!
except AttributeError as e:
print(f"Error: {e}")
# Benchmark: 1 million instances
import time
start = time.time()
regular_objects = [RegularClass(i, i) for i in range(100000)]
print(f"Regular: {time.time()-start:.3f}s")
start = time.time()
slotted_objects = [SlottedClass(i, i) for i in range(100000)]
print(f"Slotted: {time.time()-start:.3f}s") # Faster!
Q25: Python mein isinstance() aur type() mein kya fark hai?
Example
class Animal:
pass
class Dog(Animal):
pass
dog = Dog()
# type() — exact type check
print(type(dog)) # <class '__main__.Dog'>
print(type(dog) == Dog) # True
print(type(dog) == Animal) # False — Dog is NOT Animal by type()
# isinstance() — inheritance bhi consider karta hai
print(isinstance(dog, Dog)) # True
print(isinstance(dog, Animal)) # True — Dog IS-A Animal!
print(isinstance(dog, object)) # True — everything is object!
# Why isinstance() is better?
# - Supports inheritance
# - Supports multiple types check
print(isinstance(42, (int, float))) # True
print(isinstance("hi", (int, float))) # False
# Use isinstance() for type checking (except when exact type needed)
def process(data):
if isinstance(data, list):
print(f"Processing {len(data)} items")
elif isinstance(data, dict):
print(f"Processing {len(data)} key-value pairs")
elif isinstance(data, (int, float)):
print(f"Processing number: {data}")
else:
raise TypeError(f"Unsupported type: {type(data)}")
process([1, 2, 3])
process({"a": 1})
process(42)
Quick Summary — Interview Tips
python example
# Key concepts to remember:
# 1. Everything in Python is an object
# 2. Python uses duck typing ("if it quacks like a duck...")
# 3. Mutable default arguments are dangerous
# 4. GIL limits CPU parallelism in threading
# 5. Use isinstance() over type()
# 6. Use functools.wraps() in decorators
# 7. Generators save memory for large sequences
# 8. Context managers ensure cleanup with 'with'
# 9. LEGB rule for scope resolution
# 10. Deep copy vs shallow copy for nested objectsInterview Pro Tip: Practice writing code on paper/whiteboard. Explain your thought process aloud. Ask clarifying questions before coding. Think about edge cases. Talk about time and space complexity.
📤 Output Examples — Code Outputs at a Glance
Yahan kuch important code snippets ke outputs hain jo interviews mein frequently puchhe jaate hain:
Example
# Q1: Dynamic Typing
x = [1, 2, 3]
print(type(x))
Output
<class 'list'>
python example
# Q2: Mutable Default Argument Bug
def bad_func(items=[]):
items.append("new")
return items
print(bad_func())
print(bad_func())
print(bad_func())Output
['new'] ['new', 'new'] ['new', 'new', 'new']
Example
# Q9: Shallow vs Deep Copy
import copy
original = {"name": "Alice", "scores": [95, 87]}
shallow = copy.copy(original)
shallow["scores"].append(100)
print(original["scores"])
Output
[95, 87, 100]
Example
# Q10: is vs ==
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)
print(a is b)
Output
True False
python example
# Q13: LEGB Scope
x = "Global"
def outer():
x = "Enclosing"
def inner():
x = "Local"
print(f"Inner: {x}")
inner()
print(f"Outer: {x}")
outer()
print(f"Global: {x}")Output
Inner: Local Outer: Enclosing Global: Global
python example
# Q16: __new__ vs __init__
class MyClass:
def __new__(cls, *args, **kwargs):
print("__new__ called")
return super().__new__(cls)
def __init__(self, value):
print(f"__init__ called with {value}")
obj = MyClass(42)Output
__new__ called __init__ called with 42
Example
# Q20: any() and all()
scores = [95, 88, 72, 91, 65]
print(any(x > 90 for x in scores))
print(all(x > 70 for x in scores))
Output
True False
Example
# Q22: Walrus Operator
data = [1, 2, 3, 4, 5]
if (n := len(data)) > 3:
print(f"List has {n} elements")
Output
List has 5 elements
python example
# Q25: isinstance vs type
class Animal: pass
class Dog(Animal): pass
dog = Dog()
print(type(dog) == Animal)
print(isinstance(dog, Animal))Output
False True
⚠️ Common Mistakes
Python interviews mein yeh galtiyan bahut common hain — inse bachna seekho! 🚫
1. Mutable Default Arguments Use Karna ❌
Example
# ❌ WRONG — mutable default argument
def add_item(item, items=[]):
items.append(item)
return items
print(add_item("a")) # ['a']
print(add_item("b")) # ['a', 'b'] — Bug! Same list reuse ho rahi hai
# ✅ CORRECT — None use karo
def add_item(item, items=None):
if items is None:
items = []
items.append(item)
return items
Output
['a'] ['a', 'b']
Hindi: Mutable objects (list, dict, set) ko kabhi function default argument mein mat do. Python function define hone pe ek baar hi default evaluate karta hai — har call pe nahi!
2. is aur == Confuse Karna ❌
python example
# ❌ WRONG
name = "hello"
if name is "hello": # Identity check — unreliable!
print("Match")
# ✅ CORRECT
if name == "hello": # Value check — reliable!
print("Match")Hindi:issirfNone,True,Falseke saath use karo. Baaki sab ke liye==use karo.ismemory address compare karta hai, value nahi!
3. Shallow Copy samajh ke Deep Copy expect karna ❌
Example
# ❌ Problem
import copy
original = [[1, 2], [3, 4]]
shallow = original.copy()
shallow[0].append(99)
print(original) # [[1, 2, 99], [3, 4]] — Original bhi change ho gaya!
# ✅ Solution — deep copy use karo nested objects ke liye
deep = copy.deepcopy(original)
Output
[[1, 2, 99], [3, 4]]
Hindi: Jab bhi nested objects (list of lists, dict of dicts) ho, always copy.deepcopy() use karo agar independent copy chahiye.4. Exception mein bare except: use karna ❌
python example
# ❌ WRONG — catches EVERYTHING including KeyboardInterrupt
try:
result = 10 / 0
except:
print("Something went wrong")
# ✅ CORRECT — specific exceptions catch karo
try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Math error: {e}")
except Exception as e:
print(f"Unexpected: {e}")Hindi: Bareexcept:kabhi mat likho — yehSystemExitaurKeyboardInterruptbhi catch kar leta hai. Hamesha specific exception name lo.
5. Loop mein list modify karna ❌
Example
# ❌ WRONG — iterating while modifying
numbers = [1, 2, 3, 4, 5, 6]
for n in numbers:
if n % 2 == 0:
numbers.remove(n) # Unpredictable behavior!
print(numbers) # [1, 3, 5] — lucky, but NOT guaranteed!
# ✅ CORRECT — new list banao
numbers = [1, 2, 3, 4, 5, 6]
numbers = [n for n in numbers if n % 2 != 0]
print(numbers) # [1, 3, 5]
Output
[1, 3, 5]
Hindi: Jis list pe iterate kar rahe ho, usiko modify mat karo. List comprehension ya copy pe iterate karo.
6. Global variables overuse karna ❌
python example
# ❌ WRONG — sab kuch global
count = 0
def increment():
global count
count += 1
# ✅ CORRECT — encapsulation use karo
def make_counter():
count = 0
def increment():
nonlocal count
count += 1
return count
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2Output
1 2
Hindi: global ka overuse code ko unpredictable banata hai. Closures, classes ya function parameters prefer karo.7. String concatenation loop mein karna ❌
python example
# ❌ SLOW — O(n²) time complexity
result = ""
for i in range(10000):
result += str(i) # Har iteration mein new string banati hai!
# ✅ FAST — O(n) time complexity
result = "".join(str(i) for i in range(10000))Hindi: Strings immutable hain —+=har baar new string create karta hai. Large data ke liye"".join()use karo — 10x faster hai!
✅ Key Takeaways
Interview mein yeh points yaad rakho — yeh foundation hai Python mastery ka! 💡
- 🐍 Everything is an Object — Python mein integers, functions, classes sab objects hain.
id(),type()se verify karo.
- 🔒 Mutable vs Immutable samjho — Yeh concept interviews ka bread and butter hai. Lists mutable hain, tuples/strings immutable. Default arguments mein mutable objects = bug!
- 🧠 GIL ka impact jaano — CPU-bound tasks ke liye
multiprocessinguse karo, I/O-bound ke liyethreadingyaasyncio. GIL sirf CPython mein hai.
- 🎯 LEGB Rule yaad rakho — Variable lookup order: Local → Enclosing → Global → Built-in.
globalaurnonlocalkeywords kab use karne hain, yeh clear hona chahiye.
- 📦 Generators memory bachate hain — Large datasets ke liye generators (
yield) use karo, puri list memory mein load mat karo. Lazy evaluation = efficient!
- 🛡️ Context Managers (
with) cleanup ensure karte hain — File handling, DB connections, locks — hameshawithstatement use karo. Resource leaks se bachao!
- 🎨 Decorators samjho aur likho —
@functools.wrapshamesha use karo. Decorator = function jo function ko modify kare bina original code change kiye.
- 📐 Type Hints code quality badhate hain — Runtime pe enforce nahi hote, but IDE support aur
mypyse bugs pakad sakte ho before deployment.
- 🔄 Deep Copy vs Shallow Copy — Nested objects ke saath kaam karte waqt always
copy.deepcopy()consider karo. Interview mein yeh tricky question bahut aata hai.
- 🏗️ OOP concepts clear rakho —
__init__vs__new__,@classmethodvs@staticmethod,__str__vs__repr__— yeh basics interviews mein 100% puchhe jaate hain.
❓ FAQ
Python interview preparation ke liye kitna time chahiye?
Agar aapko Python basics aate hain, toh 2-3 weeks ka focused preparation kaafi hai. Daily 2-3 questions practice karo with code. Agar beginner ho toh 1-2 months plan karo. Concepts + coding dono parallel chale! 📅
Kya Python interviews mein DSA bhi puchha jaata hai?
Haan, bilkul! 🎯 Especially product-based companies (Google, Amazon, Microsoft) mein Data Structures + Algorithms Python mein solve karne hote hain. Arrays, linked lists, trees, graphs, dynamic programming — sab cover karo. Python-specific DSA (deque, heapq, bisect) bhi jaano.
Freshers ke liye sabse important Python topics kaun se hain?
Freshers ke liye yeh topics must-know hain: (1) Data types & mutability, (2) List/Dict comprehensions, (3) Functions — *args, **kwargs, lambda, (4) OOP basics — inheritance, polymorphism, (5) Exception handling, (6) File I/O, (7) Basic modules — os, sys, json. Yeh 7 topics cover karo, interview mein 80% questions in se aayenge! 📚
Python 2 vs Python 3 — interview mein kya puchha jaata hai?
Ab zyada companies Python 3 pe focus karti hain. Main differences yaad rakho: print() function vs statement, integer division (/ vs //), range() vs xrange(), Unicode strings default in Python 3, input() behavior. But Python 2 ko deeply padhne ki zaroorat nahi — just key differences jaano. 🔄
Remote Python interviews mein kya different hota hai?
Remote interviews mein usually ek online coding platform milta hai (HackerRank, CodeSignal, CoderPad). Tips: (1) Apna mic/camera check karo, (2) Screen sharing smooth honi chahiye, (3) Code likhte waqt think aloud — apni thought process explain karo, (4) Edge cases pehle discuss karo, (5) IDE shortcuts yaad rakho. Practice karo online editors mein coding! 💻
Python mein design patterns puchhe jaate hain kya?
Senior/mid-level roles mein haan! Common patterns: Singleton (__new__), Factory, Observer, Decorator (already Python mein built-in), Iterator (__iter__/__next__), Context Manager (__enter__/__exit__). Freshers ke liye basic Singleton aur Factory enough hai. 🏛️
Interview mein code run nahi ho raha — kya karu?
Don't panic! 😅 (1) Pehle logic explain karo interviewer ko, (2) Dry run karo mentally with a small example, (3) Edge cases check karo — empty input, None, negative numbers, (4) Syntax errors dhundo — indentation, colons, parentheses. Interviewer approach dekhta hai, perfect code zaroori nahi!
Kya frameworks (Django/Flask) ke questions bhi aate hain?
Yeh role pe depend karta hai. Backend Developer role mein Django/Flask zaroor puchha jaata hai. But pure Python Developer role mein core Python + OOP + DSA focus hota hai. Job description carefully padho — usme clearly likha hota hai kya expect hai. Both scenarios ke liye core Python strong hona mandatory hai! 🎪
🎯 Interview Tips
Python interview crack karne ke liye yeh actionable tips follow karo! 🚀
1. 📝 Pehle Approach Explain Karo, Phir Code Likho
Interviewer ko seedha code mat dikhao. Pehle bolo: "Main yeh approach use karunga because..." — isse interviewer ko lagta hai ki aap think kar rahe ho, blindly code nahi likh rahe.
2. 🧪 Edge Cases Pehle Identify Karo
Code likhne se pehle bolo: "Edge cases honge — empty list, None input, negative numbers, duplicate values." Yeh interviewer ko impress karta hai because most candidates yeh skip kar dete hain.
3. ⏱️ Time & Space Complexity Batao
Har solution ke baad bolo: "Yeh O(n) time aur O(1) space hai." Agar interviewer nahi puchhe tab bhi voluntarily batao — yeh shows depth of understanding.
4. 🐍 Pythonic Code Likho
Example
# ❌ Non-Pythonic
result = []
for i in range(10):
if i % 2 == 0:
result.append(i * i)
# ✅ Pythonic
result = [i * i for i in range(10) if i % 2 == 0]
Interviewer Pythonic code dekhna chahta hai — list comprehensions, f-strings, enumerate(), zip() use karo!
5. 🗣️ Think Aloud — Chup Mat Raho
Silence = red flag in interviews. Sochte waqt bhi bolo: "Main soch raha hoon ki yahan dictionary use karun ya set..." — yeh communication skills demonstrate karta hai.
6. 🔄 Brute Force Pehle, Optimize Baad Mein
First working solution do (even if O(n²)), phir bolo: "Ab isko optimize karta hoon O(n) mein." Yeh shows iterative thinking — interviewers love this approach!
7. 📚 Standard Library Jaano
collections (Counter, defaultdict, deque), itertools (combinations, permutations), functools (lru_cache, reduce) — yeh modules interview mein bahut kaam aate hain. Inke 2-3 use cases yaad rakho.
8. ❓ Clarifying Questions Puchho
Question sunke seedha code mat likho! Puchho: "Input ka type kya hoga? Negative numbers aa sakte hain? Output sorted chahiye? Duplicates handle karne hain?" — yeh senior-level thinking dikhata hai.
9. 🧩 Real Projects ka Reference Do
Jab bhi concept explain karo, real example do: "Maine apne project mein decorators use kiye the for caching API responses" — yeh shows practical experience, not just textbook knowledge.
10. 🎯 Mock Interviews Practice Karo
Friends ke saath ya platforms (Pramp, Interviewing.io) pe weekly mock interviews do. Camera on karke practice karo — real interview jaise environment create karo. Practice mein nervous feel ho, toh real mein confident lagoge! 💪
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Interview Questions and Answers.
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, interview, preparation, questions
Related Python Master Course Topics
Continue learning this concept
Interview PreparationPython Coding Interview QuestionsTop 25+ Python coding interview problems with solutions - arrays, strings, linked lists, sorting, searching, dynamic programming, and algorithmic challenges with Hindi explanations.Interview PreparationPython OOP Interview Questions and AnswersTop 25+ Python OOP interview questions covering classes, objects, inheritance, polymorphism, encapsulation, abstraction, decorators, and design patterns with Hindi explanations.Interview PreparationPython Master CheatsheetComprehensive Python cheatsheet covering all important syntax, data structures, functions, OOP, libraries, and interview tips in one place with Hindi explanations.Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.Advanced PythonAdvanced Python DecoratorsMaster advanced Python decorators including decorator factories, class decorators, stacking decorators, functools.wraps, parameterized decorators, and real-world patterns.