Python Developer Interview Questions & Answers

Preparing for a Python Developer interview requires more than just knowing the syntax—you need to demonstrate how you think, solve problems, and collaborate with teams. Whether you’re applying for your first developer role or stepping into a senior position, understanding what interviewers are looking for will help you showcase your true capabilities.

This guide walks you through the most common python developer interview questions and answers you’ll encounter, along with practical strategies for crafting responses that highlight your experience and approach to problem-solving.

Common Python Developer Interview Questions

What are the key differences between Python 2 and Python 3?

Why they ask: Interviewers want to understand your awareness of Python’s evolution and whether you stay current with industry practices. Since Python 2 reached end-of-life in 2020, this also signals whether you’re working with modern standards.

Sample answer:

“The main differences I’ve encountered in my work are pretty significant. In Python 3, print became a function requiring parentheses, so print('hello') instead of print 'hello'. Integer division also changed—in Python 2, 5/2 equals 2, but in Python 3 it equals 2.5, which caught me off-guard early on. Strings are Unicode by default in Python 3, which is much better for internationalization. Error handling syntax changed too—it’s now except Exception as e: instead of except Exception, e:. In one of my recent projects, I had to maintain some legacy Python 2 code, and those differences made debugging tricky until I got used to switching between them. I’ve standardized on Python 3 for all new projects since then.”

Personalization tip: Mention a specific project where this mattered, or discuss which differences impacted you most during your learning journey.

Explain Python’s memory management and garbage collection.

Why they ask: This reveals whether you understand Python’s underlying mechanics and how to write memory-efficient code—critical for performance-sensitive applications.

Sample answer:

“Python uses a combination of reference counting and garbage collection to manage memory. Every object has a reference count, and when it drops to zero, the memory is released. I learned this the hard way when I was building a data processing pipeline that was consuming too much memory. I discovered I had circular references—objects referencing each other—that weren’t being cleaned up immediately. After that, I started using context managers with the with statement to ensure resources get released properly. For example, when opening files, with open('file.txt') as f: automatically closes the file when the block exits. For large datasets, I also use generators instead of lists to avoid loading everything into memory at once. I occasionally use the gc module to manually trigger garbage collection when I know I’m about to process a huge batch of data, but that’s rare.”

Personalization tip: Include a real scenario where memory management affected your work, or mention tools you’ve used to profile memory usage.

What is the Global Interpreter Lock (GIL) and how does it affect multi-threading?

Why they ask: This tests your understanding of Python’s concurrency limitations and whether you know practical workarounds—important for building scalable systems.

Sample answer:

“The GIL is basically a mutex that prevents multiple threads from executing Python bytecode simultaneously, even on multi-core processors. This means that CPU-bound multi-threaded programs don’t actually get the performance boost you’d expect. I ran into this when I tried to parallelize a CPU-intensive calculation using threading—I got zero speed improvement. That’s when I learned about multiprocessing, which spawns separate Python processes with their own GIL, so they can truly run in parallel. For I/O-bound tasks like web requests or database calls, threading works fine because the GIL is released during I/O operations. In another project, I used asyncio for handling multiple concurrent HTTP requests efficiently without the overhead of spinning up processes. The key is understanding your workload—if it’s CPU-bound, use multiprocessing; if it’s I/O-bound, threading or asyncio will work.”

Personalization tip: Describe an actual performance problem you solved and which concurrency approach you chose.

What are decorators and how would you use them?

Why they asks: Decorators are a core Python feature that show mastery of higher-order functions and functional programming concepts. They’re also used frequently in frameworks like Flask and Django.

Sample answer:

“Decorators are functions that wrap another function or method to modify its behavior without permanently changing it. You create them by defining a function that takes a function as an argument, adds some functionality, and returns a new function. I’ve used decorators extensively in Flask projects. For example, I built a custom @login_required decorator that checks if a user is authenticated before allowing access to certain endpoints. I also created a @cache_result decorator for expensive database queries—it stores the result and returns the cached version for subsequent calls with the same arguments. Another practical one I built was @retry, which automatically retries a function up to three times if it fails, useful for API calls that might be temporarily down. The beauty of decorators is that they keep your code DRY and make cross-cutting concerns like logging, caching, and authentication much cleaner.”

Personalization tip: Share a specific decorator you’ve written and the problem it solved in your work.

How do you approach writing clean and optimized Python code?

Why they ask: This evaluates your code quality standards and whether you understand best practices for readability, performance, and maintainability.

Sample answer:

“I approach this from a few angles. First, readability—I follow PEP 8 style guidelines and use meaningful variable names. I also break large functions into smaller, single-purpose functions that are easier to test and understand. For optimization, I use profiling tools like cProfile to identify actual bottlenecks rather than guessing. In one project, I was convinced a particular loop was slow, but cProfile showed the real culprit was a library function I was calling repeatedly. I used list comprehensions and generators where appropriate because they’re both faster and more readable than equivalent loops. I also leverage Python’s built-in functions—they’re written in C and are much faster than Python equivalents. For maintainability, I write docstrings for all functions, include type hints which help catch bugs early, and aim for around 80-90% test coverage. I run linters like pylint and flake8 to catch style issues automatically rather than waiting for code review.”

Personalization tip: Mention specific performance wins you’ve achieved or tools you rely on regularly.

Describe your experience with testing frameworks. How do you integrate testing into your workflow?

Why they ask: Testing is fundamental to professional development. This reveals whether you take quality seriously and understand different testing strategies.

Sample answer:

“I use pytest primarily because it’s more intuitive and flexible than unittest. My workflow starts with understanding the requirements, then I write tests that describe the expected behavior before implementing the feature—that’s test-driven development. I write different types of tests: unit tests for individual functions, integration tests to ensure components work together, and occasionally end-to-end tests for critical user flows. In my last project, I maintained around 85% test coverage, which gave me confidence to refactor code without breaking things. I also use fixtures in pytest to set up test data consistently, and I mock external dependencies like APIs or databases so tests run fast and don’t depend on external systems. I’ve found that having a solid test suite actually speeds up development because I catch bugs immediately instead of in production. I also run tests automatically through CI/CD pipelines so nothing gets merged without passing tests.”

Personalization tip: Mention your typical test coverage percentage and specific testing patterns you rely on.

What data structures would you use to solve a specific problem? Can you give an example?

Why they ask: This tests your ability to choose appropriate tools for the job and optimize for the problem at hand.

Sample answer:

“The choice really depends on the access patterns you need. Recently, I was building a word frequency analyzer, and I used a dictionary because I needed O(1) lookup and update time. I could iterate through a document, count occurrences of each word, and then easily retrieve the top 10 most common words. If I’d used a list, searching and updating would be O(n) and much slower. In another project, I needed to maintain the order of items while ensuring uniqueness, so I used a set in Python 3.7+ which preserves insertion order. For a cache with a fixed size, I used collections.OrderedDict to efficiently remove the least recently used items. Sets are great when you need uniqueness and fast membership testing—much faster than checking if an item is in a list. Tuples are useful as dictionary keys when you need immutable structures. I always think about the operations I’ll perform most frequently and choose the data structure that optimizes for those operations.”

Personalization tip: Describe a real problem you solved and walk through your decision-making process.

How do you use version control systems in your workflow?

Why they ask: Version control is essential in professional teams. This assesses your understanding of collaboration, code management, and development best practices.

Sample answer:

“I use Git daily and follow a feature branch workflow. For each feature or bug fix, I create a new branch off the main branch, which keeps main stable and deployable. I make frequent commits with clear, descriptive messages because it makes the history readable and helps with debugging later. When the feature is ready, I push the branch and open a pull request so teammates can review the code before it merges. I’ve found code reviews catch bugs and improve code quality significantly. I also rebase my feature branches to keep the history clean rather than creating merge commits. On my current team, we use GitHub and have branch protection rules that prevent merging without approvals and passing tests. I’ve made mistakes with Git—accidentally committing sensitive data, messy merge conflicts—but those taught me to be more careful. I always pull before pushing, communicate with teammates about what I’m working on, and try to keep pull requests focused on a single concern so they’re easier to review.”

