Python Interview Questions and Answers (2026 Master Guide)

Q1. Explain the difference between Python list and tuple with memory implications.

Foundation • 0-2 Yrs

Lists are mutable sequences stored as dynamic over-allocated arrays in memory, allowing items to be appended or modified in-place with O(1) amortized time. Tuples are immutable and allocated with fixed memory blocks, making them faster to iterate over and usable as dictionary keys. Tuples also benefit from Python's internal memory caching (free lists).

Q2. How does memory management work in Python? Explain Reference Counting and Garbage Collection.

Foundation • 0-2 Yrs

Python utilizes two primary mechanisms: Reference Counting and a Generational Cyclic Garbage Collector. Every object maintains an ob_refcnt counter; when this reaches zero, memory is immediately deallocated. To resolve cyclic references (e.g., objects pointing to each other), Python's GC runs across three generations (0, 1, 2) based on object survival thresholds.

Q3. What are Python decorators and how do you write a function with *args and **kwargs?

Foundation • 0-2 Yrs

A decorator is a callable that takes another function as an argument, extends its behavior without altering its source code, and returns a callable. Using *args allows passing variable positional arguments as a tuple, while **kwargs allows variable keyword arguments as a dictionary, making decorators flexible across any function signature.

Q4. Differentiate between '==' and 'is' in Python with practical examples.

Foundation • 0-2 Yrs

The '==' operator evaluates value equality (comparing contents by calling the __eq__() dunder method), whereas 'is' evaluates identity equality (verifying if both references point to the exact same memory address using id()). For example, small integers (-5 to 256) are interned so 'a is b' returns True, but newly instantiated lists with identical items return False for 'is'.

Q5. What is a generator in Python and how does 'yield' differ from 'return'?

Foundation • 0-2 Yrs

A generator is a function that produces a sequence of values on demand using the 'yield' keyword instead of returning a complete list. While 'return' terminates function execution and releases local stack variables, 'yield' pauses the function, saves its execution state, and yields control back to the caller, enabling memory-efficient iteration over massive datasets.

Q6. Explain Python's LEGB rule for variable scope resolution.

Foundation • 0-2 Yrs

LEGB defines the hierarchy Python searches when resolving variable names: Local (inside current function), Enclosing (in enclosing functions for nested scopes), Global (module-level namespace), and Built-in (predefined names in the builtins module like len, range). Variables can be modified in global scope using 'global' or in enclosing scope using 'nonlocal'.

Q7. What is the difference between shallow copy and deep copy in the 'copy' module?

Foundation • 0-2 Yrs

A shallow copy (copy.copy()) constructs a new compound object and inserts references to the original object's elements; changes to nested mutable objects affect both copies. A deep copy (copy.deepcopy()) recursively duplicates all nested objects, creating an entirely independent clone with zero shared references.

Q8. How do lambda functions work and what are their limitations?

Foundation • 0-2 Yrs

Lambda functions are anonymous, inline functions created with the 'lambda' keyword, taking multiple arguments but limited to a single evaluated expression. They cannot contain statements (like assignments, loops, or try-except blocks) or annotations, and are primarily used in functional contexts like map(), filter(), and sorted(key=...).

Q9. What is the purpose of the '__init__' and '__new__' methods in Python classes?

Foundation • 0-2 Yrs

'__new__' is the static constructor method responsible for creating and returning a new instance of a class (allocating memory). '__init__' is the initializer method called immediately after '__new__' to set up instance attributes and state. Customizing '__new__' is critical when implementing Singletons or subclassing immutable types like tuple or int.

Q10. How does exception handling work with 'try', 'except', 'else', and 'finally'?

Foundation • 0-2 Yrs

Code prone to runtime errors runs in the 'try' block. If an exception occurs, matching 'except' blocks catch it. If no exception occurs, the 'else' block executes. The 'finally' block always executes regardless of whether an exception occurred, was caught, or unhandled, making it ideal for resource cleanup like closing files or database cursors.

Q11. What are list comprehensions and when should they be avoided?

Foundation • 0-2 Yrs

List comprehensions provide a concise syntactic construct [expr for item in iterable if cond] to create lists. They execute faster than equivalent for-loops because bytecode iteration happens at C-level speed. However, they should be avoided when logic becomes deeply nested (reducing readability) or when dealing with massive datasets where generator expressions save memory.

Q12. Explain the concept of Duck Typing in Python.

