Top 20 NumPy Interview Questions: From Basic to Advanced

Intermediate NumPy Interview Questions

These questions dive deeper into actually using NumPy. Once you’ve established a fundamental understanding of NumPy’s arrays, you should explore its functionality. Performing calculations with NumPy can be expected at the intermediate level.

6. How do you create an array of all zeros or all ones?

Creating arrays filled with zeros or ones is a common requirement in many data science tasks, such as initializing matrices, creating mask arrays, or setting up placeholder data structures. 

To create an array of all zeros or all ones in NumPy, you use the np.zeros() or np.ones() functions:

import numpy as np

# Create a 3x4 array of zeros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Create a 2x2 array of ones
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. What is broadcasting in NumPy?

Broadcasting is a key NumPy behavior that allows for efficient operations on arrays of different sizes. 

Simply put, it allows for arithmetic operations between arrays of different sizes by ensuring both arrays have compatible shapes. This is done when NumPy automatically replicates smaller arrays across the larger array so that they have compatible shapes. 

See the following example:

import numpy as np

a = np.array([1, 2, 3])b = np.array([[1], [2], [3]])
print(a + b)
# Output:
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

8. How do you find the mean, median, and standard deviation of a NumPy array?

The mean, median, and standard deviation are key descriptive statistics commonly used to understand our data. NumPy calculates these very easily and has functions specially built for them. 

Knowing these calculations is important for enhancing our ability to utilize NumPy:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Mean
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Output: 3.0

# Median
median_value = np.median(arr)
print("Median:", median_value)  # Output: 3.0

# Standard deviation
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Output: 1.4142135623730951

9. How can we utilize NumPy to quickly query our numerical data and perform actions based on a boolean statement?

While we think of NumPy’s primary purpose as a calculation package, it also has powerful data-wrangling capabilities. 

NumPy can easily query data through boolean indexing and perform operations based on results. The where() method is particularly useful when we want to make changes to our data based on numerical values.

Assume we have a data frame of exam scores named df and want to categorize the students. A simple np.where() may look like:

df[‘student_cat’] = np.where(df[‘score’] > 80, ‘good’, ‘bad’)

Note that the where() method takes up to 3 inputs: 

• The first is the boolean statement of any kind
• The second is the result if true
• The third is the result if false

10. What is a way to utilize NumPy for something like Mean Squared Error?

NumPy’s ability to work across an entire array at once makes implementing calculations like Mean Squared Error (MSE) simple. 

Because it performs simple operations on an element-by-element basis it easily vectorizes the operation and provides an efficient way of calculating MSE. 

An example of an implementation of MSE in NumPy follows:

# 1. We have two arrays, our prediction, and actual labels
# 2. We take the squared differences and sum them
# 3. We then divide by n, which is the length of the array

n= len(labels)
error = (1/n) * np.sum(np.square(predictions - labels))

Advanced NumPy Interview Questions

Now, it’s time to enter advanced territory! You’re expected to use NumPy to solve more complex problems at this level.

11. How can you compute the rolling statistics using NumPy, such as a rolling mean?

Rolling statistics such as a rolling average are very important in data science. The rolling mean is often used to smooth noisy data, especially if it is time-based. 

A little-known functionality of NumPy is “strides.” One of the ways stride is implemented is to create a sliding window view of your array. Using lib.stride_tricks.sliding_window_view(), you can easily generate array subsets. 

You can then do any sort of summarization, such as calculating the mean, on each of these subsets to obtain a rolling average. Here’s an example implementation:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# This creates v, an array that contains subarrays of length 3 which reflect the size of the window.

12. How do you perform advanced indexing to select elements from a multidimensional array based on a condition?

While indexing may be a fundamental skill for NumPy, leveraging more advanced indexing techniques can allow data scientists to slice their data more precisely. 

By utilizing integer array indexing and boolean indexing, creating datasets that meet specific criteria becomes trivial.

import numpy as np

array = np.array([[10, 15, 20, 25],
                  [30, 35, 40, 45],
                  [50, 55, 60, 65]])
print(array)  # Output: 
# [[10 15 20 25]
#  [30 35 40 45]
#  [50 55 60 65]]

# Boolean indexing: Select elements greater than 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Apply the condition to get the elements that meet the criteria
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Integer array indexing: Select specific elements based on row and column indices
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 2, 3])
selected_elements = array[row_indices, col_indices]
print(selected_elements)  # Output: [15 40 65]

# Combining boolean and integer indexing
# Select elements from the array where the element is greater than 30 and belongs to specific indices
combined_condition = (array > 30) & ((row_indices[:, None] == np.arange(3)).any(axis=0))
filtered_selected_elements = array[combined_condition]
print(filtered_selected_elements)  # Output: [35 40 45 50 55 60 65]

13. How can you use NumPy to perform a linear algebra operation like matrix decomposition or solve a linear equation system?

Performing matrix decomposition is vital for data scientists dealing with large data volumes. Reducing data to its principal components is a critical first step in reducing complexity and noise. 

NumPy’s linalg module allows us to easily perform linear algebra to obtain principal components. 

# The underlying signal is a sinusoidally modulated image
img = lena() # This is from scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# We add some noise
noisy = real + np.random.randn(*true.shape)*255

# (observations, features) matrix
M = noisy.reshape(noisy.shape[0],-1)

# Singular value decomposition factorizes your data matrix such that:
#   M = U*S*V.T     (where '*' is matrix multiplication)
# * U and V are the singular matrices containing orthogonal vectors of unit length
# * S is a diagonal matrix containing the singular values of M - we can use this to calculate our PCs

