Skip to content Skip to footer

Key Python interview questions (and answers) from basic to senior level

Getting started

Python is one of the most popular coding languages in the world—from building web apps to powering AI innovations. Its widespread usage can be attributed to its simplicity, robust community support, and versatility. As a result, proficiency in Python can give you a significant advantage in the job market as you look for your next role, whether you’re a more senior engineer or looking for your first tech job. This guide is tailored to prepare you for Python-related interviews. It covers a wide spectrum of questions, from foundational Python concepts to advanced domain-specific challenges faced by senior developers. Detailed answers accompany each question to enhance understanding.

To prepare efficiently, it’s important for developers to accurately evaluate their own skills in Python and technical interviewing. This guide helps in this assessment by categorizing questions by difficulty. Beginners can gauge their understanding of basics, while advanced programmers can test their knowledge of more complex use cases. Recognizing your proficiency level helps you focus your preparation on areas that require the most attention.

It’s important to set specific goals for your Python interview preparation based on your skill and type of role you’re interviewing for. This guide will help you identify key areas for improvement, such as data structures, object-oriented programming, or library specific knowledge. Once you set your goals, you can create a focused and tailored practice plan that includes regular coding exercises and mock interview scenarios. 

Let’s get started.

Jump to a section:

What you will need to get started

For day-to-day coding, developers often rely on fully-featured Integrated Development Environments (IDEs) such as PyCharm, leveraging tools like debugging, auto-complete, and code navigation. However, interview coding environments are generally more lightweight, intentionally limiting available features to concentrate on assessing coding abilities. Some may only allow debugging using print statements. We’ve observed that developers accustomed to the rich debugging capabilities of IDEs can sometimes encounter challenges when transitioning to these constrained coding environments.

Therefore, while full IDEs prove ideal for regular development, we strongly recommend practicing coding interviews using simpler text editors that mirror the conditions of actual interview coding platforms. Those who intentionally practice in environments resembling interviews tend to feel more at ease. If you opt for practicing in a feature-rich IDE, consider refraining from using advanced features like variable watching and instead focus on debugging using print statements. If your interview IDE does offer extra features, view them as an added bonus.

Similarly, unless an interview explicitly evaluates proficiency with a framework like NumPy or TensorFlow, minimize the use of external packages and imports. Interview questions typically center around base language skills and standard library functionality. If you are accustomed to heavily relying on packages, explore alternative ways of implementing their capabilities.

How to solve our Python interview questions

  • Review computer science fundamentals: Familiarize yourself with basic data types (strings, lists, dictionaries) and control flow statements. Ensure comfort with the structure and syntax of Python code. Brush up on time and space complexity so you can evaluate those for all problems. 
  • Practice common algorithm questions: Code solutions to standard algorithm questions like fizzbuzz, reversing a string, and the Fibonacci sequence. Many coding questions tend to build off the basics, and knowing some common patterns will make approaching new problems easier.
  • Master built-in Python features: Become adept at using built-in Python data structures and methods. Understand methods for lists, dictionaries, sets, strings, etc., and know when to apply them.
  • Handle input/output: Review input/output operations in Python, including reading input, opening files, and writing output. Develop proficiency in debugging with print statements.
  • Communication is key: Practice speaking through your code as you would during the interview; articulate the purpose of each line. After writing a solution, generate test cases after coding, considering base cases, edge cases, and invalid input.
  • Coding style matters: Embrace good coding style with meaningful variable names, proper indentations, and spaces for readability. Add comments where they enhance understanding. Your code should be clear enough for an interviewer to read and understand your thought process. Practice writing clear code early so it’s second nature during your interview.
  • Problem-solving approach: If you encounter difficulties, think aloud about how to break down the problem and try to solve smaller subproblems first. During the actual interview, you will have the interviewer to lean on—but if you’re practicing by yourself, you’ll have to work out ways to guide yourself. Consider using paper to write down ideas, write out test cases, and work out the logic step-by-step before coding.

Tips for basic level Python interview coding questions

