When NumPy is not fast enough - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Comparing execution time of NumPy and pure Python loops

What will be the output of the following code snippet that compares the sum of squares using NumPy and a Python loop?

NumPy

import numpy as np
import time

arr = np.arange(1_000_000)

start = time.time()
result_numpy = np.sum(arr ** 2)
end = time.time()
numpy_time = end - start

start = time.time()
result_loop = 0
for x in arr:
    result_loop += x ** 2
end = time.time()
loop_time = end - start

print(f"NumPy sum: {result_numpy}, Time: {numpy_time:.4f} seconds")
print(f"Loop sum: {result_loop}, Time: {loop_time:.4f} seconds")

A

NumPy sum: 333332833333500000, Time: 1.2000 seconds
Loop sum: 333332833333500000, Time: 0.0050 seconds

B

NumPy sum: 333332833333500000, Time: 0.0050 seconds
Loop sum: 333332833333500000, Time: 1.2000 seconds

C

NumPy sum: 500000500000, Time: 0.0050 seconds
Loop sum: 500000500000, Time: 1.2000 seconds

D

NumPy sum: 333332833333500000, Time: 0.0050 seconds
Loop sum: 0, Time: 1.2000 seconds

💡 Hint

NumPy uses optimized C code internally, so it runs much faster than Python loops.

The NumPy sum of squares is correct and computed very fast. The Python loop computes the same sum but takes much longer.

❓ data_output

intermediate

Result shape after applying a slow Python function with np.vectorize

Given the code below, what is the shape of the output array?

NumPy

import numpy as np

def slow_func(x):
    return x ** 2 + 1

vec_func = np.vectorize(slow_func)
arr = np.arange(12).reshape(3,4)
result = vec_func(arr)
print(result.shape)

A (3, 4)

B (12,)

C (4, 3)

D (1, 12)

💡 Hint

np.vectorize preserves the input array shape.

np.vectorize applies the function element-wise and returns an array with the same shape as the input.

🔧 Debug

advanced

Why does this Numba JIT function run slower than NumPy?

Consider this code using Numba's JIT to speed up a function. Why might it run slower than the pure NumPy version?

NumPy

import numpy as np
from numba import jit

@jit(nopython=True)
def sum_squares(arr):
    total = 0
    for i in range(arr.size):
        total += arr[i] ** 2
    return total

arr = np.arange(1_000_000)

import time
start = time.time()
result_numba = sum_squares(arr)
end = time.time()
numba_time = end - start

start = time.time()
result_numpy = np.sum(arr ** 2)
end = time.time()
numpy_time = end - start

print(f"Numba time: {numba_time:.4f} seconds")
print(f"NumPy time: {numpy_time:.4f} seconds")

A Numba runs slower because np.arange is incompatible with Numba.

B Numba runs slower because the JIT compiler is not installed correctly.

C Numba runs slower because the function uses a Python loop instead of vectorized operations.

D Numba runs slower because the function is missing a return statement.

💡 Hint

Numba speeds up loops but cannot beat fully vectorized NumPy operations.

Numba speeds up loops but vectorized NumPy operations are implemented in optimized C code and often run faster than explicit loops, even JIT compiled.

🧠 Conceptual

advanced

When to consider alternatives to NumPy for speed

Which scenario is the best reason to consider alternatives like Numba or Cython instead of pure NumPy?

A When you want to use built-in NumPy functions for matrix multiplication.

B When you want to plot data using matplotlib.

C When you want to load data from CSV files quickly.

D When you need to speed up element-wise operations that cannot be vectorized easily.

💡 Hint

Think about when vectorization is not possible or practical.

NumPy is fast for vectorized operations. For complex element-wise logic that can't be vectorized, tools like Numba or Cython can speed up loops.

🚀 Application

expert

Optimizing a custom function with Numba for large arrays

You have a custom function that applies a complex formula element-wise on a large NumPy array. The pure Python loop is too slow. Which approach will most likely give the best speedup?

A Use Numba's @jit decorator with nopython=True on the loop function.

B Rewrite the function using only Python built-in functions without NumPy.

C Use np.vectorize to apply the function element-wise.

D Convert the array to a list and use a Python list comprehension.

💡 Hint

Consider which method compiles loops to fast machine code.

Numba's JIT with nopython=True compiles loops to fast machine code, giving large speedups for complex element-wise functions on arrays.