Foundation • 0-2 Yrs

Duck typing is a dynamic typing philosophy summarized as: 'If it walks like a duck and quacks like a duck, it is a duck.' Rather than inspecting an object's explicit type or inheritance hierarchy (isinstance), Python checks whether the required methods and attributes are present at runtime when invoked.

Q13. How do dictionary lookups achieve O(1) average time complexity?

Foundation • 0-2 Yrs

Python dictionaries use compact hash tables. Keys are hashed via hash(), which determines the slot index in the table. Collisions are handled via open addressing with pseudo-random probing. Starting in Python 3.7, dictionaries maintain insertion order using a split indices array and an entries array, achieving O(1) average lookup, insertion, and deletion.

Q14. What are Python built-in data types, and which ones are immutable?

Foundation • 0-2 Yrs

Built-in types include numeric (int, float, complex), sequence (str, list, tuple, range), mapping (dict), set (set, frozenset), and boolean (bool). Immutable types cannot be altered after creation and include int, float, str, tuple, frozenset, and bytes. Modifying them creates a new object in memory.

Q15. What is the difference between 'append()' and 'extend()' methods on lists?

Foundation • 0-2 Yrs

'append(x)' adds its argument as a single element to the end of the list, increasing list length by 1 even if x is an iterable. 'extend(iterable)' iterates over its argument and appends each element individually, increasing the list length by the length of the iterable.

Q16. Explain the Global Interpreter Lock (GIL) and its evolution in Python 3.13 free-threaded builds.

Experienced • 3-5+ Yrs

The GIL is a mutex that protects Python objects from concurrent corruption by ensuring only one native thread executes Python bytecode at any given moment. In CPU-bound multithreaded applications, threads contest for the GIL, degrading multicore throughput. Python 3.13 introduces experimental free-threaded builds (PEP 703) that remove the GIL via mimalloc thread-safe memory allocation, biased locking, and immortal objects.

Q17. How does Python's 'asyncio' event loop achieve concurrency compared to multiprocessing?

Experienced • 3-5+ Yrs

Asyncio provides cooperative single-threaded concurrency using coroutines (async/await) and an event loop running non-blocking asynchronous I/O multiplexing (epoll/kqueue). It has near-zero context-switching overhead and can handle 100,000+ open sockets. Multiprocessing bypasses the GIL by spawning separate OS processes with independent memory spaces, ideal for CPU-intensive parallel computing.

Q18. How do Python Descriptors work and how are they used in properties and ORMs?

Experienced • 3-5+ Yrs

Descriptors are classes implementing at least one of the protocol methods: __get__(), __set__(), or __delete__(). When an attribute on an object is accessed, Python's attribute lookup checks if the attribute is in the class dictionary and implements descriptor methods. The built-in @property decorator, classmethod, and ORM fields (like Django models) are built entirely on descriptors.

Q19. Explain Metaclasses in Python and how '__init_subclass__' serves as a modern alternative.

Experienced • 3-5+ Yrs

A metaclass is the 'class of a class' (defaulting to 'type') that defines how classes are constructed, validated, and registered. In Python 3.6+, '__init_subclass__' provides a cleaner, simpler alternative to full metaclasses: whenever a class is subclassed, the parent's __init_subclass__() hook is automatically called with subclass keyword arguments.

Q20. How does method resolution order (MRO) work under the C3 Linearization algorithm?

Experienced • 3-5+ Yrs

Python resolves inheritance hierarchies in multiple inheritance using C3 Linearization. It guarantees monotonicity (parents are evaluated in declaration order) and ensures subclasses precede their parents. You can inspect any class's MRO using Class.mro() or Class.__mro__. If a valid linearization cannot be constructed, Python raises a TypeError at class definition time.

Q21. Explain context managers and how to implement one using both a class and '@contextmanager'.

Experienced • 3-5+ Yrs

Context managers govern resource acquisition and release using the 'with' statement. As a class, it implements '__enter__()' (acquires resource, returns target) and '__exit__(exc_type, exc_val, exc_tb)' (handles exceptions and cleanup). Using contextlib.@contextmanager, a generator function yields the resource between a try and finally block.

Q22. What are weak references in Python ('weakref' module) and why are they used?

Experienced • 3-5+ Yrs