For junior-level positions, interviewers aim to evaluate your aptitude for learning, problem-solving, and grasp of fundamental computer science concepts. While the assessment may not delve deeply into Python domain knowledge, being fluent in the language significantly enhances your coding speed and enables you to concentrate on solving the given problem effectively. When tackling a problem, prioritize developing a working solution initially, and then explore optimization possibilities. Recognize that problems often have multiple viable solutions, and experimenting with different approaches can be beneficial. At this early stage in your coding journey, gaining more practice proves to be the most advantageous strategy.

Tips for senior level Python interview coding questions

For senior-level Python interviews, anticipate a variety of challenges that extend beyond coding proficiency. As you become more specialized, the requirements for domain knowledge are likely to increase beyond fundamental understanding.  After spending significant time in the industry, preparing for the more pedagogical problems that often arise in interviews can feel both challenging and unfamiliar. Consider initially practicing with beginner-level problems to reacquaint yourself with the essential skills required for interviews before delving into more domain-specific scenarios. When you transition to advanced topics, approach them with a fresh perspective, acknowledging that your prior experiences may differ from the canonical questions often posed in interviews.

Basic Python interview questions

For questions at a beginner level, interviewers may want to evaluate your computer science fundamentals more than they want to see deeper knowledge of Python functions and capabilities. They may ask you not to use built-in functions and ask you to build them from scratch, to show that you understand how these functions work. Other times, they may expect you to demonstrate enough knowledge of the language to know when to use them. For interview practice, try writing multiple solutions for each problem you encounter. If you’re unsure what to use during the actual interview, ask your interviewer for clarification.

Question 1: Adding up elements in a list

Prompt: Write a Python function that takes a list of numbers and returns the sum of all elements in the list. For example, for the list [1, 2, 3, 4], the function should return 10. 

What this question evaluates: This question assesses basic list handling and the use of loops in Python. For this reason, don’t use the built-in Python sum function in your initial implementation.

Solution:

def sum_of_list(numbers):
    total = 0
    for number in numbers:
        total += number
    return total

Explanation of solution: The function iterates over each element in the list numbers using a for loop. It initializes a variable total to 0 and adds each element of the list to this variable, accumulating the sum. Finally, it returns the total sum of the elements.

Question 2: Finding the highest number in a list

Prompt: Build on your previous function to return the largest number in the list, in addition to the sum. For the list [1, 2, 3, 4], the function should return the sum 10 and the maximum number 4.

What this question evaluates: This question builds on the first question by adding an understanding of how to compare elements in a list. For this problem, don’t use the built-in max function.

Solution:

def sum_and_max_of_list(numbers):
    total = 0
    max_number = numbers[0]  # Assume the first number is the largest initially
    for number in numbers:
        total += number
        if number > max_number:
            max_number = number
    return total, max_number

Explanation of solution: The function initializes two variables: total to store the sum and max_number to store the current maximum number, initially set to the first element in the list. As it iterates through the list, it adds each element to total. Simultaneously, it checks if each element is greater than the current max_number. If so, it updates max_number. It returns both the total sum and the maximum number found in the list.

Question 3: Counting occurrences of a specific element in a list

Prompt: Write a function that takes a list and a target number, and returns the count of occurrences of the target number in the list. For instance, in the list [1, 2, 3, 2, 2, 4] and target number 2, the function should return 3.

What this question evaluates: This question tests basic list operations and conditional logic in loops. Avoid using the count function at this time in order to practice the underlying technique.

Solution:

def count_occurrences(numbers, target):
count = 0
    for number in numbers:
        if number == target:
            count += 1
    return count

Explanation of solution: The function iterates over the list numbers. It uses a variable count to keep track of how many times the target number appears in the list. Each time it finds the target number, it increments count. After iterating through the list, it returns the total count of the target number’s occurrences.

Intermediate to advanced Python interview practice questions

In tackling intermediate-level questions and beyond, the emphasis pivots toward evaluating advanced problem-solving proficiency and a more profound familiarity with intricate coding concepts.  A deeper understanding of Python becomes not just beneficial but increasingly necessary, as you’ll be expected to have sufficient knowledge about the inner workings of the implementation of Python’s built-in methods and data structures. The expectation extends beyond simply problem-solving to an understanding of efficient solutions and the strategic trade-offs involving time and space in your implementations. Successful preparation for interviews at this level involves practicing a diverse set of challenging coding exercises, mastering more complex algorithms, and deepening your understanding of Python’s libraries and data structures.

