The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Numba can speed up numerical Python when a slow, frequently run function uses operations and types its compiler supports. Start by profiling with representative data, then try nopython compilation, test parallel loops where the work allows it, and use caching when repeated program starts make compilation time noticeable. None of these techniques guarantees a speedup for every workload.
Before optimizing, measure the code that matters
Profile the program with realistic inputs to find the hot path before changing it. Numba’s Performance Tips guide recommends profiling real data to guide tuning and cautions that its examples demonstrate features rather than provide canonical performance advice.
As an Amazon Associate I earn from qualifying purchases.
For a useful comparison, record the Numba version, machine, input size, and threading configuration. Measure compilation and execution separately: a cold first call and warmed subsequent calls answer different questions. Check correctness as well as elapsed time.
1. Compile numeric hot paths in nopython mode
Use @njit to request Numba’s nopython mode explicitly for a function that operates on supported types:
#1 Best Overall
from numba import njit
@njit
def sum_squares(values):
total = 0.0
for value in values:
total += value * value
return totalNopython mode generates native machine code without relying on Python objects for the compiled function’s work. It is best suited to numerical kernels; it does not make arbitrary Python code compilable. Unsupported operations or types can cause compilation to fail, so keep orchestration and unsupported work in ordinary Python when appropriate.
Since Numba 0.59.0, @jit defaults to nopython mode as well. @njit remains a clear signal of intent. See the JIT documentation for decorator behavior and supported use.
2. Try simple compiled loops, then test parallelism
Do not assume a vector expression is automatically faster
Numba can compile ordinary loops, and its performance guide shows a compiled loop and a compiled NumPy-vector-expression version performing similarly in one teaching example. That does not establish a general ranking: performance depends on the actual function, data, and execution conditions. Choose the clearest correct implementation, compile it, and measure it on representative inputs.
Free tools Windows power users keep installed
One-click scans. No signup required.
Use parallel loops only when the work fits
For independent iterations, try Numba’s parallel facilities. A simple example is a loop that writes each output element from the corresponding input:
from numba import njit, prange
@njit(parallel=True)
def scale(values, factor):
result = values.copy()
for i in prange(values.size):
result[i] = values[i] * factor
return resultparallel=True enables parallelization of supported constructs; prange marks a loop for parallel execution. The loop must be suitable for parallel work: iterations that depend on one another are not interchangeable with independent iterations. Parallel overhead can outweigh the benefit on small workloads, so compare serial and parallel versions across realistic input sizes and verify their results. The parallel documentation describes the supported features.
Treat published timings as an example, not a forecast
Numba’s performance guide reports timings for a contrived trigonometric-identity example: an uncompiled NumPy expression took 0.581 seconds, a compiled NumPy expression 0.659 seconds, an uncompiled loop 25.2 seconds, and a compiled loop 0.670 seconds. These are the project’s illustrative results for an Intel i7-4790 with four hardware threads and an input based on np.arange(1.e7); they are not a prediction for other code or machines.
3. Cache compiled code when repeated starts cost time
Add cache=True when the same supported function is compiled across repeated program runs and startup time matters:
Recommended Free Tools
from numba import njit
@njit(cache=True)
def sum_squares(values):
total = 0.0
for value in values:
total += value * value
return totalNumba can persist compiled results so later invocations may avoid some compilation work. Cache support depends on the function and filesystem: cache files normally go in the source file’s __pycache__ directory, with a user-wide fallback if that location is not writable, and some functions cannot be cached. Consult the caching documentation for details. Compare cold-start time separately from warmed execution time; caching reduces repeated compilation overhead, not the kernel’s inherent runtime.
Optional trade-off: fastmath changes floating-point rules
fastmath=True allows transformations that do not preserve all strict floating-point assumptions. It may be useful when the application tolerates the resulting numerical behavior, but it is not a free speed switch. Validate outputs against the accuracy requirements of the task before enabling it. Numba documents this option in its performance guide.
Quick Recap
Check correctness and benchmark results
- Profile with representative data and optimize the function that actually limits performance.
- Compare cold first-call time with warmed execution time, especially when evaluating caching.
- For parallel code, test realistic input sizes and confirm iterations can safely run independently.
- Record the machine, Numba version, input size, and threading configuration so timings can be interpreted.
- Validate numerical output after changing compilation options. Numba’s JIT reference notes that bounds checking is off by default; out-of-range indexing can produce garbage or a segmentation fault. Enabling bounds checking raises
IndexError.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