Weak references allow referencing an object without increasing its reference count (ob_refcnt). When the only remaining references to an object are weak references, garbage collection proceeds and frees the object. Weak references are essential for implementing in-memory caches, circular graphs, and event-listener registries without leaking memory.

Q23. How do you profile memory leaks and CPU bottlenecks in production Python services?

Experienced • 3-5+ Yrs

For CPU bottlenecks, use cProfile to generate call graphs and py-spy for low-overhead sampling profilers in production. For memory leaks, use the 'tracemalloc' module to capture memory allocation snapshots and diff them, or 'objgraph' to visualize object growth and identify cyclic references that escape GC collection.

Q24. Explain dataclasses vs Pydantic models for data validation and schema serialization.

Experienced • 3-5+ Yrs

Python dataclasses (PEP 557) provide boilerplate-free classes with auto-generated __init__, __repr__, and __eq__ methods without runtime type enforcement. Pydantic leverages Python type hints for runtime coercion, strict schema validation, JSON serialization, and OpenAPI generation, executing up to 20x faster in v2 via its Rust-based core.

Q25. How do you optimize high-throughput Python API services using Gunicorn and Uvicorn workers?

Experienced • 3-5+ Yrs

High-throughput ASGI frameworks (FastAPI) are deployed using Gunicorn as a process manager running multiple Uvicorn worker classes (UvicornWorker). Sizing follows (2 * CPU cores) + 1 workers. UVloop replaces standard asyncio event loop with libuv C bindings, boosting I/O processing speed to over 50,000 requests/sec.

Q26. How does monkey patching work in Python, and what architectural dangers does it introduce?

Experienced • 3-5+ Yrs

Monkey patching is dynamically modifying modules, classes, or functions at runtime without altering the original source code. While useful in unit test mocking (unittest.mock.patch), doing so in production introduces non-deterministic bugs, breaks static analysis, compromises type checkers, and complicates debugging because method behaviors change unexpectedly.

Q27. What is the difference between 'multiprocessing.Pool' and 'concurrent.futures.ProcessPoolExecutor'?

Experienced • 3-5+ Yrs

Multiprocessing.Pool is the classic interface offering map(), apply(), and imap() methods. Concurrent.futures.ProcessPoolExecutor is the modern, unified high-level API conforming to PEP 3148 that returns Future objects, standardizing code between ThreadPoolExecutor and ProcessPoolExecutor with support for as_completed() and callbacks.

Q28. Explain structural pattern matching ('match-case') introduced in Python 3.10.

Experienced • 3-5+ Yrs

Structural pattern matching provides expressive destructuring and conditional branching. Unlike simple C switch-statements, match-case matches literal values, sequences, mappings, class patterns, and guards ('if' conditions), capturing variables dynamically and extracting nested attributes in a single statement.

Q29. How do '__slots__' optimize memory usage in high-volume Python classes?

Experienced • 3-5+ Yrs

By default, Python instances store attributes in a dynamic dictionary (__dict__), which consumes significant memory overhead. Specifying '__slots__ = ("attr1", "attr2")' tells Python to allocate a fixed-size array for attributes, preventing __dict__ creation and reducing instance memory consumption by up to 50% for millions of objects.

Q30. How do you implement a distributed task queue architecture using Celery and Redis in Python?

Experienced • 3-5+ Yrs

Celery worker processes consume asynchronous tasks pushed into a message broker (Redis/RabbitMQ). Tasks are decorated with @app.task. The main web application dispatches tasks asynchronously using .delay() or .apply_async(), and task results, retries, exponential backoffs, and dead-letter queues are stored in the Redis result backend.

Q31. Write a Python function to find the first non-repeating character in a string with O(N) complexity.

Live Coding Challenge

We count frequencies using collections.Counter or an ordered dictionary in O(N) time, and then perform a single pass over the original string to find the first character with a count of 1.

from collections import Counter

def first_non_repeating_char(s: str) -> str:
    freq = Counter(s)
    for char in s:
        if freq[char] == 1:
            return char
    return ''

# Example Test
print(first_non_repeating_char('swiss'))  # Output: 'w'

Q32. Implement an LRU (Least Recently Used) Cache in Python using collections.OrderedDict.

Live Coding Challenge

An LRU cache maintains items in order of recent access. We use OrderedDict to achieve O(1) gets and puts, calling move_to_end() on access and popitem(last=False) to evict the oldest item when capacity is exceeded.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

Q33. Write a decorator in Python that measures execution time and retries on failure up to N times.