Personalization tip: Mention a specific branching strategy you’ve used and any lessons you’ve learned.

Explain what a context manager is and how you’ve used them.

Why they asks: Context managers are Pythonic and crucial for resource management. This shows understanding of Python idioms and best practices.

Sample answer:

“Context managers ensure that resources are properly initialized and cleaned up, even if an error occurs. The with statement is the key—it calls __enter__ when you enter the block and __exit__ when you leave, regardless of whether an exception happened. The most common use is file handling: with open('data.txt') as f: automatically closes the file when you’re done. I’ve also created custom context managers for my own resources. For instance, I built one that establishes a database connection, manages a transaction, and ensures the connection closes properly. If an error occurred mid-transaction, the context manager would rollback changes automatically. I used the contextlib.contextmanager decorator to build a timer context manager that measured how long a code block took to execute—useful for identifying performance issues. Another handy one I created managed temporary directories for tests, ensuring they got cleaned up afterward. Context managers make code cleaner and safer because you don’t have to remember to clean up manually.”

Personalization tip: Share a custom context manager you’ve built and what problem it solved.

What are list comprehensions and when would you use them?

Why they ask: List comprehensions are a Pythonic feature that reveals your fluency with the language and understanding of code efficiency.

Sample answer:

“List comprehensions provide a concise way to create lists by applying an operation to each element in an iterable. They’re more readable and faster than equivalent for loops. For example, if I need to square all numbers in a list, [x**2 for x in numbers] is cleaner than writing a loop. I also use the filtering syntax like [x for x in numbers if x > 10] to extract even values. Dictionary comprehensions and set comprehensions follow the same pattern. I use them frequently, but I’m careful not to overuse them—if a comprehension gets too complex with nested loops and conditions, it becomes less readable than a regular loop. I’ve also learned that generator expressions, which look similar but use parentheses instead of brackets like (x**2 for x in numbers), are better when you’re not storing the entire list in memory. I used a generator expression recently when processing a huge file line by line—it meant the entire file wasn’t loaded into memory at once.”

Personalization tip: Give a concrete example from your own work where comprehensions made a difference.

How do you handle exceptions and errors in Python?

Why they ask: Exception handling reveals your approach to robustness, error prevention, and user experience.

Sample answer:

“I try to catch specific exceptions rather than bare except: clauses, which can hide bugs. For example, if I’m parsing JSON from an API, I’ll catch json.JSONDecodeError specifically, not all exceptions. I also use try-except-else-finally: the else block runs if no exception occurred, and finally runs regardless—useful for cleanup. I’ve learned to provide context in error messages. Instead of just except Exception as e: print(e), I provide information about what was being attempted. I also consider whether to handle an exception or let it propagate up to a higher level. In a recent project, I had a function that called an external API—if the API was down, I wanted the function to retry a few times before giving up, so I handled the exception locally. But if there was a programming error, I let it propagate so developers would see it during testing. I avoid catching Exception too broadly because it can mask legitimate bugs. I use custom exception classes for domain-specific errors—it makes the code intention clearer and allows calling code to handle different errors differently.”

Personalization tip: Describe an error scenario you handled and explain your reasoning for the approach.

What are generators and when would you use them?

Why they ask: Generators demonstrate understanding of memory efficiency and advanced Python concepts.

Sample answer:

“Generators are functions that use yield instead of return, producing a sequence of values one at a time instead of creating an entire list in memory. They’re lazy—they compute values only when requested. I use them when processing large files or datasets. For instance, I had a project that needed to process millions of log entries. Creating a list with all of them would consume too much memory, but a generator yielded one line at a time: yield line for each line in the file. The calling code could iterate through them without worrying about memory. Generators are also useful for infinite sequences—you can yield values indefinitely and the caller takes what they need. I’ve also used them with itertools for data transformation pipelines. The tradeoff is that you can’t access elements by index or get the length directly, so they’re not suitable for every situation. But when performance and memory efficiency matter, generators are excellent.”

