15

我想提高 Python 脚本的性能，并一直在使用cProfile它来生成性能报告：

python -m cProfile -o chrX.prof ./bgchr.py ...args...

chrX.prof我用 Python打开这个文件pstats并打印出统计数据：

Python 2.7 (r27:82500, Oct  5 2010, 00:24:22) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import pstats
>>> p = pstats.Stats('chrX.prof')
>>> p.sort_stats('name')
>>> p.print_stats()                                                                                                                                                                                                                        
Sun Oct 10 00:37:30 2010    chrX.prof                                                                                                                                                                                                      

         8760583 function calls in 13.780 CPU seconds                                                                                                                                                                                      

   Ordered by: function name                                                                                                                                                                                                               

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)                                                                                                                                                                    
        1    0.000    0.000    0.000    0.000 {_locale.setlocale}                                                                                                                                                                          
        1    1.128    1.128    1.128    1.128 {bz2.decompress}                                                                                                                                                                             
        1    0.002    0.002   13.780   13.780 {execfile}                                                                                                                                                                                   
  1750678    0.300    0.000    0.300    0.000 {len}                                                                                                                                                                                        
       48    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}                                                                                                                                                          
        1    0.000    0.000    0.000    0.000 {method 'close' of 'file' objects}                                                                                                                                                           
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}                                                                                                                                             
  1750676    0.496    0.000    0.496    0.000 {method 'join' of 'str' objects}                                                                                                                                                             
        1    0.007    0.007    0.007    0.007 {method 'read' of 'file' objects}                                                                                                                                                            
        1    0.000    0.000    0.000    0.000 {method 'readlines' of 'file' objects}                                                                                                                                                       
        1    0.034    0.034    0.034    0.034 {method 'rstrip' of 'str' objects}                                                                                                                                                           
       23    0.000    0.000    0.000    0.000 {method 'seek' of 'file' objects}                                                                                                                                                            
  1757785    1.230    0.000    1.230    0.000 {method 'split' of 'str' objects}                                                                                                                                                            
        1    0.000    0.000    0.000    0.000 {method 'startswith' of 'str' objects}                                                                                                                                                       
  1750676    0.872    0.000    0.872    0.000 {method 'write' of 'file' objects}                                                                                                                                                           
        1    0.007    0.007   13.778   13.778 ./bgchr:3(<module>)                                                                                                                                                                          
        1    0.000    0.000   13.780   13.780 <string>:1(<module>)                                                                                                                                                                         
        1    0.001    0.001    0.001    0.001 {open}                                                                                                                                                                                       
        1    0.000    0.000    0.000    0.000 {sys.exit}                                                                                                                                                                                   
        1    0.000    0.000    0.000    0.000 ./bgchr:36(checkCommandLineInputs)                                                                                                                                                           
        1    0.000    0.000    0.000    0.000 ./bgchr:27(checkInstallation)                                                                                                                                                                
        1    1.131    1.131   13.701   13.701 ./bgchr:97(extractData)                                                                                                                                                                      
        1    0.003    0.003    0.007    0.007 ./bgchr:55(extractMetadata)                                                                                                                                                                  
        1    0.064    0.064   13.771   13.771 ./bgchr:5(main)                                                                                                                                                                              
  1750677    8.504    0.000   11.196    0.000 ./bgchr:122(parseJarchLine)                                                                                                                                                                  
        1    0.000    0.000    0.000    0.000 ./bgchr:72(parseMetadata)                                                                                                                                                                    
        1    0.000    0.000    0.000    0.000 /home/areynolds/proj/tools/lib/python2.7/locale.py:517(setlocale)

问题：我可以做些什么来join减少它们对该脚本性能的明显影响？splitwrite

如果相关，这里是相关脚本的完整源代码：

#!/usr/bin/env python

import sys, os, time, bz2, locale

def main(*args):
    # Constants
    global metadataRequiredFileSize
    metadataRequiredFileSize = 8192
    requiredVersion = (2,5)

    # Prep
    global whichChromosome
    whichChromosome = "all"
    checkInstallation(requiredVersion)
    checkCommandLineInputs()
    extractMetadata()
    parseMetadata()
    if whichChromosome == "--list":
        listMetadata()
        sys.exit(0)

    # Extract
    extractData()   
    return 0

def checkInstallation(rv):
    currentVersion = sys.version_info
    if currentVersion[0] == rv[0] and currentVersion[1] >= rv[1]:
        pass
    else:
        sys.stderr.write( "\n\t[%s] - Error: Your Python interpreter must be %d.%d or greater (within major version %d)\n" % (sys.argv[0], rv[0], rv[1], rv[0]) )
        sys.exit(-1)
    return

