Top Python Interview Questions and Answers: From Basics to Modern Python

Python interviews today test more than syntax. Expect questions on core concepts (mutability, scope, decorators, generators), memory and performance (reference counting, the GIL, free-threaded Python), concurrency (threads, processes, asyncio), data structures (such as an LRU cache), modern features (type hints, dataclasses, pattern matching) and how you work. This guide gives clear answers with working code, the mistakes interviewers look for and what is new in Python 3.14 and 3.15.

Quick answer: what to prepare

What is new in Python that interviewers may ask about

• Python 3.14 (October 2025): free-threaded Python (without the GIL) became officially supported as an optional build, plus template strings (t-strings) and deferred evaluation of annotations.
• Python 3.15 (released in October 2026): explicit lazy imports (lazy import json), UTF-8 as the default text encoding, a new frozendict type, unpacking in comprehensions, a sampling profiler called Tachyon, a faster experimental JIT and a stable ABI for free-threaded builds.
• The standard Python build still has the GIL. The free-threaded build is separate and opt-in, and many libraries are still adapting to it.
• The incremental garbage collector added in 3.14 was reverted after reports of memory leaks, so do not assume it is present in 3.14.5 or later.

You do not need to memorise every release note. Know the headline features and be honest about what you have used in production.

Core Python questions

1. What is the difference between mutable and immutable types?

Immutable objects (int, float, str, tuple, frozenset, bytes) cannot change after creation. Mutable objects (list, dict, set, most custom classes) can be changed in place. This matters for dictionary keys (keys must be hashable, which immutable types usually are) and for function arguments, because mutable arguments can be changed by the function.

2. What is the difference between a list and a tuple?

Lists are mutable, tuples are immutable. Tuples are hashable when all their items are hashable, so they can be dictionary keys. Use a tuple for fixed records and a list for collections that change.

3. What is the difference between == and is?

== compares values. is compares identity (whether two names point to the same object). Use is for None checks (if x is None), and == for values.

4. What is the mutable default argument trap?

def add_item(item, items=[]):   # bug: one shared list for all calls
    items.append(item)
    return items

The default list is created once when the function is defined. Fix it with None:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

5. What is the difference between a shallow copy and a deep copy?

A shallow copy (copy.copy, list.copy()) copies the outer container but shares the inner objects. A deep copy (copy.deepcopy) copies everything recursively. Changing a nested list in a shallow copy also changes the original.

6. What are *args and **kwargs?

*args collects extra positional arguments into a tuple and **kwargs collects extra keyword arguments into a dictionary. They let functions accept flexible arguments and forward them to other functions.

7. What is the LEGB rule?

Python looks up names in this order: Local, Enclosing function, Global and Built-in. Use global and nonlocal only when you really need to rebind outer variables.

Functions and iteration

8. What are higher-order functions? Show an example.

A higher-order function takes a function as an argument, returns a function, or both. Python functions are first-class objects, so this is natural.

def apply(func, x):
    return func(x)

def make_multiplier(n):
    def multiply(x):
        return x * n
    return multiply

double = make_multiplier(2)
nums = [1, 2, 3, 4]

print(apply(lambda n: n * n, 5))        # 25
print(list(map(double, nums)))          # [2, 4, 6, 8]
print([n for n in nums if n % 2 == 0])  # [2, 4]

map, filter, sorted(key=...) and functools.reduce are built-in higher-order functions. In everyday Python, list comprehensions are often preferred over map and filter.

9. What is the difference between map and flatMap? How do you do it in Python?

map transforms each item and keeps the same structure. flatMap (a Scala, Kotlin and JavaScript idea) maps and then flattens one level. Python has no built-in flatMap, but you can write it like this:

from itertools import chain

nested = [[1, 2], [3, 4], [5]]

flat = list(chain.from_iterable(nested))          # [1, 2, 3, 4, 5]
doubled = [x * 2 for sub in nested for x in sub]  # [2, 4, 6, 8, 10]

Our earlier version of this article answered this question with Scala code, which does not help in a Python interview.

10. What is a decorator? Write one.

A decorator is a function that wraps another function to add behaviour, such as logging, timing, caching or authentication.

import functools
import time

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

@timer
def slow():
    time.sleep(0.5)

functools.wraps keeps the original function name and docstring.

11. What are generators and why use them?