# Obtain the results of SVD from our noisy matrix
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpose V to get our PC vectors
V = Vt.T

# PCs are already sorted by descending order of the singular values (i.e. by the proportion of total variance they explain)
# If we use all of the PCs we can reconstruct the noisy signal perfectly
S = np.diag(s)
Mhat = np.dot(U, np.dot(S, V.T))
print(“Using all PCs, MSE = %.6G" %(np.mean((M - Mhat)**2)))

14. How can you optimize memory usage when working with large arrays in NumPy?

A rarely used functionality of NumPy is memmap(). This allows us to store arrays as a file, which allows us to read larger arrays than we would purely in memory. Its main benefit is lazy data reading, which reduces the overall memory need while allowing us to assess the entire dataset. 

Cleverly using this function will allow a data scientist to work with large data more easily and conveniently.

​​import numpy as np

# Create a large array and save it to a file using memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Specify the data type of the array

# Create a memmap object with the desired shape and dtype
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Initialize the array with some values (e.g., fill it with random numbers)
large_array[:] = np.random.rand(*large_array_shape)

# Access a small part of the array without loading the entire array into memory
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: A 10x10 array with random float values

# Clean up and ensure that the changes are written to disk
del large_array

15. How can you handle and manipulate arrays with missing or infinite values in NumPy?

Dealing with missing and infinite values is common for data scientists. First, you might want to use NumPy’s isnan() or isinf() to find these missing and infinite values. 

If there is a systematic issue, we may want to assess our pipelines; otherwise, we may want to fill in these values. 

While we may not use NumPy directly to fill in missing values, we are often using NumPy functions in combination with something like pandas fillna() to fill in missing data. For instance, we may want to use NumPy’s mean() or median() functions to quickly fill in erroneous values.

NumPy Interview Questions for Data Scientists

Until now, we have covered general NumPy questions. Of course, the questions we reviewed before may apply to data science, but in this section, I compiled specific NumPy questions for data scientists.

16. Is there a way to quickly and easily apply functions to each row and column of a 2D array?

Sometimes, we need to perform custom calculations on our array to get information on each row or column. Thankfully, the NumPy method apply_along_axis() can be utilized to apply a custom function across a NumPy array. These functions are applied across the entirety of a particular axis in each array. 

import numpy as np

# Create a 2D array
data = np.array([
    [1, 2, 3, 4, 5],
    [10, 15, 20, 25, 30],
    [100, 200, 300, 400, 500]
])

# Define a function to compute the range of a 1D array
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Apply the compute_range function to each row (axis=1)
ranges = np.apply_along_axis(compute_range, axis=1, arr=data)
print("Range of each row:", ranges)
# Output:
# Range of each row: [  4  20 400]

17. How can you leverage NumPy to perform feature scaling and normalization of datasets for machine learning?

Normalization of data ensures we’re properly training our machine learning models. Without normalization, the scale can impact our model results, especially for distance-based models. 

We can use NumPy’s functions to easily perform scaling. Here's an example of min-max scaling that runs for all rows. Make sure you are choosing the right dimension when feature scaling.

import numpy as np

data = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# Min-Max Scaling
min_vals = np.min(data, axis=0)
max_vals = np.max(data, axis=0)
scaled_data = (data - min_vals) / (max_vals - min_vals)
print("Scaled Data:\n", scaled_data)
# Output:
# Scaled Data:
# [[0.   0.   0.  ]
#  [0.5  0.5  0.5 ]
#  [1.   1.   1.  ]]

18. What are some ways we can easily sort and index our NumPy arrays?

While we have something like the DataFrame sort_values() there are certain cases where we want to find the location of these sorted values. 

NumPy’s argsort() provides the positions that would sort a given array. One useful scenario is when we need to properly index other datasets to match our sorted arrays. By having the positions ready, we can utilize the output from argsort() to ensure consistency across our datasets.

19. What is one important aspect of NumPy’s random number generator that can be utilized to make it predictable and why?

Random number generators in computing are not genuinely random. They are based on an initial seed. Since we often want to test our data and be able to easily assess results, we must minimize the amount of randomness present in our pipeline. 

By utilizing NumPy’s random.seed() method, we can set the seed for an entire pipeline so that we can get similar results each time. Setting a specific seed allows us to assess whether improvements to our results are based on our model adjustments and not randomness.

20. Describe how you might implement K-Means in NumPy.

During an interview, you may be asked to implement an algorithm of some kind. The focus of these questions is to answer with a fundamental understanding of the model and the package. 

You do not need to memorize every line of code below, but be able to point out the key steps and methods needed. Make sure you’ve read about K-Means (and other basic algorithms) and understand how the algorithm works as well.

import numpy as np

# Generate a sample dataset
np.random.seed(42)  # For reproducibility
data = np.vstack([
    np.random.normal(loc=[1, 1], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[5, 5], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[9, 1], scale=0.5, size=(50, 2))
])
def k_means(X, k, max_iters=100, tol=1e-4):
    # Step 1: Initialize centroids randomly
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Step 2: Assign clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Step 3: Update centroids
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Check for convergence
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Apply k-means clustering
k = 3
centroids, cluster_assignments = k_means(data, k)

Final Thoughts

Building up your interview knowledge with NumPy is one of the critical steps to success in a career in data science. 

Start by practicing and understanding the fundamentals followed by specific implementation. The more you use Numpy the better you will understand and internalize its functions. Try some of the courses and tutorials in DataCamp, such as the following:

• Python Numpy Array Tutorial
• Numpy Cheat Sheet
• Numpy Crash Course