Python algorithms interview questions

Question 1: Reversing a string

Prompt: Write a Python function to reverse a given string. For example, if the input string is “hello”, the output should be “olleh”.

What this question evaluates: This question assesses basic understanding of string manipulation and iteration in Python.

Solution:

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

Explanation of solution: The solution uses Python’s slicing mechanism. The slice [::-1] is a common Python idiom for reversing a string (or a list). It starts from the end towards the first character, stepping backwards. s[::-1] takes the entire string s and reverses it.

Question 2: Checking for a palindrome

Prompt: Enhance the previous function to check if the given string is a palindrome. A palindrome is a word that reads the same backward as forward, e.g., “radar”.

What this question evaluates: This question builds on the first question by adding conditional logic and understanding of string properties.

Solution:

def is_palindrome(s):
reversed_s = s[::-1]
    return s == reversed_s

Explanation of solution: This solution first reverses the input string using the slicing method s[::-1]. It then compares the original string s with the reversed string. If they are identical, it means the string is a palindrome.

Question 3: Counting palindromic substrings

Prompt: Write a function to count the number of palindromic substrings in a given string. For instance, in the string “aba”, there are three palindromic substrings: “a”, “b”, “aba”.

What this question evaluates: This question tests more advanced algorithmic thinking that involves string manipulation, nested loops, and understanding of substrings.

Solution:

def count_palindromic_substrings(s):
count = 0
    for i in range(len(s)):
        for j in range(i, len(s)):
            if s[i:j+1] == s[i:j+1][::-1]:
                count += 1
    return count

Explanation of solution: The function uses nested loops to generate all possible substrings of the input string. The outer loop fixes the starting point of the substring, and the inner loop varies the endpoint. For each substring generated (s[i:j+1]), the function checks if it is a palindrome (by comparing it to its reverse). The count is incremented each time a palindromic substring is found.

Python data structures interview questions

Question 1: Implementing a stack

Prompt: Implement a stack data structure in Python using lists. Your stack should support push, pop, and peek operations.

What this question evaluates: This question assesses the understanding of basic data structures (like stacks) and methods to manipulate them using Python lists.

Solution: 

class Stack:
def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[-1] if self.items else None
    def is_empty(self):
        return len(self.items) == 0

Explanation of solution: The Stack class uses a Python list to store elements. push adds an item to the end of the list, pop removes the last item, and peek returns the last item without removing it. is_empty checks whether the stack is empty, which is crucial for the subsequent questions.

Question 2: Creating a queue using 2 stacks

Prompt: Using your stack implementation from Question 1, create a queue data structure. Implement enqueue and dequeue operations using two instances of your stack.

What this question evaluates: This question builds upon the stack implementation to create a more complex data structure (queue) using two stacks. This tests the understanding of how different data structures can be combined and the efficiency of operations.

Solution:

class Queue:
def __init__(self):
        self.in_stack = Stack()
        self.out_stack = Stack()
    def enqueue(self, item):
        self.in_stack.push(item)
    def dequeue(self):
        if self.out_stack.is_empty():
            while not self.in_stack.is_empty():
                self.out_stack.push(self.in_stack.pop())
        return self.out_stack.pop()

Explanation of solution: The Queue class uses two instances of the Stack class. One stack (in_stack) is used for enqueue operations, and the other (out_stack) for dequeue operations. For dequeue, if out_stack is empty, all elements from in_stack are popped and pushed into out_stack. This reverses the order of elements, making the earliest enqueued element available for dequeue.

Question 3: Make a balanced parentheses checker

Prompt: Write a function that uses your stack implementation to check if a string of parentheses (e.g., ‘((()))’, ‘()()’) is balanced. Every opening parenthesis must have a corresponding closing parenthesis.

What this question evaluates: This question requires using the stack to solve a common programming problem, testing knowledge of both data structures and algorithms, as well as string processing.

Solution:

