Top 50 Python Interview Questions & Answers for 2026

Q1. What is Python and what are its key features?

Python is a high-level, interpreted, dynamically-typed, general-purpose programming language. Its key features include: readable syntax inspired by English, dynamic typing, automatic memory management via garbage collection, an extensive standard library ("batteries included"), support for multiple programming paradigms (procedural, OOP, functional), and a massive ecosystem of third-party packages (PyPI).

Q2. What is the difference between a list, tuple, and set in Python?

Q3. What is the difference between == and is in Python?

== checks value equality — whether two objects have the same value. is checks identity — whether two variables point to the exact same object in memory. Never use is to compare strings or integers beyond small int caching (-5 to 256).

Q4. What is a Python dictionary and what is its time complexity?

A dictionary is an unordered (insertion-ordered since Python 3.7) collection of key-value pairs implemented as a hash table. Average-case time complexity: O(1) for get, set, and delete operations. Worst-case is O(n) due to hash collisions, though this is rare with Python's hash randomization.

Q5. Explain Python's mutable vs immutable types.

Immutable types (int, float, str, tuple, frozenset, bytes) cannot be changed after creation — modifying them creates a new object. Mutable types (list, dict, set, bytearray) can be changed in-place. This distinction is critical: mutable default arguments in functions are a classic Python interview gotcha.

Q6. What is the difference between __str__ and __repr__?

__str__ is meant to return a human-readable, informal string representation (used by print()). __repr__ returns an official, unambiguous representation ideally that could recreate the object (used in the REPL and logs). If only __repr__ is defined, it also serves as the fallback for __str__.

Q7. What is Python's MRO (Method Resolution Order)?

MRO defines the order in which Python searches for methods in a class hierarchy during multiple inheritance. Python uses the C3 Linearization algorithm. You can inspect it with ClassName.__mro__. Understanding MRO is essential to avoid the diamond problem in multiple inheritance scenarios.

Q8. What are @classmethod, @staticmethod, and instance methods?

Q9. What is the difference between @property and a regular attribute?

@property allows you to define a method that is accessed like an attribute, enabling computed values, validation, and encapsulation. You can pair it with @attr.setter to control writes. Regular attributes are just stored data — no logic on access.

Q10. What is the purpose of __slots__?

__slots__ restricts a class to a fixed set of attributes, bypassing the default per-instance __dict__. This reduces memory usage significantly for classes with many instances — a commonly asked senior-level Python optimization question.

Q11. How does Python's collections.defaultdict work?

defaultdict is a dict subclass that calls a factory function to supply missing values. Instead of a KeyError, accessing a missing key creates it with the default: defaultdict(list) auto-creates an empty list, perfect for grouping items.

Q12. When would you use a deque over a list?

Use collections.deque when you need O(1) append and pop from both ends. A regular list's insert(0, x) and pop(0) are O(n) because all elements shift. deque is ideal for sliding window problems, BFS queues, and LRU cache implementations.

Q13. How does Python's heapq module work?

Python's heapq provides a min-heap implementation. heappush and heappop run in O(log n). For a max-heap, negate values before pushing. Common use-cases: K-th largest/smallest element, merge K sorted lists, and top-N problems.

Q14. What is a Python frozenset and when do you use it?

A frozenset is an immutable version of set. Because it's hashable, it can be used as a dictionary key or as an element of another set — unlike a regular mutable set. Use it when you need set operations on fixed data.

Q15. What is a Python decorator? Write one from scratch.

A decorator is a function that takes another function as input, extends its behavior, and returns a new function — without modifying the original source code. Example:

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time()-start:.4f}s")
        return result
    return wrapper

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

Q16. What is a Python generator? What is the difference between return and yield?

A generator is a function that uses yield instead of return to produce a sequence of values lazily — one at a time — saving memory. yield suspends execution and saves state; calling next() resumes it. Perfect for large data streams, infinite sequences, and pipeline processing.

Q17. Explain Python closures and the nonlocal keyword.

A closure is a nested function that retains access to variables from its enclosing scope even after the outer function has returned. The nonlocal keyword allows a nested function to modify (not just read) variables in the enclosing scope — without making them global. Closures are the foundation of decorators.

Q18. What is the difference between map(), filter(), and list comprehension?

map(fn, iterable) applies a function to every element. filter(fn, iterable) returns elements where fn returns truthy. Both return lazy iterators. List comprehensions are generally preferred in modern Python for clarity: [fn(x) for x in iterable].

Q19. What is Python's GIL (Global Interpreter Lock)?

The GIL is a mutex in CPython that allows only one thread to execute Python bytecode at a time, even on multi-core CPUs. This makes threading in Python unsuitable for CPU-bound parallelism — use multiprocessing instead. The GIL does not affect I/O-bound concurrency (asyncio, threading with I/O).

Q20. When should you use threading vs multiprocessing vs asyncio?

Q21. What is async def and await in Python?

async def defines a coroutine — a function that can be suspended. await suspends the coroutine until the awaited task completes, giving control back to the event loop. This enables writing concurrent I/O code in a readable, sequential style without callbacks.

Q22. How does Python handle memory management?

Python uses reference counting as the primary mechanism — when an object's reference count drops to zero, it is deallocated. A supplementary cyclic garbage collector handles circular references. The gc module lets you interact with it. Python also maintains a private heap for all Python objects.

Q23. What is the difference between copy.copy() and copy.deepcopy()?

copy.copy() creates a shallow copy — a new object but nested objects are still referenced (shared). copy.deepcopy() creates a fully independent copy including all nested objects. Use deepcopy when mutating nested data in one copy should not affect the other.

Q24. How can you profile and optimize Python code?

Use cProfile or line_profiler to find bottlenecks. Optimization strategies: use built-ins and list comprehensions over loops, prefer numpy for numerical work, cache with functools.lru_cache, use __slots__ for memory, and use generators for large data. Tools like Cython or PyPy provide JIT compilation.