A generator produces values one at a time with yield, so it uses little memory and can handle large or streaming data.

def read_lines(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

This is useful for large files, streaming API responses and pipelines.

12. What is a context manager?

A context manager sets up and cleans up a resource with with, for example files, locks and database connections. You can write one with a class (__enter__ and __exit__) or with contextlib.contextmanager.

Memory and performance

13. How does Python manage memory?

CPython uses reference counting: every object tracks how many references point to it, and the memory is freed when the count reaches zero. A cyclic garbage collector finds and frees groups of objects that reference each other. Memory for small objects is handled by an internal allocator.

Operating-system memory management (paging, virtual memory and segmentation) is a related but separate topic. If asked, explain that the OS gives each process a virtual address space and maps it to physical memory in pages, and that Python’s allocator works inside that space.

14. Can Python have memory leaks? Show an example.

Yes, but the usual cause is code that keeps references alive, not forgetting to free memory. Our earlier example built a long linked list inside a function and said it leaked. In CPython that is not a leak: when the function returns, the references go away and the objects are freed.

A realistic leak is an unbounded cache or global list:

_cache = {}

def get_user(user_id):
    if user_id not in _cache:
        _cache[user_id] = load_user(user_id)   # grows forever
    return _cache[user_id]

Other common causes are growing global lists, unbounded lru_cache(maxsize=None), event handlers that are never removed, and long-lived objects that hold large data. Find leaks with tracemalloc:

import tracemalloc

tracemalloc.start()
# ... run your code ...
snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics("lineno")[:5]:
    print(stat)

Fix leaks with bounded caches (maxsize), weak references (weakref) and clean-up code.

15. What is the GIL, and what is free-threaded Python?

The Global Interpreter Lock lets only one thread run Python bytecode at a time in the standard CPython build. That is fine for I/O-bound threads, but it prevents CPU-bound threads from using several cores. Free-threaded Python is an optional build without the GIL, officially supported since 3.14, and Python 3.15 adds a stable ABI for extensions. It is promising, but the standard build still has the GIL and not every library supports free-threading yet. For CPU-bound work today, multiprocessing or native extensions such as NumPy remain common choices.

Concurrency: running tasks in parallel

16. How do you run two tasks at the same time in Python?

Choose by workload:

asyncio (I/O-bound):

import asyncio

async def task(name, seconds):
    await asyncio.sleep(seconds)
    return f"{name} done"

async def main():
    results = await asyncio.gather(task("A", 3), task("B", 2))
    print(results)

asyncio.run(main())

Processes (CPU-bound):

from concurrent.futures import ProcessPoolExecutor

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(heavy, [10_000_000, 12_000_000])))

The if __name__ == "__main__" guard is required on platforms that start new processes by importing your module.

Data structures: implement an LRU cache

17. Implement an LRU (Least Recently Used) cache

Our earlier version used a dictionary plus a list, which makes get and put take O(n) time because list.remove scans the list. A better answer uses OrderedDict for O(1) operations:

from collections import OrderedDict

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

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

    def put(self, key, value):
        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)

cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
print(cache.get(1))   # 1
cache.put(3, 3)       # evicts key 2
print(cache.get(2))   # -1

For caching function results, use the built-in decorator:

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

Explain the trade-off: a hash map gives O(1) lookup, and an ordered structure (or a doubly linked list) tracks recency. Also mention thread safety and cache size limits.

Modern Python questions

18. What are type hints, and do they enforce types?

Type hints (def add(a: int, b: int) -> int) document expected types and let tools such as mypy, pyright and your editor catch errors. Python does not enforce them at run time. Libraries such as Pydantic can validate data using type hints.

19. What are dataclasses?

A dataclass generates __init__, __repr__ and comparison methods from annotated fields.

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: float
    y: float

frozen=True makes instances immutable and hashable.

20. What is structural pattern matching?

Introduced in Python 3.10, match and case can match values and shapes:

match command.split():
    case ["go", direction]:
        move(direction)
    case ["quit"]:
        exit()
    case _:
        print("Unknown command")

21. What are f-strings and t-strings?

f-strings (f"Hello {name}") format values into a string immediately. Template strings (t-strings), added in Python 3.14, capture the template and its values without producing a final string, which lets libraries process them safely, for example to sanitise SQL or HTML before output.

22. How do you manage dependencies and environments?

