Let's compare the execution time of the following function. It adds 1 to a variable 1 billion times. 
With Numba:

```python
from numba import jit
import time

@jit(nopython=True, cache=True, fastmath={'fast'})
def numba_test():
	x = 0
	for i in range(1000000000):
		x += 1

start = time.time()
numba_test()
print(time.time() - start)
```
This returned 0.031908512115478516 seconds.

Without Numba:

```python
import time

def test():
	x = 0
	for i in range(1000000000):
		x += 1

start = time.time()
test()
print(time.time() - start)
```
This returns 23.248998165130615 seconds. As we can see this example of using Numba is 728x times faster.  


Numba Module Example

Numba is a Just-In-Time (JIT) compiler that translates python code into machine code at runtime via the LLVM compiler. The performance of Numba-optimized algorithms comes very close to the speeds of native C execution. Numba also has support for parallelization as well as GPU acceleration. 

California State University, San Bernardino

Python code can usually be optimized in few ways:

* Re-factoring code with optimizations that are specific to python.
* Using a Just-In-Time compiler (JIT) such as Numba or Pypy.
* Using an optimizing compiler such as Cython.

Speeding Up Python Code

Numba Module

Cython is an optimizing compiler that allows computationally expensive Python code to be translated into C and compiled for use within a python program. It contains a Python-like syntax as well as static typing. The main performance gain comes from Cython being able to bypass the CPython API (Where python code is interpreted from). 

Cython Module

Pypy is an alternative implementation of Python that uses a Just-In-Time compiler instead of an interpreter. Pypy consumes less memory and and is compatible with many python libraries. On average, Pypy is 4.2x faster than the standard CPython implementation.

Learn Before

Related

Learn After