提升Python运算效率1 - numba-jit

numba使用LLVM编译器架构将纯Python代码生成优化过的机器码，

将面向数组和使用大量数学的python代码优化到与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编译的函数可以调用其他编译的函数。这些函数调用甚至可以在本地代码中被内联，这取决于优化器的启发式方法。比如说。

# 例子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解释器，变成机器码来运行，所以速度超快。

@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那么就默认是这个

def foo():
	A#非数学计算类。
	for i in range(1000):
		B#数学计算类。
	C#非数学计算类。

这个模式将自动识别那个循环，然后优化，脱离python解释器，运行。而对于A,C这两个东西无法优化，需要切换回到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)