Personalization tip: Share a scenario where generators improved your application’s performance.

What is a lambda function and when would you use one?

Why they ask: Lambda functions are useful for short operations, and their use (or misuse) reflects your judgment about code readability.

Sample answer:

“Lambda functions are anonymous, single-expression functions defined with the lambda keyword. They’re useful for short operations, especially when passing functions to higher-order functions like map, filter, or as dictionary key functions. For example, if I need to sort a list of tuples by the second element, sorted(data, key=lambda x: x[1]) is cleaner than defining a separate function. I’ve also used them with map and filter, though I often prefer list comprehensions because they’re more readable. I avoid complex lambdas—if a function needs multiple lines or is complex, I define a regular function instead. Lambdas should be immediately understandable; if someone has to read the logic twice to understand it, it’s not a good use case. I also wouldn’t use a lambda in a place where I’d need to debug it, because tracebacks for lambdas can be confusing.”

Personalization tip: Give an example of when you chose a lambda and when you chose a regular function.

Describe your experience with Python libraries and frameworks relevant to the role.

Why they ask: This reveals your practical experience and whether you know the right tools for the job.

Sample answer:

“My experience varies by project type. For web development, I’ve built several Flask applications and recently worked with Django on a larger project. Flask is lightweight and gives you flexibility, while Django provides more structure and batteries-included features like ORM and admin panel. For data manipulation, I use Pandas extensively—it’s powerful for cleaning, transforming, and analyzing data. I’ve also used NumPy for numerical computations. For HTTP requests, the requests library is my go-to; it’s much more user-friendly than the built-in urllib. I’ve used SQLAlchemy for database operations—it provides a great ORM layer that abstracts away SQL complexity. For testing, as I mentioned, I use pytest. For API development, I’ve experimented with FastAPI, which is becoming popular for its speed and automatic documentation. I choose libraries based on the project requirements and team familiarity. I also check when a library was last updated and how actively it’s maintained—I learned early on to avoid dead or dying libraries.”

Personalization tip: Mention specific projects where you used these libraries and what you built.

How do you approach debugging Python code?

Why they ask: Debugging skills are essential for every developer. This shows your problem-solving approach and resourcefulness.

Sample answer:

“My first step is usually adding print statements or using logging to trace execution and see what’s actually happening versus what I expected. I use Python’s built-in pdb debugger for more complex issues—I can set breakpoints, step through code line by line, and inspect variables. I also use IDE debugging features; my editor has a visual debugger that makes stepping through code easier. When hunting a bug, I try to reproduce it consistently first, then isolate which part of the code is causing it. I’ve learned to read tracebacks carefully—they tell you the exact line and the call stack. For production bugs that are hard to reproduce locally, I increase logging verbosity to capture more context. I also use tools like cProfile for performance issues—sometimes what looks like a bug is actually code being slow. I’ve had situations where the bug wasn’t in my code but in a library or an incorrect assumption about how something works, so I check documentation and library behavior. Testing also prevents many bugs—when I find a bug, I write a test that reproduces it, fix the code, and ensure the test passes.”

Personalization tip: Describe a tricky bug you found and your debugging process.

Behavioral Interview Questions for Python Developers

Behavioral questions explore how you work with others, handle challenges, and approach your career. Use the STAR method (Situation, Task, Action, Result) to structure concise, compelling stories.

Tell me about a time you had to learn a new technology quickly.

Why they ask: This reveals your adaptability and learning ability—critical in fast-moving tech environments.

STAR framework:

• Situation: Describe the context and timeline pressure.
• Task: What did you need to accomplish?
• Action: How did you approach learning? What resources did you use?
• Result: What did you learn? How did you apply it? What was the outcome?