def checkCommandLineInputs():
    cmdName = sys.argv[0]
    argvLength = len(sys.argv[1:])
    if (argvLength == 0) or (argvLength > 2):
        sys.stderr.write( "\n\t[%s] - Usage: %s [<chromosome> | --list] <bjarch-file>\n\n" % (cmdName, cmdName) )
        sys.exit(-1)
    else:   
        global inFile
        global whichChromosome
        if argvLength == 1:
            inFile = sys.argv[1]
        elif argvLength == 2:
            whichChromosome = sys.argv[1]
            inFile = sys.argv[2]
        if inFile == "-" or inFile == "--list":
            sys.stderr.write( "\n\t[%s] - Usage: %s [<chromosome> | --list] <bjarch-file>\n\n" % (cmdName, cmdName) )
            sys.exit(-1)
    return

def extractMetadata():
    global metadataList
    global dataHandle
    metadataList = []
    dataHandle = open(inFile, 'rb')
    try:
        for data in dataHandle.readlines(metadataRequiredFileSize):     
            metadataLine = data
            metadataLines = metadataLine.split('\n')
            for line in metadataLines:      
                if line:
                    metadataList.append(line)
    except IOError:
        sys.stderr.write( "\n\t[%s] - Error: Could not extract metadata from %s\n\n" % (sys.argv[0], inFile) )
        sys.exit(-1)
    return

def parseMetadata():
    global metadataList
    global metadata
    metadata = []
    if not metadataList: # equivalent to "if len(metadataList) > 0"
        sys.stderr.write( "\n\t[%s] - Error: No metadata in %s\n\n" % (sys.argv[0], inFile) )
        sys.exit(-1)
    for entryText in metadataList:
        if entryText: # equivalent to "if len(entryText) > 0"
            entry = entryText.split('\t')
            filename = entry[0]
            chromosome = entry[0].split('.')[0]
            size = entry[1]
            entryDict = { 'chromosome':chromosome, 'filename':filename, 'size':size }
            metadata.append(entryDict)
    return

def listMetadata():
    for index in metadata:
        chromosome = index['chromosome']
        filename = index['filename']
        size = long(index['size'])
        sys.stdout.write( "%s\t%s\t%ld" % (chromosome, filename, size) )
    return

def extractData():
    global dataHandle
    global pLength
    global lastEnd
    locale.setlocale(locale.LC_ALL, 'POSIX')
    dataHandle.seek(metadataRequiredFileSize, 0) # move cursor past metadata
    for index in metadata:
        chromosome = index['chromosome']
        size = long(index['size'])
        pLength = 0L
        lastEnd = ""
        if whichChromosome == "all" or whichChromosome == index['chromosome']:
            dataStream = dataHandle.read(size)
            uncompressedData = bz2.decompress(dataStream)
            lines = uncompressedData.rstrip().split('\n')
            for line in lines:
                parseJarchLine(chromosome, line)
            if whichChromosome == chromosome:
                break
        else:
            dataHandle.seek(size, 1) # move cursor past chromosome chunk

    dataHandle.close()
    return

def parseJarchLine(chromosome, line):
    global pLength
    global lastEnd
    elements = line.split('\t')
    if len(elements) > 1:
        if lastEnd:
            start = long(lastEnd) + long(elements[0])
            lastEnd = long(start + pLength)
            sys.stdout.write("%s\t%ld\t%ld\t%s\n" % (chromosome, start, lastEnd, '\t'.join(elements[1:])))
        else:
            lastEnd = long(elements[0]) + long(pLength)
            sys.stdout.write("%s\t%ld\t%ld\t%s\n" % (chromosome, long(elements[0]), lastEnd, '\t'.join(elements[1:])))
    else:
        if elements[0].startswith('p'):
            pLength = long(elements[0][1:])
        else:
            start = long(long(lastEnd) + long(elements[0]))
            lastEnd = long(start + pLength)
            sys.stdout.write("%s\t%ld\t%ld\n" % (chromosome, start, lastEnd))               
    return

if __name__ == '__main__':
    sys.exit(main(*sys.argv))

编辑

如果我注释掉sys.stdout.write第一个条件中的语句parseJarchLine()，那么我的运行时间会从 10.2 秒变为 4.8 秒：

# with first conditional's "sys.stdout.write" enabled
$ time ./bgchr chrX test.bjarch > /dev/null
real    0m10.186s                                                                                                                                                                                        
user    0m9.917s                                                                                                                                                                                         
sys 0m0.160s  