Use a virtual environment per project, a lock file for repeatable installs, and a tool such as uv, pip, poetry or pip-tools. Pin versions, separate development and production dependencies, and run tests in CI.

23. How do you test Python code?

Use pytest for unit tests, fixtures for setup, mocking for external services and coverage reports to find untested code. Mention integration tests for databases and APIs.

Python in AI and data roles

If you apply for data or AI roles, expect questions on:

• NumPy and pandas: vectorised operations instead of loops, handling missing data, groupby and merges
• APIs and LLMs: calling a language-model API with retries, timeouts and async code, and validating JSON output with Pydantic
• Performance: profiling, using generators and chunked processing for large data
• Notebooks vs production: turning exploratory code into tested, packaged code

Learn the basics with our Python tutorial, practise in the online Python compiler, and explore our guides to Langflow and free AI tools for students.

Behavioural question: “What did you learn last week?”

This is not a Python question, but interviewers ask it to see how you learn. A good answer is specific, recent and shows application:

1. Name the topic you learned, for example “how asyncio handles concurrent API calls”.
2. Say how you learned it: a docs page, a project, a code review or a bug.
3. Show what you built or changed with it.
4. Mention the result or trade-off, such as faster response time.
5. Say what you will learn next.

Example: “Last week I learned how to use asyncio.gather to call three APIs at once. I replaced a sequential loop in a small script and cut its run time from nine seconds to about three. Next I want to learn how to handle timeouts and retries cleanly.” Use only true examples from your own work.

Interview tips for Python candidates

• Explain your thinking out loud. Start with a simple solution, then improve it.
• State complexity (time and space) for every data-structure answer.
• Handle edge cases: empty input, duplicates, very large data and errors.
• Write readable code: clear names, small functions and type hints.
• Know your resume. Be ready to explain any library or project you list.
• Practise coding without autocomplete, as some interviews use plain editors.
• Be honest about AI tools. Many companies have rules about using AI assistants in interviews and on the job. Follow them, and be ready to explain every line of code you write.
• Prepare questions for the interviewer about the team, code review and testing.

Common mistakes interviewers notice

• Using a mutable default argument
• Using is instead of == for values
• Using except: that hides every error
• Writing O(n) operations inside loops without noticing
• Using threads for CPU-bound work and expecting speed-ups
• Forgetting to close files and connections
• Calling a Scala or JavaScript idea “Python”

FAQs

What are the most common Python interview questions?

Mutable vs immutable types, list vs tuple, decorators, generators, the GIL, copy vs deepcopy, *args and **kwargs, and writing small programs such as an LRU cache.

Which Python version should I know for interviews?

Know Python 3.10 or later well, including type hints, dataclasses and match. Be able to mention the headline features of 3.14 and 3.15, such as free-threaded builds and lazy imports.

Is Python multithreaded?

Python supports threads, but the standard build has the GIL, which limits CPU-bound parallelism. Use multiprocessing for CPU work or a free-threaded build when your libraries support it.

Does Python have memory leaks? Python frees memory automatically, but programs can still leak by holding references, for example in unbounded caches or global lists.

Does Python have a flatMap?

No built-in one. Use itertools.chain.from_iterable or a nested comprehension.

What is the best way to implement an LRU cache in Python?

Use OrderedDict with move_to_end and popitem(last=False) for O(1) operations, or functools.lru_cache for function results.

How should I prepare for a Python interview in a month?

Week 1: core concepts, Week 2: data structures and algorithms, Week 3: concurrency, memory and modern features. Week 4: mock interviews and projects.

Do I need DSA for a Python interview?

Usually yes for software roles. Practise arrays, strings, hash maps, stacks, queues, trees and sorting, and read our data structures course.

Are Python interviews different for freshers and experienced candidates?

Freshers face more basics and coding exercises. Experienced candidates also face design, performance, testing and production questions.

Should I learn Python 3.15 features now?

Know them at a high level. Use the stable features of your team’s Python version in real code, and test new ones before adopting them.

Conclusion

Strong Python answers combine correct fundamentals, clean code and awareness of how the language is changing. Learn the core concepts, practise the examples above, understand the GIL and concurrency choices, and be honest about what you know. Then keep building small projects so you have real stories to share.

Python release details were checked on October 30, 2026 against news coverage of the 3.15 release. Confirm the latest versions and features at python.org.