site Logo
Home
Portfolio
Python
JavaScript
AI
Search
Write Faster Python with Numba's @jit
python
numba
jit
optimization
performance
numpy

Write Faster Python with Numba's @jit

Learn how to speed up your Python code, especially numerical computations, using Numba's JIT compiler. We'll cover the ...

March 22, 2025
3 minutes

Supercharge Your Python: A Guide to Numba's JIT

Python is beloved for its readability and versatility. However, when it comes to raw computational speed, especially for numerical tasks, it can sometimes lag behind compiled languages like C++ or Fortran. This is where Numba steps in! ✨

Introduction: The Need for Speed

Several factors contribute to Python's potential slowness in numerical computations:

  • Interpreted Nature: Python code is executed line by line, adding overhead compared to pre-compiled languages.
  • Dynamic Typing: Variable types are checked at runtime, requiring extra processing.
  • Global Interpreter Lock (GIL): In CPython (the standard Python implementation), the GIL limits true parallelism in multi-threaded programs.

While these features contribute to Python's flexibility, they can impact performance. This is where Numba offers a powerful solution.

What is Numba?

Numba is an open-source just-in-time (JIT) compiler for Python. It translates a subset of your Python and NumPy code into highly optimized machine code at runtime. This allows your numerical calculations to run significantly faster, often approaching the speeds of compiled languages, without requiring you to rewrite your code in a different language. ✅

The key concept here is "just-in-time." Unlike traditional compilers that translate the entire program before execution, a JIT compiler analyzes and optimizes specific parts of the code as they are needed.

How to Use Numba: The @jit Decorator

The most common way to use Numba is through its decorators. The @jit decorator is the workhorse. You simply place it above the function you want to accelerate:

Explanation:

  • @jit(nopython=True): This is the crucial part. nopython=True forces Numba to compile the function entirely into machine code, without falling back to the Python interpreter. This mode provides the highest speedup. If Numba can't compile in nopython mode (because it encounters unsupported code), it will raise an error.
  • First Call is Slower: The first time you call a Numba-decorated function, there's a compilation step. Subsequent calls within the same runtime will use the cached, compiled code and be much faster.
  • Caching You can chache the compiled function using cache=True to store it on a file .

@njit: A Convenient Alias

Because nopython=True is so frequently used, Numba provides a shorthand: @njit. These two lines are equivalent:

When to Use Numba (and When Not To)

Numba excels in specific scenarios:

  • Numerical Code: Functions involving loops, mathematical operations, and array manipulations (especially with NumPy).
  • NumPy-Heavy Code: Numba is designed to work seamlessly with NumPy arrays and functions.
  • Loops: Numba can optimize loops significantly.

However, Numba has limitations:

  • I/O-Bound Code: If your code spends most of its time waiting for input/output (e.g., reading files, network requests), Numba won't provide much benefit.
  • Non-Numerical Code: String manipulations, complex data structures (like standard Python lists and dictionaries), and extensive Python object interactions are not well-suited for Numba. Numba works best with numerical data types and NumPy arrays.
  • Small Functions: For very tiny functions, the compilation overhead might outweigh any speed gains.
  • Pandas Limitations: Numba doesn't directly support Pandas DataFrames. You'll need to work with the underlying NumPy arrays if you want to use Numba with Pandas data.

Beyond @jit: Parallelism and More

