How to Use Numba to Speed Up Python Execution ~ Fun Programming

Python is known for its simplicity and readability, but sometimes it falls short in terms of performance, especially for numerical and array-heavy computations. That’s where Numba comes in — a just-in-time (JIT) compiler that can significantly accelerate your Python code.

In this article, we’ll explore what Numba is, how it works, and how to use it effectively to make your Python programs run faster.

What is Numba?

Numba is an open-source JIT compiler that translates a portion of Python and NumPy code into fast machine code at runtime using the LLVM compiler infrastructure.

Numba is ideal for:

Numerical loops
Heavy mathematical operations
NumPy array manipulations

Benefits of Using Numba

Up to 100x faster execution in numeric computations
Minimal code changes — just add a decorator
Compatible with NumPy and math libraries
No need to write C/C++ extensions

Installing Numba

You can install Numba via pip:

pip install numba

Or with conda (recommended for scientific computing):

conda install numba

Basic Usage Example

Let’s compare a plain Python function with its Numba-accelerated version.

Normal Python:

def slow_function(n):
    total = 0
    for i in range(n):
        total += i ** 2
    return total

Accelerated with Numba:

from numba import jit

@jit
def fast_function(n):
    total = 0
    for i in range(n):
        total += i ** 2
    return total

The only change is the @jit decorator from Numba — and the performance difference can be massive!

Types of Numba Decorators

1. `@jit`

Automatically chooses the best mode (nopython or object mode).

@jit
def your_function(...):
    ...

2. `@njit` (Recommended)

Forces nopython mode — the fastest mode where Python objects are not allowed.

from numba import njit

@njit
def your_function(...):
    ...

3. `@vectorize`

Turns a function into a universal function (ufunc) that operates element-wise on NumPy arrays.

from numba import vectorize

@vectorize
def multiply(a, b):
    return a * b

Benchmarking with `timeit`

You can measure performance differences easily:

import timeit

print(timeit.timeit("slow_function(1000000)", globals=globals(), number=1))
print(timeit.timeit("fast_function(1000000)", globals=globals(), number=1))

Numba Gotchas and Tips

Numba works best with NumPy arrays and primitive types (ints, floats).
Avoid using Python objects, dictionaries, or lists inside @njit functions.
Doesn’t work well with dynamic typing or object-oriented features.
Use NumPy operations instead of Python loops when possible for best performance.

Example: Accelerating Matrix Multiplication

import numpy as np
from numba import njit

@njit
def matmul(A, B):
    result = np.zeros((A.shape[0], B.shape[1]))
    for i in range(A.shape[0]):
        for j in range(B.shape[1]):
            for k in range(A.shape[1]):
                result[i, j] += A[i, k] * B[k, j]
    return result

A = np.random.rand(500, 500)
B = np.random.rand(500, 500)

# Run the accelerated matrix multiplication
C = matmul(A, B)

This version is often orders of magnitude faster than a pure Python implementation.

Summary

Feature	Benefit
`@jit`, `@njit`	Speed up numerical Python code
Easy to apply	Just add a decorator
Supports NumPy	Ideal for array-heavy tasks
Great for loops	Dramatic speed-up for nested loops

Final Thoughts

Numba is a must-have tool for any Python developer working with numerical data, simulations, or scientific computing. With minimal code changes, you can unlock huge performance gains — making your Python code not just easy to write, but fast to run.

Fun Programming

MENU