Python：如何减少运行时间？

我有一个如何减少运行时间的问题。
我编写的代码是Python
它将一个庞大的数据集作为输入，对其进行处理，计算并将输出写入数组<大多数计算可能非常简单，例如求和。在输入文件中，大约有1亿行和3列。我面临的问题是运行时间太长。如何减少运行时间

这是我写的代码
我需要将我计算的所有新值（从GenePair到RM_pval和header）写入新文件。事先非常感谢你

fi = open ('1.txt')
fo = open ('2.txt','w')

import math
def log(x):
    return math.log(x)

from math import sqrt

import sys
sys.path.append('/tools/lib/python2.7/site-packages')
import numpy
import scipy
import numpy as np
from scipy.stats.distributions import norm

for line in fi.xreadlines():
    tmp = line.split('\t')

    GenePair = tmp[0].strip()

    PCC_A = float(tmp[1].strip())
    PCC_B = float(tmp[2].strip())

    ZVAL_A = 0.5 * log((1+PCC_A)/(1-PCC_A))
    ZVAL_B = 0.5 * log((1+PCC_B)/(1-PCC_B))

    ABS_ZVAL_A = abs(ZVAL_A)
    ABS_ZVAL_B = abs(ZVAL_B)

    Var_A = float(1) / float(21-3) #SAMPLESIZE - 3
    Var_B = float(1) / float(18-3) #SAMPLESIZE - 3

    WT_A = 1/Var_A #float
    WT_B = 1/Var_B #float

    ZVAL_A_X_WT_A = ZVAL_A * WT_A #float
    ZVAL_B_X_WT_B = ZVAL_B * WT_B #float

    SumofWT = (WT_A + WT_B) #float
    SumofZVAL_X_WT = (ZVAL_A_X_WT_A + ZVAL_B_X_WT_B) #float

    #FIXED MODEL
    meanES = SumofZVAL_X_WT / SumofWT #float
    Var = float(1) / SumofWT #float
    SE = math.sqrt(float(Var)) #float
    LL = meanES - (1.96 * SE) #float
    UL = meanES - (1.96 * SE) #float
    z_score = meanES / SE #float
    p_val = scipy.stats.norm.sf(z_score)

    #CAL
    ES_POWER_X_WT_A = pow(ZVAL_A,2) * WT_A #float
    ES_POWER_X_WT_B = pow(ZVAL_B,2) * WT_B #float
    WT_POWER_A = pow(WT_A,2)
    WT_POWER_B = pow(WT_B,2)
    SumofES_POWER_X_WT = ES_POWER_X_WT_A + ES_POWER_X_WT_B
    SumofWT_POWER = WT_POWER_A + WT_POWER_B

    #COMPUTE TAU
    tmp_A = ZVAL_A - meanES
    tmp_B = ZVAL_B - meanES
    temp = pow(SumofZVAL_X_WT,2)

    Q = SumofES_POWER_X_WT - (temp /(SumofWT))      
    if PCC_A !=0 or PCC_B !=0:
        df = 0
    else:
        df = 1

    c = SumofWT - ((pow(SumofWT,2))/SumofWT)
    if c == 0:
        tau_square = 0
    else:
        tau_square = (Q - df) / c

    #calculation
    Var_total_A = Var_A + tau_square
    Var_total_B = Var_B + tau_square

    WT_total_A = float(1) / Var_total_A
    WT_total_B = float(1) / Var_total_B

    ZVAL_X_WT_total_A = ZVAL_A * WT_total_A
    ZVAL_X_WT_total_B = ZVAL_B * WT_total_B

    Sumoftotal_WT = WT_total_A + WT_total_B
    Sumoftotal_ZVAL_X_WT= ZVAL_X_WT_total_A + ZVAL_X_WT_total_B


    #RANDOM MODEL
    RM_meanES = Sumoftotal_ZVAL_X_WT / Sumoftotal_WT
    RM_Var = float(1) / Sumoftotal_WT
    RM_SE = math.sqrt(float(RM_Var))
    RM_LL = RM_meanES - (1.96 * RM_SE)
    RM_UL = RM_meanES + (1.96 * RM_SE)
    RM_z_score = RM_meanES / RM_Var
    RM_p_val = scipy.stats.norm.sf(RM_z_score)

---

当然要做探查器，但是。。。 我认为唯一的主要加速将发生由于并行性。如果您要运行这样的cpu限制问题，那么利用多核是至关重要的。尝试将每一行放入不同的（线程/进程）。这当然会引发更多的问题，例如，数据是否需要与输入文件的顺序相同？如果是这样的话，只需枚举它，并在big_hairy_func上粘贴第二个变量，它将用于哪一行

下面是一些开始使用的样板代码

注:

xreadlines已被弃用，即使它处理大型文件。

对于文件中的行：

将其替换

fi = open('1.txt')
fo = open('2.txt','w')

import math
def log(x):
    return math.log(x)

from math import sqrt

import multiprocessing as mp
import sys
sys.path.append('/tools/lib/python2.7/site-packages')
import scipy
import numpy as np
from scipy.stats.distributions import norm

def big_hairy_func(linefromfile):
    <majority of your post here>
    return <whatever data you were going to write to 'fo'>

if __name__ == '__main__':
    pool = mp.Pool(4) #rule of thumb.  Replace '4' with the number of cores on your system
    result = pool.map(big_hairy_func, (input for input in fi.readlines()))
    <write the result to fo that you haven't posted>

fi=open（'1.txt'）
fo=open（'2.txt'，'w'）
输入数学
def日志（x）：
返回math.log（x）
从数学导入sqrt
将多处理作为mp导入
导入系统
sys.path.append（“/tools/lib/python2.7/site packages”）
进口西皮
将numpy作为np导入
从scipy.stats.distributions导入norm
def big_hairy_func（linefromfile）：
返回
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
池=mp.池（4）#经验法则。将“4”替换为系统上的内核数
结果=pool.map（big_hairy_func，（在fi.readlines（）中输入）
1.使用探查器查找瓶颈。2.搜索特定代码段的解决方案。3.如果找不到，请在这里提问。此外，这个问题似乎适合您的瓶颈，很明显，在每次读取和处理1亿行时。。。一次读一百万行（如果太多的话，读十万行）到一个numpyarrya中，并矢量化你的代码。你有很多事情要做，但似乎没有什么事情是不可传播的：如果你被困在某个地方，再问一个更具体的问题。你能分享
1.txt
文件的一部分吗？矢量化肯定先于多处理。我肯定会按照@Jaimie的建议+146（从开始）。（-1）一般来说是好建议，但在这种情况下是坏建议
numpy
作为依赖项，代码似乎可以矢量化；因此，至少几倍（可能几百倍）的加速几乎是免费的。从多处理开始似乎有些过分。虽然numpy是导入的，但它并没有被使用。是的，这是第一个使用它的优化。如果矢量化代码仍然不够快，那么就存在多处理。所以，如果你的建议被矢量化了，我会对它+1（或+更多）。