numba使用LLVM編譯器架構(gòu)將純Python代碼生成優(yōu)化過的機(jī)器碼，

將面向數(shù)組和使用大量數(shù)學(xué)的python代碼優(yōu)化到與c，c++和Fortran類似的性能，而無需改變Python的解釋器。

from numba import jit, int32
import math
# 例子1
@jit(int32(int32, int32))
def f(x, y):
    return x + y
f(1, 3)

4

Numba編譯的函數(shù)可以調(diào)用其他編譯的函數(shù)。這些函數(shù)調(diào)用甚至可以在本地代碼中被內(nèi)聯(lián)，這取決于優(yōu)化器的啟發(fā)式方法。比如說。

# 例子2
@jit
def square(x):
    return x ** 2

@jit
def hypot(x, y):
    return math.sqrt(square(x) + square(y))

hypot(1, 3)

3.1622776601683795

# 例子3

@jit
def go_fast_sum1(size: float) -> int:
    sum = 0
    for i in range(size):
        sum += i
    return sum

@jit
def go_fast_sum2(size):
    sum = 0
    for i in range(size):
        sum += i
    return sum

@jit(int32(int32))
def go_fast_sum3(size):
    sum = 0
    for i in range(size):
        sum += i
    return sum


def pure_python_sum(size):
    sum = 0
    for i in range(size):
        sum += i
    return sum

%timeit go_fast_sum1(1000)

192 ns ± 6.89 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

%timeit go_fast_sum2(1000)

193 ns ± 4.93 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

%timeit go_fast_sum3(1000)

201 ns ± 4.9 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

%timeit pure_python_sum(1000)

47.8 μs ± 5.39 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

上面幾個例子看出來，不同寫法，差別不是很大，都有得到提升。就按你自己舒服方式寫就好

nopython:

這個模式，是被推薦的模式

說白了就是這段代碼的運行將脫離python解釋器，變成機(jī)器碼來運行，所以速度超快。

@jit(nopython=True)
def go_fast_sum4(size):
    sum = 0
    for i in range(size):
        sum += i
    return sum

%timeit go_fast_sum4(1000)

190 ns ± 12.5 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

@jit(nopython=True)
def go_fast_sum5(size: float) -> int:
    sum = 0
    for i in range(size):
        sum += i
    return sum

%timeit go_fast_sum5(1000)

195 ns ± 26 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

object

普通模式，就是在python解釋器里運行的模式。沒有寫nopython=True那么就默認(rèn)是這個

def foo():
	A#非數(shù)學(xué)計算類。
	for i in range(1000):
		B#數(shù)學(xué)計算類。
	C#非數(shù)學(xué)計算類。

這個模式將自動識別那個循環(huán)，然后優(yōu)化，脫離python解釋器，運行。而對于A,C這兩個東西無法優(yōu)化，需要切換回到python解釋器，極其浪費時間，效果差。切換很費時間，這種情況，最好不要用nopython的模式，而使用下面地這種普通模式。

并行模式

@jit(nopython=True, parallel=True)
def go_fast_sum6(size: float) -> int:
    sum = 0
    for i in range(size):
        sum += i
    return sum

%timeit go_fast_sum6(1000)

/home/ubuntu/.local/lib/python3.8/site-packages/numba/core/typed_passes.py:329: NumbaPerformanceWarning: [1m
The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.

To find out why, try turning on parallel diagnostics, see https://numba.readthedocs.io/en/stable/user/parallel.html#diagnostics for help.
[1m
File "../../../../tmp/ipykernel_3446152/3683479791.py", line 1:[0m
[1m<source missing, REPL/exec in use?>[0m
[0m
  warnings.warn(errors.NumbaPerformanceWarning(msg,


196 ns ± 15.5 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)