When NumPy is not fast enough - Step-by-Step Execution

Concept Flow - When NumPy is not fast enough

Start: NumPy operation

↓

Check: Is NumPy fast enough?

Yes→Use NumPy result

No↓

Try alternatives:

↓

Numba

↓

Faster computation

↓

Use result

Start with NumPy; if it's slow, try faster tools like Numba, Cython, or parallel processing to speed up.

Execution Sample

NumPy

import numpy as np
from numba import njit

@njit
def fast_sum(arr):
    total = 0
    for x in arr:
        total += x
    return total

arr = np.arange(1000000)
print(fast_sum(arr))

This code uses Numba to speed up summing a large NumPy array with a loop.

Execution Table

Step	Action	Evaluation	Result
1	Create NumPy array arr	np.arange(1000000)	Array of 1 million integers from 0 to 999999
2	Define fast_sum with @njit	Function compiled by Numba	fast_sum is ready for fast execution
3	Call fast_sum(arr)	Loop over arr adding elements	Sum calculated quickly using compiled code
4	Print result	Output sum of 0 to 999999	499999500000
5	End	All steps done	Program finishes

💡 Completed summing large array using Numba for speed

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
total	0	0 + 0 = 0	0 + 1 = 1	1 + 2 = 3	499999500000
x	N/A	0	1	2	999999

Key Moments - 3 Insights

Why does using a Python loop with NumPy arrays run slowly?

NumPy is fast with vectorized operations but slow with explicit Python loops, as shown in step 3 of the execution_table where looping in Python is replaced by Numba compiled code.

How does Numba speed up the loop?

Numba compiles the Python loop into fast machine code, avoiding Python overhead, as seen in step 2 and 3 where the function is compiled and runs faster.

Can we always replace NumPy operations with Numba?

No, Numba works best with simple loops and numerical code; complex NumPy functions or object arrays may not benefit, so choose based on your code.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is happening inside fast_sum?

A A Python loop adding elements slowly

B A Numba compiled loop adding elements quickly

C A vectorized NumPy sum operation

D A recursive function call

💡 Hint

Check step 2 and 3 in execution_table where @njit compiles the function and step 3 shows the loop running fast.

According to variable_tracker, what is the value of 'total' after adding the first three elements?

A 6

B 0

C 3

D 1

💡 Hint

Look at 'total' values After 1, After 2, and After 3 in variable_tracker.

If we remove @njit decorator, how would the execution_table change at step 3?

A The loop would run slower in pure Python

B The loop would run faster

C The function would not run at all

D The sum would be incorrect

💡 Hint

Consider the role of Numba in speeding up loops as explained in key_moments.

Concept Snapshot

When NumPy loops are slow, use tools like Numba to compile loops into fast code.
Numba's @njit decorator speeds up numerical loops.
Not all NumPy operations need Numba; vectorized code is already fast.
Use alternatives like Cython or parallel processing for more speed.
Test performance to choose the best method.

Full Transcript

This visual execution shows how NumPy can be slow when using Python loops. We start by creating a large NumPy array. Then we define a function fast_sum that sums elements using a loop. Normally, Python loops are slow with NumPy arrays. But by adding the @njit decorator from Numba, the function is compiled into fast machine code. The execution table traces each step: creating the array, compiling the function, running the fast loop, and printing the result. The variable tracker shows how the total sum accumulates step by step. Key moments explain why loops are slow in Python and how Numba speeds them up. The quiz tests understanding of these steps and the effect of removing Numba. This helps beginners see when and how to speed up NumPy code beyond its built-in fast operations.