Live Coding Challenge

We define a parameterized decorator that wraps the target function with functools.wraps, catches specified exceptions, sleeps with exponential backoff, and re-raises if all retries fail.

import time
from functools import wraps

def retry_with_timer(max_retries=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            start_time = time.perf_counter()
            while retries < max_retries:
                try:
                    result = func(*args, **kwargs)
                    elapsed = time.perf_counter() - start_time
                    print(f'{func.__name__} executed in {elapsed:.4f}s')
                    return result
                except Exception as e:
                    retries += 1
                    print(f'Attempt {retries} failed: {e}. Retrying...')
                    time.sleep(delay * retries)
            return func(*args, **kwargs)
        return wrapper
    return decorator

Q34. Write a Python function to flatten a deeply nested dictionary into dot-separated keys.

Live Coding Challenge

We recursively traverse dictionary items, accumulating parent keys with a separator until primitive values are reached, then write them into a flat dictionary.

def flatten_dict(d, parent_key='', sep='.'):
    items = []
    for k, v in d.items():
        new_key = f'{parent_key}{sep}{k}' if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

# Example
nested = {'user': {'name': 'Arjun', 'address': {'city': 'Noida'}}}
print(flatten_dict(nested))
# Output: {'user.name': 'Arjun', 'user.address.city': 'Noida'}

Q35. Solve the Two-Sum problem in Python in O(N) time complexity.

Live Coding Challenge

We maintain a hash map of complements (target - num). For each number, if its complement exists in the map, we return both indices immediately; otherwise, we record the current number's index.

def two_sum(nums, target):
    seen = {}
    for idx, num in enumerate(nums):
        diff = target - num
        if diff in seen:
            return [seen[diff], idx]
        seen[num] = idx
    return []

# Example
print(two_sum([2, 7, 11, 15], 9))  # Output: [0, 1]

Q36. Write a Python function to merge overlapping intervals.

Live Coding Challenge

First sort intervals by start time. Iterate through sorted intervals: if the current interval starts before or at the end of the previous interval, merge them by setting the end to max(prev.end, current.end).

def merge_intervals(intervals):
    if not intervals:
        return []
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    for current in intervals[1:]:
        prev = merged[-1]
        if current[0] <= prev[1]:
            prev[1] = max(prev[1], current[1])
        else:
            merged.append(current)
    return merged

# Example
print(merge_intervals([[1,3],[2,6],[8,10],[15,18]])) 
# Output: [[1, 6], [8, 10], [15, 18]]

Q37. Implement a thread-safe Singleton pattern in Python.

Live Coding Challenge

We implement a thread-safe Singleton using a class with a threading.Lock and double-checked locking inside the __new__() method.

import threading

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            with cls._lock:
                if not cls._instance:
                    cls._instance = super().__new__(cls)
        return cls._instance

Q38. Write a Python generator that yields the Fibonacci sequence up to N elements.

Live Coding Challenge

Using a generator function with yield allows producing infinite or bounded Fibonacci numbers with O(1) auxiliary memory.

def fibonacci_gen(n):
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

# Example
print(list(fibonacci_gen(7)))  # Output: [0, 1, 1, 2, 3, 5, 8]

Q39. Write a Python function to validate whether a string contains balanced parentheses, brackets, and braces.

Live Coding Challenge

We push open brackets to a stack and pop when matching closing brackets occur. If an unmatched closing bracket appears or the stack is non-empty at the end, it is invalid.

def is_valid_parentheses(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping.values():
            stack.append(char)
        elif char in mapping:
            if not stack or stack.pop() != mapping[char]:
                return False
    return len(stack) == 0

# Example
print(is_valid_parentheses('({[]})'))  # True
print(is_valid_parentheses('([)]'))    # False

Q40. Write an asyncio script in Python that downloads multiple URLs concurrently with rate limiting.

Live Coding Challenge

We use asyncio.Semaphore to bound concurrent HTTP requests, gathering results with asyncio.gather().

import asyncio
import aiohttp

async def fetch_url(session, url, semaphore):
    async with semaphore:
        async with session.get(url) as response:
            return url, response.status

async def fetch_all(urls, limit=5):
    semaphore = asyncio.Semaphore(limit)
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, u, semaphore) for u in urls]
        return await asyncio.gather(*tasks)

# Run with: asyncio.run(fetch_all(['https://4achievers.com']))