def is_balanced_parentheses(string):
stack = Stack()
    for char in string:
        if char == '(':
            stack.push(char)
        elif char == ')':
            if stack.is_empty():
                return False
            stack.pop()
    return stack.is_empty()

Explanation of solution: This function iterates through each character in the input string. If an opening parenthesis is encountered, it is pushed onto the stack. For a closing parenthesis, the function checks if the stack is empty (unmatched closing parenthesis) or pops from the stack (matching pair found). At the end, if the stack is empty, all parentheses are balanced; otherwise, they are not.

Python automation testing interview questions

Question 1: Writing a basic test case using unittest

Prompt: Write a Python test case using the unittest framework to test a function add(a, b) that returns the sum of two numbers. Include both a passing and a failing test.

What this question evaluates: This question assesses the basic understanding of the unittest framework, one of Python’s standard libraries for testing. It evaluates the ability to write simple test cases and understand test results.

Solution:

import unittest
def add(a, b):
    return a + b
class TestAddFunction(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add(1, 2), 3)
    def test_failed_addition(self):
        self.assertNotEqual(add(1, 2), 4)
if __name__ == '__main__':
    unittest.main()

Explanation of solution: The test class TestAddFunction extends unittest.TestCase. Two test methods are defined: test_addition (a passing test) and test_failed_addition (a failing test), using assertEqual and assertNotEqual to verify the function’s output.

Question 2: Implementing mocking in a test case

Prompt: Suppose you have a function fetch_data(api_url) that retrieves data from an API. Write a test case using unittest.mock to mock the API call, ensuring it does not make an actual HTTP request. Test that the function returns a predefined response.

What this question evaluates: This tests the candidate’s knowledge of mocking in Python, a crucial technique for testing code that interacts with external services or dependencies. It evaluates the ability to mock external calls to isolate tests from their external dependencies, allowing you to precisely control the inputs and outputs to validate the code handles various scenarios and edge cases

Solution:

import unittest
from unittest.mock import patch
def fetch_data(api_url):
    # Function that makes an HTTP request to the provided api_url
    pass
class TestFetchData(unittest.TestCase):
    @patch('path.to.fetch_data_function')
    def test_mock_api_call(self, mock_fetch):
        mock_fetch.return_value = "Mocked Data"
        response = fetch_data("http://example.com/api")
        self.assertEqual(response, "Mocked Data")
if __name__ == '__main__':
    unittest.main()

Explanation of solution: The unittest.mock module is used to replace the fetch_data function with a mock during the test. @patch decorator is applied to mock the function. mock_fetch.return_value sets a predefined return value for the mock. The test verifies that fetch_data returns the mocked response instead of performing a real API call.

Question 3: Testing asynchronous code

Prompt: Write a test case for an asynchronous function async fetch_data(api_url) that retrieves data from an API. Ensure the test properly waits for the function to complete and checks the returned result.

What this question evaluates: This question focuses on testing asynchronous Python code, a key skill in modern Python development. It assesses understanding of async features in Python and the ability to write tests for async functions.

Solution:

import asyncio
import unittest
async def fetch_data(api_url):
    # Asynchronous function to fetch data
    pass
class TestAsyncFetchData(unittest.TestCase):
    def test_async_fetch_data(self):
        loop = asyncio.get_event_loop()
        response = loop.run_until_complete(fetch_data("http://example.com/api"))
        self.assertEqual(response, expected_response)
if __name__ == '__main__':
    unittest.main()

Explanation of solution: This solution involves testing an asynchronous function fetch_data. An event loop is obtained using asyncio.get_event_loop(). loop.run_until_complete() is used to run the asynchronous function within the test, ensuring the test waits for its completion. The result of the async function is then tested using assertEqual.

Python full-stack engineer interview questions

If you’re interviewing for a more senior web-development position at a company that uses a Python web framework, you may encounter domain specific questions in Django or Flask. These questions will test your understanding of the frameworks and how you would use them in a practical context to build or expand on a web application. In addition to doing practice problems like the ones below, consider creating a small web application from the ground up to solidify your foundations in your chosen framework. If the position you’re interviewing for is full-stack, be sure to brush up on your front skills, like HTML and CSS, as well. 

Django interview questions