Example response:

“My previous company decided to migrate from Flask to FastAPI to improve API performance. I’d never used FastAPI before, and we needed to migrate a critical service within three weeks. I started by reading the official documentation and watching tutorials to understand async/await patterns, which were new to me. I built a small prototype API to get hands-on experience, then worked with a senior developer to review my approach. I identified that the async pattern required rethinking how we handled database operations, so I studied SQLAlchemy’s async support. Within a week, I confidently rewrote the first module, and by the deadline, we’d migrated the entire service. The API response times improved by 40%, and the team gained a technology that better fit our needs. That experience taught me that learning by doing, supplemented with documentation and peer input, is more effective than purely theoretical study.”

Personalization tip: Choose a technology you actually learned and describe the specific challenges you faced.

Describe a situation where you disagreed with a team member about code design or approach.

Why they ask: This explores your collaboration skills, receptiveness to feedback, and ability to communicate technical ideas.

STAR framework:

• Situation: What was the disagreement about?
• Task: Why did it matter to resolve this?
• Action: How did you handle it? How did you communicate your perspective?
• Result: What was the outcome? What did you learn?

Example response:

“During code review, a senior developer suggested refactoring a complex function into several smaller functions, which I thought was unnecessary—the function worked fine. I initially defended my approach, but then I stopped to understand their reasoning. They explained that in a few months, when someone needs to modify this code, breaking it into testable, focused functions would make maintenance easier. I was thinking about present efficiency; they were thinking about future maintainability. I implemented their suggestion, wrote tests for each small function, and realized they were right—the code became much more understandable. More importantly, I learned to listen to experience and consider perspectives beyond my immediate view. Now I actively seek feedback and try to understand the reasoning behind suggestions rather than dismissing them.”

Personalization tip: Show genuine reflection and what you learned from the experience.

Tell me about a project where you had to balance technical debt with new features.

Why they ask: This reveals your understanding of real-world tradeoffs and prioritization skills.

STAR framework:

• Situation: What project and what was the tension?
• Task: What were you trying to achieve?
• Action: How did you make decisions? Who did you involve?
• Result: What was the outcome?

Example response:

“We had a legacy codebase with minimal tests and inconsistent code style. New feature requests kept coming in, and we faced pressure to ship. Early on, I wanted to refactor everything before adding features, but that would’ve delayed launches indefinitely. Instead, I worked with the team to prioritize: we tackled technical debt that blocked new features or caused frequent bugs first. We incrementally added tests to existing code, especially critical paths. For new code, we enforced high standards—no exceptions. We also allocated 20% of each sprint to technical debt. This pragmatic approach let us ship features while gradually improving the codebase. After six months, our test coverage went from 10% to 60%, and the codebase felt much more maintainable. I learned that the perfect is the enemy of the good—sometimes incremental improvement is more realistic than overhauls.”

Personalization tip: Be specific about metrics and timelines; show strategic thinking.

Describe a time when you had to explain technical concepts to non-technical stakeholders.

Why they ask: Communication across technical and non-technical boundaries is crucial for product development.

STAR framework:

• Situation: What was the technical issue?
• Task: Who did you need to explain it to and why?
• Action: How did you simplify and explain the concept?
• Result: Did they understand? What happened next?

Example response:

“A performance issue was preventing a feature launch, and I had to explain database query optimization to our product manager. Instead of talking about indexes and query plans, I used an analogy: ‘Right now, every user request searches through a card catalog manually. Adding an index is like organizing that catalog alphabetically—the search is instant.’ I showed them response times before and after in simple graphs. I also provided a clear timeline: optimization would take two days and remove a bottleneck affecting user experience. They understood the tradeoff between shipping slightly later but with better performance. We prioritized the optimization, users got a better experience, and the feature shipped sooner overall because we weren’t firefighting performance complaints. That experience taught me to meet people where they are—use their vocabulary and focus on business impact, not technical details.”

Personalization tip: Show empathy for non-technical perspectives and concrete business impact.

