How Python developer interviews work
Python developer interviews vary by the type of role. For backend web development roles (Django, Flask, FastAPI), expect questions on Python fundamentals, web framework architecture, database integration, and API design. For data engineering or data science roles, expect Python proficiency tests alongside SQL, Pandas, and data pipeline questions. For general software engineering roles at tech companies, Python is often accepted for algorithm and data structure rounds. Know which type of Python role you are interviewing for and calibrate your preparation accordingly.
Most Python developer loops include a coding round (algorithms and data structures in Python), a practical Python question (debugging or extending existing code), a system or architecture round, and a behavioral interview. Experienced hire roles often include a code review exercise where you are given a Python codebase to critique.
Core Python fundamentals questions
"What is the difference between a list and a tuple in Python?" Lists are mutable (can be modified after creation), tuples are immutable. Tuples are slightly faster to create and iterate. Use lists when you need to modify the collection, tuples for fixed collections or as dictionary keys (since they are hashable). "Explain Python's GIL and when it matters." The Global Interpreter Lock (GIL) means only one Python thread executes bytecode at a time. This limits CPU-bound multithreading. For CPU-bound parallelism, use multiprocessing or a C extension. For I/O-bound tasks (network requests, file I/O), threading or asyncio work fine because the GIL is released during I/O waits.
"What are Python decorators and how do they work?" A decorator is a function that takes another function as an argument, adds some behaviour, and returns a new function. Example: @login_required in Django checks authentication before executing the view. Under the hood, @decorator is syntactic sugar for func = decorator(func). Decorators are useful for cross-cutting concerns: logging, authentication, rate limiting, caching. Know how to write one from scratch.
Object-oriented programming questions
"Explain the four pillars of OOP in Python with an example." Encapsulation (bundling data and methods, using _private or __name_mangling), Inheritance (subclassing with class Dog(Animal)), Polymorphism (duck typing in Python: if it has a .bark() method, treat it as a dog), and Abstraction (using abc.ABC and @abstractmethod to define interfaces). Give a concrete example from a domain you have worked in.
"What is the difference between @staticmethod, @classmethod, and an instance method?" Instance methods receive self and can access instance and class data. Class methods receive cls and can access only class data; often used as alternative constructors. Static methods receive neither and are just functions namespaced within the class. Interviewers often follow up with "when would you use a classmethod as a factory?"
Performance and advanced Python questions
"How would you optimise a Python function that processes a list of one million items and is running too slowly?" Work through the layers: first profile with cProfile to find the actual bottleneck rather than guessing. Common fixes: replace Python loops with NumPy vectorised operations (10-100x speedup for numerical work), use list comprehensions instead of explicit for loops, use generators instead of building large intermediate lists, use functools.lru_cache for repeated calculations, or move the hot loop to a C extension or Cython. Show systematic thinking before proposing a specific solution.
"What is asyncio and when would you use it over threading?" Asyncio is Python's event loop for asynchronous I/O using async/await syntax. Use it for high-concurrency I/O-bound tasks (handling thousands of simultaneous HTTP requests, database connections) in a single thread without the memory overhead of thread pools. Use threading when you need to run existing synchronous libraries concurrently and cannot refactor them to be async. Asyncio scales better for I/O-bound concurrency; multiprocessing for CPU-bound tasks.
Web framework and API questions
"Explain the Django ORM and when you would write raw SQL instead." Django ORM translates Python code into SQL queries. It is convenient and safe (parameterised queries prevent SQL injection) for standard CRUD operations and moderate-complexity queries. Write raw SQL when: complex JOINs or window functions are awkward in ORM syntax, you need database-specific features not exposed by the ORM, or query performance requires fine-tuned SQL. Use QuerySet.explain() to check query plans and identify N+1 query problems (a common ORM pitfall).
"What is FastAPI and why has it gained adoption over Flask?" FastAPI is a modern async Python web framework built on Pydantic and Starlette. Key advantages over Flask: native async support, automatic OpenAPI documentation from type hints, built-in request validation via Pydantic models, and significantly better performance under concurrent load. Flask remains widely used for simpler applications where its simplicity and ecosystem matter more. For new greenfield APIs in 2026, FastAPI is the more commonly recommended choice.
How to prepare for Python interviews
Practice Python algorithm questions on LeetCode or HackerRank: focus on string manipulation, list processing, dictionary operations, and class implementation. Make sure your Python syntax is clean: use f-strings rather than format(), list comprehensions rather than explicit loops where appropriate, type hints for function signatures (increasingly expected in 2026). Know the standard library well: itertools, collections (defaultdict, Counter, deque), functools (reduce, lru_cache), and pathlib.
For web development Python roles, build a small project that uses your target framework end-to-end: a REST API with authentication, database integration, and tests. Being able to discuss a real project you built is more convincing than passing framework-specific trivia questions. Know how to write unit tests with pytest and how to use mocking to test functions with external dependencies.