Question 1: Designing a basic Django model

Prompt: Design a Django model Book with fields for title (a string), author (a string), and publication_date (a date). Show how you would create a new instance of this model in the Django shell.

What this question evaluates: This question assesses understanding of Django models, one of the core components of Django. It tests knowledge of defining models and basic operations like creating new instances.

Solution:

from django.db import models
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    publication_date = models.DateField()
# Creating an instance in the Django shell
# from myapp.models import Book
# book = Book(title='Sample Book', author='Author Name', publication_date='2023-01-01')
# book.save()

Explanation of solution: The Book model is defined with three fields: title, author, and publication_date. The model is a subclass of django.db.models.Model. An example is provided for creating an instance of Book in the Django shell, including saving it to the database.

Question 2: Creating Django views and URL configuration

Prompt: Write a Django view function to display a list of Book instances (from Question 1). Then, demonstrate how to configure the URL pattern for this view in Django’s URL dispatcher.

What this question evaluates: This question expands upon basic Django knowledge to include views and URL configurations. This assesses the ability to connect models to views and configure URL patterns, essential for building Django web applications.

Solution:

# views.py
from django.http import HttpResponse
from .models import Book
def book_list(request):
    books = Book.objects.all()
    output = ', '.join([book.title for book in books])
    return HttpResponse(output)
# urls.py
from django.urls import path
from . import views
urlpatterns = [
    path('books/', views.book_list, name='book_list'),
]

Explanation of solution: A view function book_list is created in views.py. It retrieves all Book instances and returns a simple HTTP response with the titles. The URL pattern for this view is defined in urls.py, mapping the route ‘books/’ to the book_list view.

Question 3: Implementing Django REST framework serializer

Prompt: Using Django REST Framework, create a serializer for the Book model. Then, write a view to handle a GET request that returns a JSON response containing all books using this serializer.

What this question evaluates: This question tests more advanced Django skills, focusing on Django REST Framework, a key tool for building APIs. It evaluates the understanding of serializers and viewsets for handling HTTP requests and generating JSON responses.

Solution:

# serializers.py
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['title', 'author', 'publication_date']
# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Book
from .serializers import BookSerializer
class BookList(APIView):
    def get(self, request, format=None):
        books = Book.objects.all()
        serializer = BookSerializer(books, many=True)
        return Response(serializer.data)
# urls.py
from django.urls import path
from .views import BookList
urlpatterns = [
    # ... other url patterns ...
    path('api/books/', BookList.as_view(), name='api_book_list'),
]

Explanation of solution: A BookSerializer class is defined using Django REST Framework’s serializers.ModelSerializer. It specifies the model to serialize and the fields to include. A class-based view BookList is created, using APIView from Django REST Framework. It handles GET requests and returns a JSON response containing serialized data of all books. The corresponding URL pattern is added to urls.py, pointing to the BookList view for the route ‘api/books/’.

Flask interview questions

Question 1: Setting up a basic Flask application

Prompt: Describe how to set up a basic Flask application with a single route ‘/’ that returns the text “Welcome to Flask!” when accessed.

What this question evaluates: This question assesses fundamental knowledge of the Flask framework, focusing on application setup, route creation, and view functions.These skills are  essential for understanding the basic structure of a Flask application.

Solution:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
    return "Welcome to Flask!"
if __name__ == '__main__':
    app.run(debug=True)

Explanation of solution: A Flask app instance is created. A route ‘/’ is defined using the @app.route decorator. The corresponding view function home returns a simple string. The app.run(debug=True) statement runs the Flask application with debug mode enabled.

Question 2: Using Flask with template rendering

Prompt: Extend the basic Flask application from Question 1 to render an HTML template when accessing the ‘/’ route. Assume the HTML file is named index.html and located in a templates folder. The template should display “Welcome to Flask with Templates!”.

What this question evaluates: This question builds on the basic Flask setup to include template rendering, a key feature in Flask for displaying HTML content. It evaluates the candidate’s understanding of integrating Flask with HTML templates.

Solution:

# Assuming index.html is in the 'templates' folder
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def home():
    return render_template('index.html')