Tell me about a time you had to meet a tight deadline. How did you manage it?

Why they ask: This reveals your prioritization, time management, and ability to handle pressure.

STAR framework:

• Situation: What was the deadline and why was it tight?
• Task: What needed to be delivered?
• Action: How did you organize your work? What did you deprioritize or defer?
• Result: Did you meet the deadline? What was the outcome?

Example response:

“We had a week to implement a new payment processing feature for a client demo. Normally, this would take two weeks. I immediately broke it down: core functionality was non-negotiable, nice-to-have features could wait. I identified what could be reused from existing code versus what needed to be built new. I communicated with the team about potential blockers early. I also cut scope smartly—instead of handling every edge case, we implemented the happy path and logged issues for future handling. I wrote tests incrementally rather than after, catching bugs faster. I asked for help with code review instead of trying to do everything solo. We shipped the core feature on time for the demo, the client was impressed, and we backfilled edge cases in the following sprint. The key was ruthless prioritization and clear communication about what was and wasn’t included.”

Personalization tip: Emphasize your communication and decision-making, not heroic overwork.

Tell me about a mistake you made and how you handled it.

Why they ask: This shows humility, accountability, and your growth mindset.

STAR framework:

• Situation: What was the mistake?
• Task: How did you realize it?
• Action: What did you do to address it and prevent it next time?
• Result: What was the outcome?

Example response:

“Early in my career, I pushed code to production without running full tests locally because I was in a hurry. A bug made it to production and affected a small number of users for about two hours. I was embarrassed and initially wanted to hide it, but I immediately reported it to my manager, fixed the bug, and deployed a hotfix. I didn’t blame the lack of testing—I took responsibility. Afterward, I implemented automated tests and a pre-commit hook that ran tests locally before allowing pushes. I also set up a staging environment that mirrored production so issues could be caught before release. The team implemented a code review requirement for production deployments. That mistake was painful but valuable—I never repeated it. I learned that speed doesn’t matter if you break things, and that good processes catch mistakes before they reach users.”

Personalization tip: Show genuine learning and specific process changes you implemented.

How do you stay current with Python and software development trends?

Why they ask: This reveals your commitment to continuous learning and professional growth.

Example response:

“I regularly read blogs and follow developers on Twitter to see what’s happening in the ecosystem. I subscribe to Python-focused newsletters like Python Weekly and Real Python. I also read source code from projects I admire—seeing how experienced developers structure code and solve problems teaches me more than tutorials sometimes. I take online courses when I want to dive deep into a new area; I recently completed one on async Python. I participate in code reviews, both giving and receiving, because that’s where I learn the most from colleagues. I also contribute to open-source projects occasionally, which exposes me to different codebases and perspectives. Within my team, we have tech lunch-and-learns where someone presents about a new tool or technique. I’m intentional about this—I allocate time for learning because staying current is part of the job in tech.”

Personalization tip: Mention specific resources you actually use and projects you’ve contributed to.

Technical Interview Questions for Python Developers

These questions probe deeper into Python-specific knowledge and your ability to think through complex problems.

Write a function to detect if a linked list has a cycle.

Why they ask: This tests algorithmic thinking, data structure understanding, and your ability to write clean code under interview conditions.

Answer framework:

Clarify the problem: A linked list has a cycle if a node points back to a previously visited node. You need to detect its presence.

Approach: The classic solution uses Floyd’s cycle detection algorithm (tortoise and hare). Use two pointers moving at different speeds—if they meet, there’s a cycle.

def has_cycle(head):
    if not head:
        return False
    
    slow = head
    fast = head.next
    
    while fast and fast.next:
        if slow == fast:
            return True
        slow = slow.next
        fast = fast.next.next
    
    return False

Explain your thinking: “I use two pointers with different speeds. If there’s a cycle, the fast pointer eventually catches up to the slow pointer. If the fast pointer reaches the end (None), there’s no cycle. This uses O(1) space and O(n) time, which is better than using a set to track visited nodes.”

