10 senior Python developer interview questions and answers

Introduction

Python continues to be one of the most in-demand programming languages. Senior Python developer interviews often include questions that test advanced technical expertise and problem-solving skills.

Python is easy to learn, has a great community of developers, and is practiced in many fields such as software engineering, machine learning, back-end engineering, and web scraping.

In this article, we cover some of the most important and frequently asked senior Python developer interview questions and answers. Please remember that these questions are for Python Core and don’t consider other application development aspects, issues, or skills.

1. What can be the keys of a dictionary in Python?

When answering this interview question, a junior Python developer  may answer None, strings, or numbers. A mid-level developer may mention booleans, tuples, or any immutable object. However, a senior Python developer is expected to explain that any hashable object can be the key of a dictionary.

Hashable objects must be immutable. For example, the code below is correct because the tuple and all of its elements are hashable. Sets, dictionaries, and lists, however, cannot be used as dictionary keys as they are not hashable.

2. What is CPython?

Python is an interpreted language, meaning its code is first interpreted by another program (the interpreter) and then compiled into something called bytecode. Bytecode is made out of bytes that represent the machine’s instructions. CPython is the implementation of Python, where bytecode is in the C programming language.

On the other hand, we have Jython, where bytecode is in Java or other Python implementations.

We also have something called Cython, which is a compiled language used to create CPython extensions. The Cython language is a superset of Python that supports several C programming language features.

3. What is LEGB in Python?

This question often tests knowledge of Python scoping rules. When the Python interpreter is trying to look up a name, it uses the LEGB rule to resolve the names (variable, function, and other object names). It first checks for the existence of names in L, E, G, and B scopes in the order below:

1. Local Scope: The area within a function body or a lambda expression.
2. Enclosing Scope: Assume we have a function called outer which has a nested function. Enclosing scope (or nonlocal scope) is the area within the body of outer function.
3. Global Scope: The names in this scope are visible to all code in one Python script (in one file having a .py extension).
4. Built-in Scope: The names that exist in this scope are loaded when we run a Python shell/script. Keywords such as in, and, or, def, class and expressions like __main__, __file__ are some examples.

4. What are the usages of nonlocal and global keywords in Python?

This question directly relates to the previous one. The code sample below illustrates the usage of these two keywords:

5. What is GIL and why is it important?

GIL is one of the most controversial and important features of the CPython-based implementation of Python. GIL, or Global Interpreter Lock, ensures that only one thread at a time can execute a Python program. In other words, this lock belongs to the Python interpreter, and it uses it to lock a thread.

For example, thread T1 acquires GIL and does its job. While the Python interpreter is using GIL to lock T1, all other threads have to wait. After T1 finishes, it releases GIL and passes it to another thread T2 that needs it. The reason for the GIL presence is to make CPython thread-safe and not allow some threads to interfere with one another.

6. How does Python handle memory management?

Before discussing this topic, it's important to note that we are talking about the CPython implementation. Other Python implementations may have different rules and requirements for memory management.

Assume you have a Python script and you want to execute it. When you execute this file, the Python interpreter occupies some “area” of the RAM. This “area” itself is divided into two categories: the stack and the private heap.

Now assume that in this script we have declared a string object a = “hello”. When we execute this script, the CPython memory management system creates an object of type string on the private heap. This object contains three fields:

• Type: This is a string. Python is a dynamically typed programming language, so it will understand your object type to store.
• Value: This is “hello”.
• Reference count: It shows the number of times that a has been referenced. For now, it is 1.

At this point, the reference to a, which is stored on the private heap, is now stored on the stack.

A garbage collector is a tool that deletes objects on the private heap when they are no longer referenced, that is, when their reference count drops to zero. This process frees memory space for the Python interpreter.

7. Where should we use Python's multithreading, multiprocessing, and asyncio libraries?

To answer this question, we need some background knowledge. We divide the operations that we want our Python code to do into two categories:

• CPU-bound operations such as parsing, image processing, string manipulation, and algorithms involving heavy calculations. We can use parallelism for these types of operations. Basically, parallel programming is when we create different processes to divide a job among them and they all do the job simultaneously. Each process has its own GIL, Python interpreter, memory space, and state information. In Python, we use the multiprocessing library to achieve parallelism.
• IO-bound operations such as sending HTTP requests, querying data from databases, sending emails, and opening a file. We use concurrency for these operations. In Python, we can handle these operations using multithreading and asyncio libraries. Note that parallelism requires more resources than concurrency.

8. How does importing in Python work?

To answer this senior Python developer interview question, assume we have a directory called dir, inside which we have a Python script. When you import a module in this Python script, the Python interpreter tries to find your imported module in the following order:

1. It searches among other Python scripts inside the dir directory.
2. Then it goes over the list of the directories that are set using the PYTHONPATH environment variable.
3. Last, it searches through the default directories where Python files were installed. For example, 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python311\\Lib'

9. What is a closure in Python?

A closure is an inner/nested function that keeps the data regarding its enclosing scope even after the closure is called. To illustrate your answer to this interview question, you can provide this scenario as an example of utilizing closures for lazy evaluation:

10. How do you write scalable code in Python?

This is one of the most impactful and advanced senior Python interview questions. Scalability refers to designing services and microservices that can support large numbers of users without experiencing downtime. This is a challenge that must be handled properly, and writing scalable code is one way to make our service scalable.

Please be aware that we have to take into account many other components of creating a scalable project, such as systems design, DBMS, and infrastructure.

Here are key concepts for writing scalable Python Core code to help answer this interview question.

Use efficient data structures

For example, the time complexity of in operator is different depending on what iterable it has been used on.

• On list/tuple 🡪 O(n) time complexity.
• On dictionary/set 🡪 O(1) is the average case and O(n) is the worst case.

In the examples above, n is the length of the iterable.

Use parallelism

Dividing and running a CPU-bound operation using different processes can be a solution to boost the speed.

Design a distributed system

In a distributed system, there are different machines that communicate with each other to do a job. Using libraries like Apache Spark or Ray can be a good approach for scalability.

Use caching

Consider a scenario where an image requires heavy processing and must be sent to many users. To efficiently meet these needs, we can process this image only once and cache or store the processed version in a variable. This lets us reuse the processed image via the variable without repeating the processing step.

Conclusion

These are the top ten senior Python developer interview questions and answers for those looking to advance their career in tech. By preparing thoughtful answers to these questions and understanding the underlying principles, you'll be better equipped to demonstrate your expertise and problem-solving abilities in a senior Python developer interview. Staying up to date with best practices and continually improving your knowledge of Python's advanced features will set you apart and increase your confidence as you pursue new opportunities in the tech industry.