Python 如何使用Numba加速此功能？

我试图用Numba优化这个函数，但我无法做到。我认为这没有代码中可以加速的部分。如果有人能帮我优化这个版本，我的程序会变得非常快。请告知是否需要任何数据集或其他信息。当我对此应用direct@jit时，它不起作用

def c_a(x, y, z, counter, p_l):
    # start = time.time()
    if counter == 1:
        l = x
        m = y
        n = z


        path = "c_r.pdb"
        global r_a_t


        p = Bio.PDB.PDBParser() 
        structure = p.get_structure('mSN1', path)
        c_r = [a.get_coord() for a in structure.get_atoms()]   
        lengthnew = len(c_r)


        m_d = np.array([-45, -45, -45])


        a_s_r = np.zeros((128, 128, 128), np.complex)
        for i in range(0, lengthnew):
            x = int(math.floor((c_r[i][0] - m_d[0]) / 1.2))
            y = int(math.floor((c_r[i][1] - m_d[1]) / 1.2))
            z = int(math.floor((c_r[i][2] - m_d[2]) / 1.2))
            with open("Ei.txt", 'r') as ei_values:
                for row in ei_values:
                    s_v = row.split()
                    if s_v[0] == r_a_t[i] :
                        a_s_r[x, y, z] = np.complex(s_v[1])


        n_n = lambda x, y, z : [(x2, y2, z2) for x2 in range(x - 5, x + 6)
                                   for y2 in range(y - 5, y + 6)
                                   for z2 in range(z - 5, z + 6)
                                   if (-1 < x < X and
                                       -1 < y < Y and
                                       -1 < z < Z and
                                       (x != x2 or y != y2 or z != z2) and
                                       (0 <= x2 < X) and
                                       (0 <= y2 < Y) and
                                       (0 <= z2 < Z) and
                                       ((( abs(x - x2)) ** 2 + (abs(y - y2)) ** 2 + (abs(z - z2)) ** 2  ) <= 25))]  
        m = n_n(l, m, n)
        result = 0
        for i in range(0, len(m)):
            a = m[i][0]
            b = m[i][1]
            c = m[i][2]
            result = result + a_s_r[a][b][c]
        return result

    else:
        l = x
        m = y
        n = z
        path = p_l


        global l_a_t


        p = Bio.PDB.PDBParser() 
        structure = p.get_structure('mSN1', path)
        c_l = [a.get_coord() for a in structure.get_atoms()]   
        lengthnew = len(c_l)


        m_d = np.array([-45, -45, -45])


        a_s_l = np.zeros((128, 128, 128), np.complex)
        for i in range(0, lengthnew):
            x = int(math.floor((c_l[i][0] - m_d[0]) / 1.2))
            y = int(math.floor((c_l[i][1] - m_d[1]) / 1.2))
            z = int(math.floor((c_l[i][2] - m_d[2]) / 1.2))
            with open("E.txt", 'r') as e_v:
                for row in e_v:
                    s_v = row.split()
                    if s_v[0] == l_a_t[i] :
                        a_s_l[x, y, z] = np.complex(s_v[1])


        n_n = lambda x, y, z : [(x2, y2, z2) for x2 in range(x - 5, x + 6)
                                       for y2 in range(y - 5, y + 6)
                                       for z2 in range(z - 5, z + 6)
                                       if (-1 < x < X and
                                           -1 < y < Y and
                                           -1 < z < Z and
                                           (x != x2 or y != y2 or z != z2) and
                                           (0 <= x2 < X) and
                                           (0 <= y2 < Y) and
                                           (0 <= z2 < Z) and
                                           (((abs(x - x2)) ** 2 + (abs(y - y2)) ** 2 + (abs(z - z2)) ** 2  ) <= 25))]  
        m = n_n(l, m, n)
        result = 0
        for i in range(0, len(m)):
            a = m[i][0]
            b = m[i][1]
            c = m[i][2]
            result = result + a_s_l[a][b][c]
        # print "c_a : ", time.time() - start    
        return result

def c_a（x，y，z，计数器，p_l）：
#开始=时间。时间（）
如果计数器==1：
l=x
m=y
n=z
path=“c_r.pdb”
全球资源
p=Bio.PDB.PDBParser（）
结构=p.get_结构（'mSN1'，路径）
c_r=[a.获取结构中的坐标（）.get_atoms（）]
长度新=长度（c_r）
m_d=np.数组（[-45，-45，-45]）
a_s_r=np.zero（（128128128），np.complex）
对于范围内的i（0，lengthnew）：
x=int（数学层（（c_r[i][0]-m_d[0]）/1.2））
y=int（数学层（（c_r[i][1]-m_d[1]）/1.2））
z=int（数学层（（c_r[i][2]-m_d[2]）/1.2））
打开（“Ei.txt”，“r”）作为Ei_值：
对于ei_值中的行：
s_v=行分割（）
如果s_v[0]==r_a_t[i]：
a_s_r[x，y，z]=np.复形（s_v[1]）
n_n=λx，y，z:[（x2，y2，z2）表示范围（x-5，x+6）内的x2
适用于范围内的y2（y-5，y+6）
用于范围内的z2（z-5，z+6）
如果（-1（0已解决。

将所有的文件读取步骤带出函数之外，因为它们被执行了很多次。它提供了70倍的提升

只将lambda函数保留在函数中，因为它们依赖于x、y和z。
一个好的起点是查看numba可以优化什么和不能优化什么，可以在文档（和）中找到。然后使用评测（cProfile和line_profiler）运行当前的实现找到瓶颈所在。然后你可以试着将缓慢的部分隔离到Numba jitted函数中。@JoshAdel循环部分需要时间，但我无法正常进行jit。你必须将那个大函数分开。你不能读取
Nopyton
Numba函数中的文件，也不能从biopython或使用lambda函数。你需要隔离那些只对标量和数组进行大量循环的代码。取上面函数的一小段，用numba进行测试。我可以给出建议，但你必须在使用numba进行实验方面做一些工作。@JoshAdel Done。