# index.html content:
# <html>
# <head><title>Flask Template</title></head>
# <body><h1>Welcome to Flask with Templates!</h1></body>
# </html>

Explanation of solution: The render_template function from Flask is used to render an HTML template. The home view function now returns render_template(‘index.html’), rendering the index.html file from the templates directory. The index.html file contains basic HTML to display a welcome message.

Question 3: Creating a Flask REST API endpoint

Prompt: Create a REST API endpoint in the Flask application that responds to GET requests at /api/data. It should return a JSON object with a key message and value “Flask API response”.

What this question evaluates: This question assesses the ability to build RESTful APIs with Flask, a common requirement in full-stack development. It tests for understanding of HTTP methods, route creation for APIs, and JSON data handling in Flask.

Solution:

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/api/data', methods=['GET'])
def get_data():
    return jsonify({'message': 'Flask API response'})
if __name__ == '__main__':
    app.run(debug=True)

Explanation of solution: The Flask route /api/data is defined to handle GET requests. The view function get_data returns a JSON response using jsonify, a Flask utility to convert Python dictionaries to JSON. The response contains a message. This setup demonstrates how to create a simple RESTful endpoint in Flask.

Python data science interview questions

Python is commonly used in data science for its simplicity and the large number of helpful libraries available, like NumPy and Pandas. Since data scientists come from a variety of backgrounds, including software development or more pure statistics, the level of coding ability expected in an interview will differ. Be upfront with interviewers about your background and experience; in general, however, familiarity with Python fundamentals and practical problems with your chosen libraries will help. If you’re newer to Python data manipulation, consider first solidifying fundamentals through online courses and personal projects before attempting interviews. Nothing beats experience in this domain.

NumPy interview questions

Question 1: Creating and manipulating NumPy arrays

Prompt: Write a NumPy script to create a 2×3 array of ones and then reshape it to a 3×2 array. Discuss the implications of reshaping an array in terms of data layout in memory.

What this question evaluates: This question tests basic understanding of NumPy array creation and manipulation, including array reshaping. It also assesses the candidate’s knowledge of NumPy’s memory management when modifying array shapes.

Solution:

import numpy as np
# Creating a 2x3 array of ones
array = np.ones((2, 3))
# Reshaping to a 3x2 array
reshaped_array = array.reshape((3, 2))
# Reshaping an array does not modify the underlying data in memory.
# It creates a new view on the existing data, arranged in the new shape.

Explanation of solution: A 2×3 array of ones is created using np.ones((2, 3)). The array is reshaped to 3×2 using reshape((3, 2)). Reshaping provides a new view on the same data, so it’s memory efficient as the data is not duplicated.

Question 2: Indexing and slicing an array

Prompt: Given a 2D NumPy array, write a function to select and return a subarray consisting of the first two rows and the last two columns. Explain how slicing affects memory usage and the relationship between the original and sliced arrays.

What this question evaluates: This question evaluates the candidate’s skills in array indexing and slicing, crucial for data manipulation in NumPy. It also tests for understanding of how slicing works in terms of memory (i.e., views vs. copies).

Solution:

import numpy as np
def select_subarray(array):
    # Selecting the first two rows and the last two columns
    subarray = array[:2, -2:]
    return subarray
# Slicing creates a view on the original array, not a copy.
# Changes to the subarray will affect the original array and vice versa.

Explanation of solution: The function select_subarray demonstrates slicing to extract a specific part of an array.  Rather than making copies, slicing creates a view, meaning the subarray shares data with the original array. This is memory efficient but requires care; because they reference the same data, modifying one affects the other.

Question 3: Using vectorized operations and broadcasting

Prompt: Describe how to perform element-wise multiplication of two 1D arrays of different lengths using NumPy’s broadcasting rules. Provide an example and explain the concept of broadcasting in NumPy.

What this question evaluates: This question assesses advanced understanding of NumPy, focusing on vectorized operations and broadcasting, which are key for efficient data manipulation. It tests the candidate’s ability to apply these concepts to solve problems with arrays of different shapes.

Solution:

import numpy as np
def multiply_arrays(a, b):
    # Element-wise multiplication using broadcasting
    return a * b
