Top 70 Python Interview Questions & Answers India 2026

# Bug: default list is created ONCE, shared across all calls
def add_item(item, lst=[]):
    lst.append(item)
    return lst

# Fix: use None as default
def add_item(item, lst=None):
    if lst is None: lst = []
    lst.append(item)
    return lst

import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0][0] = 99
# shallow[0][0] is also 99 (shared reference!)
# deep[0][0] is still 1 (independent copy)

# List comprehension: creates a list in memory
squares = [x**2 for x in range(10) if x % 2 == 0]

# Dict comprehension
word_len = {word: len(word) for word in ['hello', 'world']}

# Generator expression: lazy evaluation, one value at a time
gen = (x**2 for x in range(1000000))  # uses almost no memory

def greet(*args, **kwargs):
    for name in args:
        print(f"Hello, {name}!")
    for key, val in kwargs.items():
        print(f"{key}: {val}")

greet('Alice', 'Bob', role='engineer', city='Bangalore')

class Vector:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, other): return Vector(self.x+other.x, self.y+other.y)
    def __repr__(self): return f"Vector({self.x}, {self.y})"
    def __len__(self): return int((self.x**2 + self.y**2)**0.5)
    def __eq__(self, other): return self.x==other.x and self.y==other.y

class Date:
    def __init__(self, day, month, year): ...

    @classmethod
    def from_string(cls, s):  # factory method
        d, m, y = map(int, s.split('-'))
        return cls(d, m, y)

    @staticmethod
    def is_leap_year(year):  # utility, no state needed
        return year % 4 == 0

import functools, time

def timer(func):
    @functools.wraps(func)  # preserves __name__, __doc__
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end-start:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

def fibonacci():
    a, b = 0, 1
    while True:
        yield a  # pauses here, returns a
        a, b = b, a + b  # resumes here on next()

gen = fibonacci()
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 1

# Using class (__enter__ / __exit__)
class Timer:
    def __enter__(self):
        import time
        self.start = time.perf_counter()
        return self
    def __exit__(self, *args):
        print(f"Elapsed: {time.perf_counter()-self.start:.4f}s")

# Using @contextmanager decorator (simpler)
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    yield
    print(f"Elapsed: {time.perf_counter()-start:.4f}s")

import asyncio

async def fetch_data(url):
    await asyncio.sleep(1)  # simulates I/O
    return f"data from {url}"

async def main():
    results = await asyncio.gather(
        fetch_data("url1"),
        fetch_data("url2"),  # runs concurrently!
    )
    return results

# N+1 problem: 1 query for all authors + N queries for books
authors = Author.objects.all()
for author in authors:
    print(author.books.all())  # query per author!

# Fix with select_related (JOINs, for ForeignKey/OneToOne)
authors = Author.objects.prefetch_related('books').all()
# OR for forward FK: select_related('publisher')

# Instead of:
data = file.read(1024)
while data:
    process(data); data = file.read(1024)

# With walrus:
while data := file.read(1024):
    process(data)