Project Euler和其他编码竞赛通常有最长的运行时间，或者人们吹嘘他们的特定解决方案运行速度有多快。对于Python，有时方法有些笨拙——即向__main__添加计时代码。
描述Python程序运行时间的好方法是什么？
Python包括一个名为cProfile的分析器。它不仅给出了总的运行时间，而且还分别计算了每个函数的时间，并告诉每个函数被调用了多少次，从而很容易确定应该在哪里进行优化。
您可以从代码内部或从解释器调用它，如下所示：
import cProfile
cProfile.run('foo()')
更有用的是，您可以在运行脚本时调用cProfile：
python -m cProfile myscript.py
为了更简单，我制作了一个名为“profile.bat”的小批处理文件：
python -m cProfile %1
所以我要做的就是跑：
profile euler048.py
我得到了这个：
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
编辑：更新了2013年PyCon视频资源的链接，标题为Python评测也可以通过YouTube。
在Virtaal的源代码中，有一个非常有用的类和装饰器，它可以使分析（甚至对于特定的方法/函数）非常简单。然后可以在KCacheGrind中非常舒适地查看输出。
值得指出的是，使用探查器仅在主线程上有效（默认情况下），如果使用它们，您将无法从其他线程获得任何信息。这可能有点棘手，因为探查器文档中完全没有提到它。
如果您还想评测线程，那么您需要查看文档中的threading.setprofile（）函数。
您也可以创建自己的线程.Thread子类：
class ProfiledThread(threading.Thread):
# Overrides threading.Thread.run()
def run(self):
profiler = cProfile.Profile()
try:
return profiler.runcall(threading.Thread.run, self)
finally:
profiler.dump_stats('myprofile-%d.profile' % (self.ident,))
并使用ProfiledThread类而不是标准类。它可能会给你更多的灵活性，但我不确定它是否值得，特别是如果你使用的是不使用你的类的第三方代码。
python wiki是一个用于分析资源的绝佳页面：http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
python文档也是如此：http://docs.python.org/library/profile.html
如Chris Lawlor所示，cProfile是一个很棒的工具，可以很容易地打印到屏幕上：
python -m cProfile -s time mine.py <args>
或存档：
python -m cProfile -o output.file mine.py <args>
PS>如果您使用的是Ubuntu，请确保安装python配置文件
apt-get install python-profiler
如果输出到文件，可以使用以下工具获得良好的可视化效果
PyCallGraph：创建调用图图像的工具安装：
pip install pycallgraph
run:
pycallgraph mine.py args
视图：
gimp pycallgraph.png
你可以使用任何你喜欢的方式来查看png文件，我使用了gimp不幸的是，我经常
dot:graph对于cairo渲染器位图太大。缩放0.257079以适合
这使我的图像变得难以使用。所以我通常创建svg文件：
pycallgraph -f svg -o pycallgraph.svg mine.py <args>
PS>确保安装graphviz（提供点程序）：
pip install graphviz
使用gprof2dot通过@maxy/@quodlibetor绘制替代图形：
pip install gprof2dot
python -m cProfile -o profile.pstats mine.py
gprof2dot -f pstats profile.pstats | dot -Tsvg -o mine.svg
一个很好的评测模块是line_profiler（使用kernprof.py脚本调用）。它可以在这里下载。
我的理解是，cProfile只提供每个函数花费的总时间的信息。因此，单独的代码行是不定时的。这是科学计算中的一个问题，因为通常一条线会花费很多时间。而且，我记得，cProfile没有抓住我在say numpy.dot上花费的时间。
根据乔·肖（Joe Shaw）关于多线程代码无法按预期工作的回答，我认为cProfile中的runcall方法只是围绕着已配置的函数调用执行self.enable（）和self.disable（）调用，因此您可以简单地自己执行，并在对现有代码的干扰最小的情况下使用任何代码。
不久前，我制作了pycallgraph，它从您的Python代码生成可视化。编辑：我已经将示例更新为使用3.3，这是本文撰写时的最新版本。
在pip安装pycallgraph并安装GraphViz之后，您可以从命令行运行它：
pycallgraph graphviz -- ./mypythonscript.py
或者，您可以分析代码的特定部分：
from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput
with PyCallGraph(output=GraphvizOutput()):
code_to_profile()
其中任何一个都将生成类似下图的pycallgraph.png文件：
想知道python脚本到底在做什么吗？输入检查外壳。Inspect Shell允许您打印/更改全局并运行函数，而不中断正在运行的脚本。现在有了自动完成和命令历史记录（仅在linux上）。Inspect Shell不是pdb样式的调试器。
https://github.com/amoffat/Inspect-Shell
你可以用它（还有你的手表）。
@Maxy对这个答案的评论对我帮助很大，我认为它应该得到自己的答案：我已经有了cProfile生成的.pstats文件，我不想用pycallgraph重新运行这些文件，所以我使用了gprof2dot，得到了很好的svgs：
$ sudo apt-get install graphviz
$ git clone https://github.com/jrfonseca/gprof2dot
$ ln -s "$PWD"/gprof2dot/gprof2dot.py ~/bin
$ cd $PROJECT_DIR
$ gprof2dot.py -f pstats profile.pstats | dot -Tsvg -o callgraph.svg
还有BLAM！
它使用点（与pycallgraph使用的相同），因此输出看起来类似。我觉得gprof2dot丢失的信息更少：
我的方法是使用雅皮语(https://github.com/sumerc/yappi). 它与RPC服务器结合使用特别有用，在RPC服务器中（甚至只是为了调试），您可以注册方法来启动、停止和打印配置信息，例如，通过以下方式：
@staticmethod
def startProfiler():
yappi.start()
@staticmethod
def stopProfiler():
yappi.stop()
@staticmethod
def printProfiler():
stats = yappi.get_stats(yappi.SORTTYPE_TTOT, yappi.SORTORDER_DESC, 20)
statPrint = '\n'
namesArr = [len(str(stat[0])) for stat in stats.func_stats]
log.debug("namesArr %s", str(namesArr))
maxNameLen = max(namesArr)
log.debug("maxNameLen: %s", maxNameLen)
for stat in stats.func_stats:
nameAppendSpaces = [' ' for i in range(maxNameLen - len(stat[0]))]
log.debug('nameAppendSpaces: %s', nameAppendSpaces)
blankSpace = ''
for space in nameAppendSpaces:
blankSpace += space
log.debug("adding spaces: %s", len(nameAppendSpaces))
statPrint = statPrint + str(stat[0]) + blankSpace + " " + str(stat[1]).ljust(8) + "\t" + str(
round(stat[2], 2)).ljust(8 - len(str(stat[2]))) + "\t" + str(round(stat[3], 2)) + "\n"
log.log(1000, "\nname" + ''.ljust(maxNameLen - 4) + " ncall \tttot \ttsub")
log.log(1000, statPrint)
然后，当您的程序工作时，您可以通过调用startProfiler RPC方法随时启动探查器，并通过调用printProfiler（或修改RPC方法将其返回给调用者）将探查信息转储到日志文件中，并获得这样的输出：
2014-02-19 16:32:24,128-|SVR-MAIN |-(Thread-3 )-Level 1000:
name ncall ttot tsub
2014-02-19 16:32:24,128-|SVR-MAIN |-(Thread-3 )-Level 1000:
C:\Python27\lib\sched.py.run:80 22 0.11 0.05
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\xmlRpc.py.iterFnc:293 22 0.11 0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\serverMain.py.makeIteration:515 22 0.11 0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\PicklingXMLRPC.py._dispatch:66 1 0.0 0.0
C:\Python27\lib\BaseHTTPServer.py.date_time_string:464 1 0.0 0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py._get_raw_meminfo:243 4 0.0 0.0
C:\Python27\lib\SimpleXMLRPCServer.py.decode_request_content:537 1 0.0 0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py.get_system_cpu_times:148 4 0.0 0.0
<string>.__new__:8 220 0.0 0.0
C:\Python27\lib\socket.py.close:276 4 0.0 0.0
C:\Python27\lib\threading.py.__init__:558 1 0.0 0.0
<string>.__new__:8 4 0.0 0.0
C:\Python27\lib\threading.py.notify:372 1 0.0 0.0
C:\Python27\lib\rfc822.py.getheader:285 4 0.0 0.0
C:\Python27\lib\BaseHTTPServer.py.handle_one_request:301 1 0.0 0.0
C:\Python27\lib\xmlrpclib.py.end:816 3 0.0 0.0
C:\Python27\lib\SimpleXMLRPCServer.py.do_POST:467 1 0.0 0.0
C:\Python27\lib\SimpleXMLRPCServer.py.is_rpc_path_valid:460 1 0.0 0.0
C:\Python27\lib\SocketServer.py.close_request:475 1 0.0 0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\__init__.py.cpu_times:1066 4 0.0 0.0
它可能对短脚本不太有用，但有助于优化服务器类型的进程，特别是考虑到printProfiler方法可以随时间多次调用，以分析和比较例如不同的程序使用场景。
在较新版本的yappi中，以下代码将起作用：
@staticmethod
def printProfile():
yappi.get_func_stats().print_all()
还值得一提的是GUI cProfile转储查看器RunSnakeRun。它允许您排序和选择，从而放大程序的相关部分。图片中矩形的大小与所用时间成正比。如果您将鼠标悬停在一个矩形上，它将突出显示表中的调用以及地图上的任何位置。双击矩形时，它会放大该部分。它将显示谁调用了该部分以及该部分调用了什么。
描述性信息非常有用。它向您显示了该位的代码，当您处理内置库调用时，该代码会很有用。它告诉要查找代码的文件和行。
还想指出，OP说的是“剖析”，但似乎他是指“时机”。请记住，程序在评测时运行速度会变慢。
pprofile文件
line_profiler（此处已介绍）也启发了pprofile，其描述如下：
行粒度、线程感知确定性和统计纯python剖面仪
它提供了line_profiler的行粒度，是纯Python，可以用作独立命令或模块，甚至可以生成callgrind格式的文件，这些文件可以很容易地使用[k|q]cachegrind进行分析。
vprof公司
还有vprof，一个Python包，描述如下：
[…]为各种Python程序特性（如运行时间和内存使用）提供丰富的交互式可视化。
添加到https://stackoverflow.com/a/582337/1070617,
我编写了这个模块，允许您使用cProfile并轻松查看其输出。更多信息：https://github.com/ymichael/cprofilev
$ python -m cprofilev /your/python/program
# Go to http://localhost:4000 to view collected statistics.
另请参见：http://ymichael.com/2014/03/08/profiling-python-with-cprofile.html如何理解收集的统计数据。
cProfile非常适合快速分析，但大多数时候它都以错误结束。函数runctx通过正确初始化环境和变量来解决这个问题，希望它对某些人有用：
import cProfile
cProfile.runctx('foo()', None, locals())
PyVmMonitor是一种在Python中处理评测的新工具：http://www.pyvmmonitor.com/
它具有一些独特的功能，例如
将探查器附加到正在运行的（CPython）程序Yappi集成的按需分析不同机器上的配置文件多进程支持（多处理、django…）实时采样/CPU视图（带时间范围选择）通过cProfile/配置文件集成进行确定性配置分析现有PStats结果打开DOT文件编程API访问按方法或行对样本进行分组PyDev集成PyCharm集成
注意：它是商业的，但对开源是免费的。
有很多很好的答案，但它们要么使用命令行，要么使用一些外部程序来分析和/或排序结果。
我真的错过了在IDE（eclipsePyDev）中使用而不接触命令行或安装任何东西的方法。所以就在这里。
无命令行分析
def count():
from math import sqrt
for x in range(10**5):
sqrt(x)
if __name__ == '__main__':
import cProfile, pstats
cProfile.run("count()", "{}.profile".format(__file__))
s = pstats.Stats("{}.profile".format(__file__))
s.strip_dirs()
s.sort_stats("time").print_stats(10)
有关更多信息，请参阅文档或其他答案。
还有一个叫做statprof的统计分析器。它是一个采样分析器，因此它为代码增加了最小的开销，并提供了基于行的（而不仅仅是基于函数的）计时。它更适合于游戏等软实时应用，但精度可能低于cProfile。
pypi中的版本有点旧，因此可以通过指定git存储库来使用pip安装：
pip install git+git://github.com/bos/statprof.py@1a33eba91899afe17a8b752c6dfdec6f05dd0c01
您可以这样运行：
import statprof
with statprof.profile():
my_questionable_function()
另请参见https://stackoverflow.com/a/10333592/320036
cProfile非常适合于分析，而kcachegrind非常适合于可视化结果。中间的pyprov2calltree处理文件转换。
python -m cProfile -o script.profile script.py
pyprof2calltree -i script.profile -o script.calltree
kcachegrind script.calltree
所需的系统包：
kcachegrind（Linux）、qcachegrind（MacOs）
Ubuntu上的设置：
apt-get install kcachegrind
pip install pyprof2calltree
结果：
在研究这个主题时，我遇到了一个叫做SnakeViz的便捷工具。SnakeViz是一个基于web的评测可视化工具。它非常容易安装和使用。我通常使用的方法是用%prun生成一个stat文件，然后在SnakeViz中进行分析。
所使用的主要viz技术是下图所示的Sunburst图表，其中函数调用的层次结构被安排为弧和时间信息的层，以其角度宽度编码。
最好的是你可以与图表互动。例如，要放大，可以单击一个弧，弧及其后代将被放大为新的阳光，以显示更多细节。
当我不是服务器的根用户时，我使用lsprofcalltree.py并像这样运行我的程序：
python lsprofcalltree.py -o callgrind.1 test.py
然后我可以用任何callgrind兼容的软件打开报告，比如qcachegrind
这取决于您希望从分析中看到什么。简单的时间度量可以由（bash）给出。
time python python_prog.py
甚至“/usr/bin/time”也可以使用“--verbose”标志输出详细的度量。
为了检查每个函数给出的时间度量，并更好地了解在函数上花费的时间，可以使用python中的内置cProfile。
进入更详细的指标，如绩效，时间不是唯一的指标。您可以担心内存、线程等问题。分析选项：line_profiler是另一个通常用于逐行查找定时度量的分析器。2.memory_profiler是一个评测内存使用情况的工具。3.heapy（来自项目Guppy）描述如何使用堆中的对象。
这些是我常用的一些。但如果你想了解更多，试试看这本书这是一本非常好的书，讲述了如何从性能出发。您可以转到使用Cython和JIT（实时）编译的python的高级主题。
找到所有时间去向的最简单快捷的方法。
1. pip install snakeviz
2. python -m cProfile -o temp.dat <PROGRAM>.py
3. snakeviz temp.dat
在浏览器中绘制饼图。最大的部分是问题函数。非常简单。
我最近创建了金枪鱼，用于可视化Python运行时和导入配置文件；这在这里可能会有所帮助。
使用安装
pip install tuna
创建运行时配置文件
python3 -m cProfile -o program.prof yourfile.py
或导入配置文件（需要Python 3.7+）
python3 -X importprofile yourfile.py 2> import.log
那就把金枪鱼放在档案里
tuna program.prof
gprof2dot_magic公司
gprof2dot的神奇函数，用于在JupyterLab或Jupyter Notebook中将任何Python语句作为DOT图进行评测。
GitHub回购：https://github.com/mattijn/gprof2dot_magic
安装
确保您有Python包gprof2dot_magic。
pip install gprof2dot_magic
它的依赖关系gprof2dot和graphviz也将被安装
用法
要启用magic函数，首先加载gprof2dot_magic模块
%load_ext gprof2dot_magic
然后将任何行语句配置为DOT图，如下所示：
%gprof2dot print('hello world')
只有终端（也是最简单的）解决方案，以防所有这些花哨的UI无法安装或运行：完全忽略cProfile并将其替换为pyinstrument，它将在执行后立即收集并显示调用树。
安装：
$ pip install pyinstrument
配置文件和显示结果：
$ python -m pyinstrument ./prog.py
适用于蟒蛇2和3。
[编辑]这里可以找到API的文档，用于分析代码的一部分。
如果你想做一个累积分析器，意思是连续运行函数几次并观察结果的总和。
您可以使用此cumulative_profiler装饰器：
它是python>=3.6特定的，但您可以删除非本地的，因为它可以在旧版本上工作。
import cProfile, pstats
class _ProfileFunc:
def __init__(self, func, sort_stats_by):
self.func = func
self.profile_runs = []
self.sort_stats_by = sort_stats_by
def __call__(self, *args, **kwargs):
pr = cProfile.Profile()
pr.enable() # this is the profiling section
retval = self.func(*args, **kwargs)
pr.disable()
self.profile_runs.append(pr)
ps = pstats.Stats(*self.profile_runs).sort_stats(self.sort_stats_by)
return retval, ps
def cumulative_profiler(amount_of_times, sort_stats_by='time'):
def real_decorator(function):
def wrapper(*args, **kwargs):
nonlocal function, amount_of_times, sort_stats_by # for python 2.x remove this row
profiled_func = _ProfileFunc(function, sort_stats_by)
for i in range(amount_of_times):
retval, ps = profiled_func(*args, **kwargs)
ps.print_stats()
return retval # returns the results of the function
return wrapper
if callable(amount_of_times): # incase you don't want to specify the amount of times
func = amount_of_times # amount_of_times is the function in here
amount_of_times = 5 # the default amount
return real_decorator(func)
return real_decorator
实例
剖析函数baz
import time
@cumulative_profiler
def baz():
time.sleep(1)
time.sleep(2)
return 1
baz()
baz跑了5次并打印了以下内容：
20 function calls in 15.003 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
10 15.003 1.500 15.003 1.500 {built-in method time.sleep}
5 0.000 0.000 15.003 3.001 <ipython-input-9-c89afe010372>:3(baz)
5 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
指定次数
@cumulative_profiler(3)
def baz():
...
我刚刚从pypref_time中开发了自己的分析器：
https://github.com/modaresimr/auto_profiler
更新版本2
安装：
pip install auto_profiler
快速入门：
from auto_profiler import Profiler
with Profiler():
your_function()
在Jupyter中使用，可以实时查看已用时间
更新版本1
通过添加装饰器，它将显示一个耗时的函数树
@探查器（深度=4）
Install by: pip install auto_profiler
实例
import time # line number 1
import random
from auto_profiler import Profiler, Tree
def f1():
mysleep(.6+random.random())
def mysleep(t):
time.sleep(t)
def fact(i):
f1()
if(i==1):
return 1
return i*fact(i-1)
def main():
for i in range(5):
f1()
fact(3)
with Profiler(depth=4):
main()
示例输出
Time [Hits * PerHit] Function name [Called from] [function location]
-----------------------------------------------------------------------
8.974s [1 * 8.974] main [auto-profiler/profiler.py:267] [/test/t2.py:30]
├── 5.954s [5 * 1.191] f1 [/test/t2.py:34] [/test/t2.py:14]
│ └── 5.954s [5 * 1.191] mysleep [/test/t2.py:15] [/test/t2.py:17]
│ └── 5.954s [5 * 1.191] <time.sleep>
|
|
| # The rest is for the example recursive function call fact
└── 3.020s [1 * 3.020] fact [/test/t2.py:36] [/test/t2.py:20]
├── 0.849s [1 * 0.849] f1 [/test/t2.py:21] [/test/t2.py:14]
│ └── 0.849s [1 * 0.849] mysleep [/test/t2.py:15] [/test/t2.py:17]
│ └── 0.849s [1 * 0.849] <time.sleep>
└── 2.171s [1 * 2.171] fact [/test/t2.py:24] [/test/t2.py:20]
├── 1.552s [1 * 1.552] f1 [/test/t2.py:21] [/test/t2.py:14]
│ └── 1.552s [1 * 1.552] mysleep [/test/t2.py:15] [/test/t2.py:17]
└── 0.619s [1 * 0.619] fact [/test/t2.py:24] [/test/t2.py:20]
└── 0.619s [1 * 0.619] f1 [/test/t2.py:21] [/test/t2.py:14]
对于像austin这样的统计分析器，不需要检测，这意味着您可以简单地使用
austin python3 my_script.py
原始输出不是很有用，但您可以将其传输到flamegraph.pl以获得该数据的火焰图表示，该火焰图提供了时间（以微秒为单位的实时）的细分。
austin python3 my_script.py | flamegraph.pl > my_script_profile.svg
或者，您也可以使用web应用程序Speedscope.app快速可视化收集的样本。如果您安装了pprof，还可以获取austin python（例如，pipx安装austin python）并使用austin2prof转换为pprof格式。
然而，如果您安装了VS Code，您可以使用Austin扩展来获得更交互式的体验，包括源代码热图、顶级函数和收集的调用堆栈
如果您想使用终端，也可以使用TUI，它也具有实时图形模式：
获取IPython笔记本上的快速配置文件统计信息。人们可以将line_profiler和memory_profile直接嵌入到笔记本中。
另一个有用的包是Pympler。它是一个强大的评测包，能够跟踪类、对象、函数、内存泄漏等。
了解了！
!pip install line_profiler
!pip install memory_profiler
!pip install pympler
加载它！
%load_ext line_profiler
%load_ext memory_profiler
使用它！
%时间
%time print('Outputs CPU time,Wall Clock time')
#CPU times: user 2 µs, sys: 0 ns, total: 2 µs Wall time: 5.96 µs
给予：
CPU时间：CPU级执行时间systimes:系统级执行时间总计：CPU时间+系统时间墙上时间：墙上时钟时间
%计时
%timeit -r 7 -n 1000 print('Outputs execution time of the snippet')
#1000 loops, best of 7: 7.46 ns per loop
给出给定循环次数（n）中的最佳运行次数（r）。输出系统缓存的详细信息：当代码片段被多次执行时，系统会缓存一些操作并不再执行，这可能会影响概要文件报告的准确性。
%普鲁士人
%prun -s cumulative 'Code to profile'
给予：
函数调用数（ncall）每个函数调用有个条目（不同）每次呼叫所用时间（百分比）到函数调用为止的时间（cumtime）调用的函数/模块的名称等。。。
%记忆，记忆
%memit 'Code to profile'
#peak memory: 199.45 MiB, increment: 0.00 MiB
给予：
内存使用情况
%低压运行
#Example function
def fun():
for i in range(10):
print(i)
#Usage: %lprun <name_of_the_function> function
%lprun -f fun fun()
给予：
按行统计
系统大小
sys.getsizeof('code to profile')
# 64 bytes
返回对象的大小（以字节为单位）。
来自pympler的asizeof（）
from pympler import asizeof
obj = [1,2,("hey","ha"),3]
print(asizeof.asizeof(obj,stats=4))
pympler.asizeof可用于调查某些Python对象消耗多少内存。与sys.getsizeof不同，asizeof递归地调整对象大小
来自pympler的跟踪器
from pympler import tracker
tr = tracker.SummaryTracker()
def fun():
li = [1,2,3]
di = {"ha":"haha","duh":"Umm"}
fun()
tr.print_diff()
跟踪函数的生存期。
Pympler包包含大量用于评测代码的高实用函数。这里无法涵盖所有这些。有关详细的概要文件实现，请参阅随附的文档。
Pympler文档
最近，我为PyCharm创建了一个插件，使用该插件，您可以在PyCharm编辑器中轻松分析和可视化line_profiler的结果。
linepfiler在其他答案中也提到过，它是一个很好的工具，可以准确分析python解释器在某些行中花费了多少时间。
我创建的PyCharm插件可以在这里找到：https://plugins.jetbrains.com/plugin/16536-line-profiler
它需要一个python环境中的助手包，名为line profiler pycharm，可以使用pip或插件本身安装。
在PyCharm中安装插件后：
用line_profiler_pycharm.profile装饰器装饰您想要评测的任何函数使用“轮廓线”跑步器跑步
结果截图：
我发现cprofiler和其他资源更多地用于优化目的，而不是调试。
我制作了自己的测试模块，用于简单的python脚本速度测试。（在我的例子中，使用ScriptProfilerPy测试了1K+行py文件，并在几分钟内将代码速度提高了10倍。
模块ScriptProfilerPy（）将运行代码，并向其添加时间戳。我把模块放在这里：https://github.com/Lucas-BLP/ScriptProfilerPy
Use:
from speed_testpy import ScriptProfilerPy
ScriptProfilerPy("path_to_your_script_to_test.py").Profiler()
输出：
我发现，如果您不想使用命令行选项，该功能快速且易于使用。
要使用，只需在要分析的每个函数上方添加@profile。
def profile(fnc):
"""
Profiles any function in following class just by adding @profile above function
"""
import cProfile, pstats, io
def inner (*args, **kwargs):
pr = cProfile.Profile()
pr.enable()
retval = fnc (*args, **kwargs)
pr.disable()
s = io.StringIO()
sortby = 'cumulative' #Ordered
ps = pstats.Stats(pr,stream=s).strip_dirs().sort_stats(sortby)
n=10 #reduced the list to be monitored
ps.print_stats(n)
#ps.dump_stats("profile.prof")
print(s.getvalue())
return retval
return inner
每个函数的输出如下
Ordered by: cumulative time
List reduced from 38 to 10 due to restriction <10>
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.002 0.002 3151212474.py:37(get_pdf_page_count)
1 0.000 0.000 0.002 0.002 fitz.py:3604(__init__)
1 0.001 0.001 0.001 0.001 {built-in method fitz._fitz.new_Document}
1 0.000 0.000 0.000 0.000 fitz.py:5207(__del__)
1 0.000 0.000 0.000 0.000 {built-in method fitz._fitz.delete_Document}
1 0.000 0.000 0.000 0.000 fitz.py:4816(init_doc)
1 0.000 0.000 0.000 0.000 fitz.py:5197(_reset_page_refs)
1 0.000 0.000 0.000 0.000 fitz.py:4821(<listcomp>)
11 0.000 0.000 0.000 0.000 fitz.py:4054(_getMetadata)
1 0.000 0.000 0.000 0.000 weakref.py:241(values)
Scalene是一个新的python分析器，它涵盖了许多用例，对性能的影响最小：
https://github.com/plasma-umass/scalene
它可以在非常精细的水平上评测CPU、GPU和内存利用率。它还特别支持多线程/并行化的python代码。
推荐文章
- 如何在Python中进行热编码?
- 如何嵌入HTML到IPython输出?
- 在Python生成器上使用“send”函数的目的是什么?
- 是否可以将已编译的.pyc文件反编译为.py文件?
- Django模型表单对象的自动创建日期
- 在Python中包装长行
- 如何计算两个时间串之间的时间间隔
- 我如何才能找到一个Python函数的参数的数量?
- 您可以使用生成器函数来做什么?
- 将Python诗歌与Docker集成
- 提取和保存视频帧
- 使用请求包时出现SSL InsecurePlatform错误
- 如何检索Pandas数据帧中的列数?
- except:和except的区别:
- 错误:“字典更新序列元素#0的长度为1;2是必需的”
