Numba strives to support as much of the Python language as possible, but
some language features are not available inside Numba-compiled functions. The following Python language features are not currently supported:

Numba supports function calls using positional and named arguments, as well
as arguments with default values and *args (note the argument for
*args can only be a tuple, not a list). Explicit **kwargs are
not supported.

Most recursive call patterns are supported. The only restriction is that the
recursive callee must have a control-flow path that returns without recursing.
Numba is able to type-infer recursive functions without specifying the function
type signature (which is required in numba 0.28 and earlier).
Recursive calls can even call into a different overload of the function.

Creating and returning lists from JIT-compiled functions is supported,
as well as all methods and operations. Lists must be strictly homogenous:
Numba will reject any list containing objects of different types, even if
the types are compatible (for example, [1,2.5] is rejected as it
contains a int and a float).

Note

When passing a list into a JIT-compiled function, any modifications
made to the list will not be visible to the Python interpreter until
the function returns.

Warning

List sorting currently uses a quicksort algorithm, which has different
performance characterics than the algorithm used by Python.

Numba supports top-level functions from the random module, but does
not allow you to create individual Random instances. A Mersenne-Twister
generator is used, with a dedicated internal state. It is initialized at
startup with entropy drawn from the operating system.

Also, under Unix, if creating a child process using os.fork() or the
multiprocessing module, the child’s random generator will inherit
the parent’s state and will therefore produce the same sequence of
numbers (except when using the “forkserver” start method under Python 3.4
and later).

Similarly to ctypes, Numba is able to call into cffi-declared external
functions, using the following C types and any derived pointer types:

char

short

int

long

longlong

unsignedchar

unsignedshort

unsignedint

unsignedlong

unsignedlonglong

int8_t

uint8_t

int16_t

uint16_t

int32_t

uint32_t

int64_t

uint64_t

float

double

ssize_t

size_t

void

The from_buffer() method of cffi.FFI and CompiledFFI objects is
supported for passing Numpy arrays and other buffer-like objects. Only
contiguous arguments are accepted. The argument to from_buffer()
is converted to a raw pointer of the appropriate C type (for example a
double* for a float64 array).

Additional type mappings for the conversion from a buffer to the appropriate C
type may be registered with Numba. This may include struct types, though it is
only permitted to call functions that accept pointers to structs - passing a
struct by value is unsupported. For registering a mapping, use: