Python 这是一份急切的汇编吗？模式是什么？

我在numba的网站上查看了急切的编译，但不知道如何指定类型：

他们使用的示例如下：

from numba import jit, int32

@jit(int32(int32, int32))
def f(x, y):
    # A somewhat trivial example
    return x + y

# source: http://numba.pydata.org/numba-doc/latest/user/jit.html#eager-compilation

如您所见，它获取2个变量作为输入，并返回一个变量。它们都应该是int32

理解decorator的一种方法是

@jit（int32（int32，int32））

可以理解为：

@jit

（

返回值的类型）（
x的类型，
b的类型）

如果这是正确的（对吗？），那么如何为多个输入和输出指定它

像这样：

@nb.jit
def filter3(a,b):
    return a > b 

@nb.jit
def func3(list_of_arrays_A, list_of_arrays_B, list_of_arrays_C, list_of_arrays_D, 2d_numpy_array_of_objects):

    for i in range(len(list_of_arrays_A)): 

        for j in range(list_of_arrays_A[i].size):
            
            if filter3(list_of_arrays_A[i][j],list_of_arrays_B[i][j]):
                2d_numpy_array_of_objects[i][j] = 1

            elif filter3(list_of_arrays_B[i][j],list_of_arrays_A[i][j]):
                2d_numpy_array_of_objects[i][j] = 0

            elif filter3(list_of_arrays_C[i][j],list_of_arrays_D[i][j]): 
                2d_numpy_array_of_objects[i][j] = 0
            else:                       
                2d_numpy_array_of_objects[i][j] = 1 
'''

My intention: Since i need to speed up a function which is only called once, (but takes forever if **not** done with numba), I need to speed up its numba-compilation 

总是可以使用干涉变量的类型。e、 g

import numpy as np
import numba as nb
N=10000
simple_list= [np.zeros(1) for x in range(N)]
nb.typeof(simple_list)
# reflected list(array(float64, 1d, C))

或：

因此，您可以提供以下签名，以便提前编译：

@nb.jit([nb.void(nb.typeof(typed_list)),
         nb.void(nb.typeof(simple_list))])
def fun(lst):
    pass

值得注意的细节：


我提前编译了两个不同版本的函数：一个用于numba的TypedList（
nb.void（nb.typeof（typed\u list）
），另一个用于python的list（
nb.void（nb.typeof（simple\u list））
）
我不使用签名字符串，而是使用签名本身（例如所述），因为如果我理解正确，
TypedList
或反射列表不存在签名字符串（更多信息如下）
由于函数
fun
不返回任何内容，因此函数的返回类型为
void
，因此签名中的
nb.void（…）

然而，有趣的是，
simple\u list
-版本的开销有多大：

%timeit fun(simple_list)  # 185 ms ± 4.23 ms 
%timeit fun(typed_list)   # 1.18 µs ± 69.3 ns

i、 e.关于
1e5
的系数！原因也很清楚：为了检查传递的列表是否真正属于
反射列表（数组（float64，1d，C））类型
numba必须查看列表中的每个元素。另一方面，对于
TypedList
来说，它要简单得多：列表中不能有多个类型-不需要迭代整个列表

因此，人们应该更倾向于创建和使用
TypedList
s，而不仅仅是放弃一个


可能无法为
反射列表
或
类型列表
提供字符串，因为现在用于解析签名：

def _parse_signature_string(signature_str):
    # Just eval signature_str using the types submodules as globals
    return eval(signature_str, {}, types.__dict__)

因为
nb.types.\uuu dict\uuu
没有
TypedList
或
反射列表
，我们无法通过字符串传递它们


一旦编译了函数（提前或及时），就可以在相应的文件中看到签名，例如通过：

[x.signature for x in fun.overloads.values()]
# [(ListType[array(float64, 1d, C)],) -> none,
#  (reflected list(array(float64, 2d, C)),) -> none]

这可以用来计算函数的正确返回类型（这里
none
意味着
void
）。
急切的编译并不是更快的编译。你只是在更早地完成它，而不是更快。我不理解decorator
@nb.jit（[nb.void（nb.typeof（typed_list）），nb.void（nb.typeof（simple_list））]）def fun（lst）：pass
为什么它是元组中的一个列表，为什么是nb.void？这似乎是我对模式的最初想法
@jit（type_of_returned_value（type_of_x，type_of_b））
是wrong@La-我提前为两个不同的签名（即列表）编译函数。试图通过编辑更好地解释。我的理解如下：1。）使用numba list（speed inrruse，否则弃用）2.
@nb.jit（[nb.void（nb.typeof（typed_list）），nb.void（nb.typeof（simple_list）））
实际上就像
@jit（type_of_返回值（type_of_x，type_of_b））
其中
np.void
是函数的类型，
nb.typeof（simple_list）
是参数的类型。但是您没有指定任何类型的输出，因为它是一个
nb.void（）
。3.）此外，您正在为函数传递两种可能的编译格式（对吗？），因此您将它们都放在
[]
中。是否只有
@jit（…（…）
否则？4.）为什么正确：
@jit（“void（int32，float32）”）def foo（x，y）：返回x+y
？这是一个空白，但它返回的东西。。。
[x.signature for x in fun.overloads.values()]
# [(ListType[array(float64, 1d, C)],) -> none,
#  (reflected list(array(float64, 2d, C)),) -> none]