Numba offers more than just basic JIT compilation:

  • @jit(parallel=True): Numba can automatically parallelize your code across multiple CPU cores. You can often use prange (Numba's parallel range) instead of range in loops to enable this.

  • @vectorize and @guvectorize: These decorators allow you to create NumPy universal functions (ufuncs) and generalized ufuncs, respectively, which can operate efficiently on arrays of different shapes.

  • GPU Acceleration: Numba has support for CUDA-enabled GPUs, allowing for even greater performance gains in highly parallelizable computations.

Example: Mandelbrot Set

Let's see a classic example – generating the Mandelbrot set:

Key improvements and explanations in this example:

  • Timing Comparison: The code now includes timing for both the Numba-accelerated version and the pure Python version. This allows you to directly compare the performance difference. I use mandel.py_func to call the original python function.
  • nopython=True: We are using @jit(nopython=True) to get the best performance.
  • Clearer Comments: Added comments to explain the purpose of each section.

Run this code, and you'll likely see a significant speedup with the Numba version. The exact difference will depend on your hardware and the size of the fractal you generate.

Conclusion

Numba's @jit decorator provides a remarkably simple way to accelerate numerically intensive Python code. By understanding its strengths and limitations, you can selectively apply it to the parts of your code that will benefit the most, achieving substantial performance improvements without sacrificing Python's ease of use. It's a valuable tool for anyone working with numerical computations in Python. 🔥

Share this Article
Comments are disabled

Table Of Content

Supercharge Your Python: A Guide to Numba's JIT
Introduction: The Need for Speed
What is Numba?
Example: Mandelbrot Set
Conclusion

Related Posts

Mastering Python Generators
May 15, 2023python

Mastering Python Generators

Learn how to use generators in Python for efficient iteration and memory management.

Article
Pydantic 101: Data Validation and Parsing Made Easy
March 22, 2025python

Pydantic 101: Data Validation and Parsing Made Easy

Learn the basics of Pydantic, a powerful Python library for data validation, parsing, and settings management. Covers models, types, validation, and more.

Article
Understanding Python's Context Managers
June 1, 2023python

Understanding Python's Context Managers

Learn how to use context managers in Python for efficient resource management.

Article
Building Robust APIs with FastAPI
October 15, 2023python

Building Robust APIs with FastAPI

Learn about FastAPI, a modern, fast, and high-performance web framework for building APIs with Python.

Article
Data Validation with Pydantic in Python
September 10, 2023python

Data Validation with Pydantic in Python

Learn how to use Pydantic, a powerful data validation library for Python, to ensure data integrity in your applications.

Article
Debugging with PySnooper in Python
August 20, 2023python

Debugging with PySnooper in Python

Learn how to use PySnooper, a powerful debugging tool for Python, to inspect your code's execution.

Article

Latest Posts

The Future of Web Development: Build Full-Stack Apps with Bolt.new (No Coding Required!)
November 19, 2024Web-Dev

The Future of Web Development: Build Full-Stack Apps with Bolt.new (No Coding Required!)

Bolt.new revolutionizes web development by letting anyone create full-stack web apps with AI, even without coding experience!

Article
Top 10 VS Code Extensions to Supercharge Your Workflow
March 23, 2024VS Code

Top 10 VS Code Extensions to Supercharge Your Workflow

Boost your productivity and streamline your development with these essential VS Code extensions.

Article
ModernBERT: A Leap Forward in Long-Context Language Models
December 19, 2024NLP

ModernBERT: A Leap Forward in Long-Context Language Models

An overview of ModernBERT, a new BERT-style model with long-context capabilities and superior performance across various tasks.

Article
site Logo
  • About
  • Privacy Policy
  • Contact
© 2026 Seyf ELislam. All Rights Reserved.
Developed byseyf1elislam|TechTuneDz Team
1
from numba import jit

2
import numpy as np

3


4
@jit(nopython=True)  #  <-- The magic happens here!

5
def sum_of_squares(n):

6
    total = 0

7
    for i in range(n):

8
        total += i * i

9
    return total

10


11
# Example Usage

12
result = sum_of_squares(10_000_000)

13
print(result)
sum_of_squares.py
1
from numba import jit

2
import numpy as np

3


4
@jit(nopython=True)  #  <-- The magic happens here!

5
def sum_of_squares(n):

6
    total = 0

7
    for i in range(n):

8
        total += i * i

9
    return total

10


11
# Example Usage

12
result = sum_of_squares(10_000_000)

13
print(result)

14
1
@jit(nopython=True)

2
def my_function(...):

3
    ...

4


5
@njit

6
def my_function(...):

7
    ...
1
from numba import jit, prange

2
import numpy as np

3


4
@jit(nopython=True, parallel=True)

5
def parallel_sum(A):

6
    sum = 0

7
    for i in prange(A.shape[0]): # Use prange for parallel loops

8
        sum += A[i]

9
    return sum

10


11
data = np.arange(1000000)

12
result = parallel_sum(data)

13
print(result)
1
from numba import jit

2
import numpy as np

3
import time # Import the time module

4


5


6
@jit(nopython=True)

7
def mandel(x, y, max_iters):

8
    i = 0

9
    c = complex(x, y)

10
    z = 0.0j

11
    for i in range(max_iters):

12
        z = z*z + c

13
        if (z.real*z.real + z.imag*z.imag) >= 4:

14
            return i

15
    return max_iters

16


17
@jit(nopython=True)

18
def create_fractal(min_x, max_x, min_y, max_y, image, iters):

19
    height = image.shape[0]

20
    width = image.shape[1]

21
    pixel_size_x = (max_x - min_x) / width

22
    pixel_size_y = (max_y - min_y) / height

23


24
    for x in range(width):

25
        real = min_x + x * pixel_size_x

26
        for y in range(height):

27
            imag = min_y + y * pixel_size_y

28
            color = mandel(real, imag, iters)

29
            image[y, x] = color

30


31
# --- Non-Numba Version ---

32
def create_fractal_python(min_x, max_x, min_y, max_y, image, iters):

33
    height = image.shape[0]

34
    width = image.shape[1]

35
    pixel_size_x = (max_x - min_x) / width

36
    pixel_size_y = (max_y - min_y) / height

37


38
    for x in range(width):

39
        real = min_x + x * pixel_size_x

40
        for y in range(height):

41
            imag = min_y + y * pixel_size_y

42
            #  Call mandel without @jit

43
            color = mandel.py_func(real, imag, iters)  # Use .py_func

44
            image[y, x] = color

45


46


47
image = np.zeros((500, 750), dtype=np.uint8)

48


49
# --- Time the Numba version ---

50
start_time = time.time()

51
create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)

52
end_time = time.time()

53
print(f"Numba Time: {end_time - start_time:.4f} seconds")

54


55
# --- Time the pure Python version ---

56
start_time = time.time()

57
create_fractal_python(-2.0, 1.0, -1.0, 1.0, image.copy(), 20) # Use a copy to avoid modifying the original

58
end_time = time.time()

59
print(f"Pure Python Time: {end_time - start_time:.4f} seconds")

60


61


62


63
# --- Uncomment to display the image (requires matplotlib) ---

64
# import matplotlib.pyplot as plt

65
# plt.imshow(image)

66
# plt.show()

67