# Example: Multiplying arrays of different lengths
array1 = np.array([1, 2, 3])
array2 = np.array([4])
# Broadcasting rules allow this operation by 'stretching' array2
# to [4, 4, 3] before performing element-wise multiplication.
result = multiply_arrays(array1, array2)
# Broadcasting is a powerful concept in NumPy that allows vectorized operations
# on arrays of different sizes, making code efficient and concise.

Explanation of solution: The function multiply_arrays performs element-wise multiplication, showcasing NumPy’s broadcasting capabilities. Broadcasting automatically ‘expands’ smaller arrays for vectorized operations, avoiding explicit data replication and thus enhancing performance. The example illustrates how an array of length 1 (array2) is ‘stretched’ to match the size of array1 for multiplication, demonstrating the utility and power of broadcasting in NumPy.

Pandas interview questions

Question 1: Manipulating a dataframe

Prompt: Given a Pandas DataFrame, write a function to filter out rows where a specified column’s value is less than a given threshold and return the filtered DataFrame. For example, given a DataFrame with a column ‘Age’, filter out all rows where ‘Age’ is less than 30.

What this question evaluates: This question tests basic DataFrame manipulation skills, specifically filtering rows based on column values. It evaluates the candidate’s understanding of conditional selection in Pandas.

Solution:

import pandas as pd
def filter_dataframe(df, column, threshold):
    return df[df[column] >= threshold]
# Example usage
# df = pd.DataFrame({'Age': [25, 30, 45, 20]})
# filtered_df = filter_dataframe(df, 'Age', 30)

Explanation of solution: The function filter_dataframe filters rows in a DataFrame based on a column value threshold. It uses boolean indexing (df[column] >= threshold) to select rows where the column value meets the condition.

Question 2: Handling missing data

Prompt: How would you handle missing data in a Pandas DataFrame? Write a function that takes a DataFrame and fills missing values in a specified column with the column’s mean value.

What this question evaluates: This question assesses the candidate’s ability to handle missing data, a common issue in real-world datasets. It tests knowledge of Pandas methods for dealing with null or NaN values, specifically imputing missing data.

Solution:

import pandas as pd
def fill_missing_values(df, column):
    mean_val = df[column].mean()
    df[column].fillna(mean_val, inplace=True)
    return df
# Example usage
# df = pd.DataFrame({'Values': [1, 2, None, 4]})
# df_filled = fill_missing_values(df, 'Values')

Explanation of solution: The function fill_missing_values calculates the mean of the specified column and fills missing values with this mean. fillna is used with inplace=True to modify the original DataFrame. This is a common approach to handle NaN values in datasets.

Question 3: Using merge and join operations

Prompt: Explain how to perform merge and join operations between two DataFrames in Pandas. Provide an example function that takes two DataFrames and a key column, and returns a merged DataFrame based on that key.

What this question evaluates: This question focuses on understanding more advanced DataFrame operations, such as merging and joining, which are core techniques for combining datasets in data analysis tasks. It tests the candidate’s proficiency in manipulating and consolidating data from multiple sources.

Solution:

import pandas as pd
def merge_dataframes(df1, df2, key_column):
    return pd.merge(df1, df2, on=key_column)
# Example usage
# df1 = pd.DataFrame({'Key': ['A', 'B', 'C'], 'Data1': [1, 2, 3]})
# df2 = pd.DataFrame({'Key': ['B', 'C', 'D'], 'Data2': [4, 5, 6]})
# merged_df = merge_dataframes(df1, df2, 'Key')

Explanation of solution: The function merge_dataframes demonstrates how to merge two DataFrames using a common key column.pd.merge is a versatile function in Pandas for database-style joining of DataFrames. The example shows an inner join, but other join types (left, right, outer) can be specified with the how parameter.

Python machine learning & AI interview questions

As with data science, Python has emerged as the primary and most popular programming language for machine learning today. Interviews for such positions will likely cover some topics in Python. Although some positions may be open to candidates who demonstrate a strong foundational understanding and a willingness to learn, many machine learning and AI roles may require more advanced expertise. Interview questions evaluating familiarity and comfortability with Tensorflow tend to be more involved and can require data manipulation, as we demonstrate with the following practice problems. In addition to solving these questions, prepare by training additional models and staying informed about current machine learning trends.