Personalization tip: Discuss why you chose this approach and mention alternatives you considered.

How would you reverse a string in Python? What about reversing it recursively?

Why they ask: This assesses your understanding of string operations, built-ins versus manual approaches, and recursive thinking.

Answer framework:

Iterative approach:

def reverse_string(s):
    return s[::-1]

Explain: “Python slicing with [::-1] is the most Pythonic way—it’s concise and efficient. Behind the scenes, it’s implemented in C.”

Manual iterative approach:

def reverse_string_manual(s):
    result = ""
    for char in reversed(s):
        result += char
    return result

Or using a list (more efficient for string concatenation):

def reverse_string_list(s):
    result = []
    for char in s:
        result.insert(0, char)
    return ''.join(result)

Recursive approach:

def reverse_string_recursive(s):
    if len(s) == 0:
        return s
    return reverse_string_recursive(s[1:]) + s[0]

Explain: “Recursively, I take the first character and append it after reversing the rest. This is elegant but slower and uses more memory due to the call stack. For production code, I’d use slicing, but recursion demonstrates understanding of the concept.”

Personalization tip: Discuss when you’d use each approach and tradeoffs in performance.

Explain how you’d implement a LRU (Least Recently Used) cache in Python.

Why they ask: This combines data structures, design patterns, and problem-solving—it’s a real-world design problem.

Answer framework:

Requirements: A cache with a fixed maximum size. When full, evict the least recently used item.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity
    
    def get(self, key):
        if key not in self.cache:
            return -1
        # Move to end to mark as recently used
        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:
            # Remove first item (least recently used)
            self.cache.popitem(last=False)

Explain: “I use OrderedDict which maintains insertion order. When accessing or updating an item, I move it to the end to mark it as recently used. When the cache exceeds capacity, I remove the first item, which is the least recently used. This is O(1) for all operations.”

Alternative using a dict and doubly linked list:

“For interviews, I might implement a custom doubly linked list to show deeper understanding, though OrderedDict handles it elegantly in production code.”

Personalization tip: Discuss the data structures involved and explain your design choices.

Write a function to find the intersection of two sorted arrays without using built-in functions.

Why they ask: This tests algorithmic thinking, understanding of time complexity, and ability to work with multiple pointers.

Answer framework:

def find_intersection(arr1, arr2):
    """Find common elements in two sorted arrays."""
    result = []
    i = 0
    j = 0
    
    while i < len(arr1) and j < len(arr2):
        if arr1[i] == arr2[j]:
            # Avoid duplicates
            if not result or result[-1] != arr1[i]:
                result.append(arr1[i])
            i += 1
            j += 1
        elif arr1[i] < arr2[j]:
            i += 1
        else:
            j += 1
    
    return result

Explain: “Since both arrays are sorted, I use two pointers starting at the beginning. When values match, I add to results (checking for duplicates). If one value is smaller, I advance that pointer. This is O(n + m) time and O(1) space (excluding output)—much better than nested loops which would be O(n * m).”

Personalization tip: Discuss edge cases (empty arrays, duplicates) and your reasoning for optimization.

How would you implement a decorator that measures function execution time?

Why they ask: This combines decorators, closures, and practical utility—showing Pythonic code.

Answer framework:

import time
from functools import wraps

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

@timer
def slow_function():
    time.sleep(1)
    return "Done"

Explain: “The decorator uses functools.wraps to preserve the original function’s metadata. Inside the wrapper, I measure time before and after the function executes, then print the duration. The *args and **kwargs allow this to work with any function signature.”

Enhancements to discuss: “I could log to a file instead of print, return the time as well as the result, or make it configurable with a parameter.”

Personalization tip: Share a decorator you’ve actually implemented and its purpose.

Explain the difference between == and is in Python. When would you use each?

Why they ask: This reveals subtle understanding of Python’s object model.

Answer framework:

== compares values (calls the __eq__ method), while is checks identity (whether two references point