JIT-compile a Python function using Numba in nopython mode.

Indicates that the decorated function should be compiled for high‑performance execution.

When optimizing numerical loops, array operations, or any performance‑critical Python function that can be compiled in nopython mode.

Scientific computing, numerical simulations, data‑processing loops, NumPy‑based algorithms, any Python code where speed matters and Numba can compile the function.

numba.jit(nopython=True)(<function>)

Decorator call: numba.jit with keyword argument nopython=True, followed by an immediate call with the target function.

• NumPy arrays
• loops
• @vectorize
• @guvectorize

• Use @njit (equivalent to @jit(nopython=True))
• use @vectorize for element‑wise array operations
• use @guvectorize for generalized ufuncs
• use @stencil for stencil computations
• each trade‑off between flexibility and performance.

Forgetting nopython=True → falls back to object mode, often slower; using unsupported Python features (e.g., arbitrary class instances, reflection) → compile errors; expecting object‑mode behavior like dynamic attribute access → runtime errors; forgetting to return a value when the function should return an array → None returned; passing unsupported NumPy dtypes → fallback or compilation failure.

@jit (default object mode) – allows full Python semantics but slower; @vectorize – applies function element‑wise to NumPy arrays with automatic looping; @guvectorize – generalizes ufuncs with flexible input/output dimensions; @stencil – optimized for stencil patterns; @cfunc – creates a callable C‑callback.

Coming from pure Python: may expect object‑mode behavior like dynamic typing or attribute access; Numba’s nopython mode restricts to supported NumPy/Numba types → compile errors or fallback to object mode. Coming from C/C++: may expect manual memory management or pointers; Numba manages memory automatically and restricts direct pointer access.

• numba.jit
• numba.njit
• numba.vectorize
• numba.guvectorize
• numba.stencil

Do not use when the function relies on unsupported Python features or needs object‑mode semantics; performance includes a one‑time compilation overhead but subsequent calls run at near‑C speed; be aware that certain NumPy functions or array shapes can trigger fallback to object mode, reducing speed gains.

Enables near‑C execution speed for numerical Python code, allowing performance‑critical sections to stay in Python while achieving significant speedups.

Think of a race car engine tucked inside a Python function: you keep the familiar Python syntax but get the raw speed of compiled code.

Using cache=True saves the compiled binary to disk, reducing start‑up time on subsequent runs.

Learn @vectorize or @guvectorize for array‑wise operations, or explore @stencil for stencil‑based computations.