TensorFlow interview questions

Question 1: Using basic TensorFlow operations

Prompt: Demonstrate how to create a TensorFlow constant tensor and a variable tensor. Perform a basic arithmetic operation (like addition) between them and print the result.

What this question evaluates: This question tests fundamental TensorFlow concepts, such as creating constants and variables, and performing tensor operations. It evaluates the candidate’s understanding of the basic building blocks of TensorFlow.

Solution:

import tensorflow as tf
# Creating a constant and a variable tensor
const_tensor = tf.constant([1, 2, 3])
var_tensor = tf.Variable([4, 5, 6])
# Performing addition
result = const_tensor + var_tensor
print(result.numpy())

Explanation of solution: A TensorFlow constant (tf.constant) and variable (tf.Variable) are created. These tensors are then added together using the + operator. The result is printed using the .numpy() method to convert the tensor to a NumPy array for easy visualization.

Question 2: Building and training a simple neural network

Prompt: Using TensorFlow, create a simple neural network model to classify handwritten digits (you can use the MNIST dataset). Describe the model architecture, compile the model, and outline the training process.

What this question evaluates: This question assesses the candidate’s ability to build and train a basic neural network using TensorFlow. It tests knowledge of model architecture, compiling models, and understanding training workflows.

Solution:

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import SGD
# Load the MNIST dataset
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# Normalize the images
train_images = train_images / 255.0
test_images = test_images / 255.0
# Building the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])
# Compiling the model
model.compile(optimizer=SGD(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Training the model
model.fit(train_images, train_labels, epochs=5)
# Evaluate the model
model.evaluate(test_images, test_labels)

Explanation of solution: The solution involves loading the MNIST dataset and normalizing the image data. A sequential model is built using Dense layers, including a flatten layer for the input and a softmax activation for the output. The model is compiled with the SGD optimizer and sparse categorical cross-entropy loss function. The model is trained using the fit method and evaluated on test data.

Question 3: Implementing custom loss functions

Prompt: Write a custom loss function in TensorFlow and demonstrate how to use it in training a model. Explain in what scenarios custom loss functions are necessary and how they are integrated into the training process.

What this question evaluates: This advanced question explores the candidate’s ability to customize aspects of the neural network training process. It assesses understanding of loss functions in TensorFlow and how to implement and integrate custom functionalities.

Solution:

import tensorflow as tf
# Custom loss function
def custom_loss_function(y_true, y_pred):
    return tf.reduce_mean(tf.square(y_true - y_pred))
# Example model (could be any model)
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(input_shape,)),
    tf.keras.layers.Dense(1)
])
# Compile the model with the custom loss function
model.compile(optimizer='adam', loss=custom_loss_function)
# Train the model
# model.fit(X_train, y_train, epochs=10)

Explanation of solution: A custom loss function is defined, which calculates the mean squared error between the true and predicted values. An example neural network model is defined using the Sequential API. The model is compiled, specifying the custom loss function in the loss parameter. This approach allows for flexibility in model training, particularly in scenarios where standard loss functions are inadequate or need customization.

Next steps & resources

As you continue preparing for your Python interview, it’s important to delve deeper into the concepts and problems we’ve discussed. Practice is key—try to implement these problems and their solutions on your own, experiment with variations, and explore additional challenges in the topics most relevant for your job search. 

Beyond coding, familiarize yourself with Python’s ecosystem, including popular libraries and frameworks relevant to your field, whether it’s web development, machine learning, or another specialization. Engaging with community resources—online forums, coding challenges, and open-source projects—can provide practical experience and expose you to real-world applications of Python that can expand your knowledge. Practicing interview scenarios, either solo or with a peer, can also help you build confidence and improve your problem-solving speed.

CodeSignal Learn is a revolutionary learning product for anyone launching a technical career, pivoting into a new role, building competitive and in-demand skills for a job search, or leveling-up in their current role. Take courses in machine learning, data science, Python programming, and more with one-on-one support from the smartest AI guide in the universe, Cosmo. Join the waitlist to get started for free.