# after first conditional's "sys.stdout.write" is commented out                                                                                                                                                                                           
$ time ./bgchr chrX test.bjarch > /dev/null
real    0m4.808s                                                                                                                                                                                         
user    0m4.561s                                                                                                                                                                                         
sys 0m0.156s

stdout用 Python写东西真的那么贵吗？

4

3 回答 3

29

ncalls仅在将数字与其他计数（例如文件中的字符/字段/行数）进行比较时才相关，可能会突出异常；tottime这才cumtime是真正重要的。cumtime是函数/方法花费的时间，包括它调用的函数/方法花费的时间；tottime是在函数/方法中花费的时间，不包括在它调用的函数/方法中花费的时间。

我发现对统计数据进行tottime一次又一次的排序很有帮助cumtime，而不是name。

bgchar 绝对是指脚本的执行，并不是无关紧要，因为它占用了 13.5 秒中的 8.9 秒；8.9 秒不包括它调用的函数/方法中的时间！仔细阅读@Lie Ryan 所说的关于将脚本模块化为函数的内容，并实施他的建议。同样@jonesy 所说的。

string之所以提到它，是因为您import string只在一个地方使用它： string.find(elements[0], 'p'). 在输出的另一行，您会注意到 string.find 只调用了一次，因此在此脚本的运行中这不是性能问题。但是：您str在其他任何地方都使用方法。string现在不推荐使用函数，而是通过调用相应的str方法来实现。你最好写elements[0].find('p') == 0一个精确但更快的等价物，并且可能喜欢使用elements[0].startswith('p')which 可以让读者不知道这是否== 0应该是 == -1.

@Bernd Petersohn 提到的四种方法在 13.541 秒的总执行时间中只占用了 3.7 秒。在过多担心这些之前，请将您的脚本模块化为函数，再次运行 cProfile，然后按tottime.

使用更改的脚本修改问题后更新：

"""问题：关于加入、拆分和写入操作，我可以做些什么来减少它们对该脚本性能的明显影响？""

嗯？这 3 个加起来总共需要 13.8 秒中的 2.6 秒。您的 parseJarchLine 函数需要 8.5 秒（不包括它调用的函数/方法所用的时间。assert(8.5 > 2.6)

Bernd 已经向您指出了您可能会考虑如何处理这些内容。您不必要地完全拆分该行，只是在写出时再次将其连接起来。您只需要检查第一个元素。而不是elements = line.split('\t')doelements = line.split('\t', 1)和 replace '\t'.join(elements[1:])by elements[1]。

现在让我们深入研究 parseJarchLine 的主体。long内置函数的来源和使用方式的使用次数是惊人的。同样令人惊讶的是longcProfile 输出中没有提到的事实。

为什么你需要long？超过 2 Gb 的文件？好的，那么您需要考虑，从 Python 2.2 开始，int溢出会导致提升long而不是引发异常。您可以利用更快的int算术执行。您还需要考虑long(x)在x已经被证明是 a 的情况下执行操作long是一种资源浪费。

这是 parseJarchLine 函数，其中删除浪费更改标记为 [1]，更改为 int 更改标记为 [2]。好主意：以小步骤进行更改，重新测试，重新配置。

def parseJarchLine(chromosome, line):
    global pLength
    global lastEnd
    elements = line.split('\t')
    if len(elements) > 1:
        if lastEnd != "":
            start = long(lastEnd) + long(elements[0])
            # [1] start = lastEnd + long(elements[0])
            # [2] start = lastEnd + int(elements[0])
            lastEnd = long(start + pLength)
            # [1] lastEnd = start + pLength
            sys.stdout.write("%s\t%ld\t%ld\t%s\n" % (chromosome, start, lastEnd, '\t'.join(elements[1:])))
        else:
            lastEnd = long(elements[0]) + long(pLength)
            # [1] lastEnd = long(elements[0]) + pLength
            # [2] lastEnd = int(elements[0]) + pLength
            sys.stdout.write("%s\t%ld\t%ld\t%s\n" % (chromosome, long(elements[0]), lastEnd, '\t'.join(elements[1:])))
    else:
        if elements[0].startswith('p'):
            pLength = long(elements[0][1:])
            # [2] pLength = int(elements[0][1:])
        else:
            start = long(long(lastEnd) + long(elements[0]))
            # [1] start = lastEnd + long(elements[0])
            # [2] start = lastEnd + int(elements[0])
            lastEnd = long(start + pLength)
            # [1] lastEnd = start + pLength
            sys.stdout.write("%s\t%ld\t%ld\n" % (chromosome, start, lastEnd))               
    return

提问后更新sys.stdout.write

如果您注释掉的语句与原始语句类似：

sys.stdout.write("%s\t%ld\t%ld\t%s\n" % (chromosome, start, lastEnd, '\t'.join(elements[1:])))

那么你的问题是......有趣。尝试这个：

payload = "%s\t%ld\t%ld\t%s\n" % (chromosome, start, lastEnd, '\t'.join(elements[1:]))
sys.stdout.write(payload)

现在注释掉sys.stdout.write声明...

顺便说一句，有人在评论中提到将其分成不止一个写...你考虑过这个吗？elements[1:] 中平均有多少字节？在染色体中？

=== 主题改变：我担心你初始化lastEnd为""而不是为零，而且没有人对此发表评论。无论如何，您应该解决这个问题，这可以进行相当大的简化并添加其他人的建议：

def parseJarchLine(chromosome, line):
    global pLength
    global lastEnd
    elements = line.split('\t', 1)
    if elements[0][0] == 'p':
        pLength = int(elements[0][1:])
        return
    start = lastEnd + int(elements[0])
    lastEnd = start + pLength
    sys.stdout.write("%s\t%ld\t%ld" % (chromosome, start, lastEnd))
    if elements[1:]:
        sys.stdout.write(elements[1])
    sys.stdout.write(\n)

现在我同样担心这两个全局变量lastEnd，而且pLengthparseJarchLine 函数现在是如此之小，以至于它可以折叠回其唯一调用者的主体中extractData，它保存了两个全局变量和一个庞大的函数调用。sys.stdout.write您还可以通过将write = sys.stdout.write一次放在前面extractData并使用它来节省大量查找。

顺便说一句，脚本测试 Python 2.5 或更高版本；您是否尝试过在 2.5 和 2.6 上进行分析？

于 2010-10-10T04:13:46.620 回答
2

如果您的代码像 Lie Ryan 所说的那样更加模块化，那么这个输出将会更加有用。但是，您可以从输出中获取一些内容并查看源代码：

你正在做很多在 Python 中实际上不需要的比较。例如，而不是：

if len(entryText) > 0:

你可以写：

if entryText:

在 Python 中，空列表的计算结果为 False。空字符串也是如此，您也在代码中对其进行测试，并且更改它也会使代码更短且更具可读性，所以不要这样：

   for line in metadataLines:      
        if line == '':
            break
        else:
            metadataList.append(line)

你可以这样做：

for line in metadataLines:
    if line:
       metadataList.append(line)

此代码在组织和性能方面还有其他几个问题。例如，您将变量多次分配给同一事物，而不是只创建一次对象实例并对该对象进行所有访问。这样做会减少分配的数量，以及全局变量的数量。我不想听起来过于挑剔，但这段代码似乎没有考虑到性能。

于 2010-10-10T02:21:23.613 回答
-1

与可能优化相关的条目是ncalls和tottime值较高的条目。bgchr:4(<module>)并且<string>:1(<module>)可能是指您的模块主体的执行，与此处无关。

显然，您的性能问题来自字符串处理。这也许应该减少。热点是split和。似乎也很昂贵。joinsys.stdout.writebz2.decompress

我建议您尝试以下方法：

  • 您的主要数据似乎由制表符分隔的 CSV 值组成。试试看，如果 CSV 阅读器表现更好。
  • 每次写入换行符时，sys.stdout 都会被行缓冲和刷新。考虑写入具有较大缓冲区大小的文件。
  • 与其在写出之前加入元素，不如将它们按顺序写入输出文件。您也可以考虑使用 CSV 编写器。
  • 与其将数据立即解压缩为单个字符串，不如使用 BZ2File 对象并将其传递给 CSV 阅读器。

似乎实际上解压缩数据的循环体只被调用一次。也许您找到了一种避免调用的方法，该调用dataHandle.read(size)会产生一个巨大的字符串，然后将其解压缩，并直接使用文件对象。

附录： BZ2File 可能不适用于您的情况，因为它需要一个文件名参数。您需要的是具有集成读取限制的文件对象视图，与 ZipExtFile 相当，但使用 BZ2Decompressor 进行解压缩。

我在这里的主要观点是，您的代码应该被更改以对您的数据执行更多的迭代处理，而不是将其作为一个整体并在之后再次拆分它。

于 2010-10-10T02:18:23.217 回答