如何逐行描述Python代码?


116

我一直在使用cProfile来分析我的代码,并且效果很好。我还使用gprof2dot.py可视化结果(使其更加清晰)。

但是,cProfile(以及到目前为止我见过的大多数其他Python分析器)似乎仅在函数调用级别进行分析。当从不同位置调用某些函数时,这会引起混乱-我不知道调用#1还是调用#2占用了大部分时间。当所讨论的函数有六个层次的深度(从其他七个地方调用)时,情况甚至更糟。

如何获得逐行分析?

代替这个:

function #12, total time: 2.0s

我想看这样的东西:

function #12 (called from somefile.py:102) 0.5s
function #12 (called from main.py:12) 1.5s

cProfile确实显示了“转移”到父级的总时间,但是当您有许多层和相互连接的呼叫时,该连接也会丢失。

理想情况下,我希望有一个GUI可以解析数据,然后向我显示源文件以及每行的总时间。像这样:

main.py:

a = 1 # 0.0s
result = func(a) # 0.4s
c = 1000 # 0.0s
result = func(c) # 5.0s

然后,我可以单击第二个“ func(c)”调用,以查看该调用中占用的时间,与“ func(a)”调用分开。

那有意义吗?是否有任何收集此类信息的性能分析库?我错过了一些很棒的工具吗?


2
我的猜测是您会对此感兴趣pstats.print_callers这里有一个例子。
Muhammad Alkarouri

穆罕默德,那绝对有帮助!至少它解决了一个问题:根据来源分离函数调用。我认为Joe Kington的答案更接近我的目标,但是print_callers()绝对可以让我走到一半。谢谢!
火箭猴2010年

Answers:


120

我相信这就是Robert Kern的line_profiler的目的。从链接:

File: pystone.py
Function: Proc2 at line 149
Total time: 0.606656 s

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   149                                           @profile
   150                                           def Proc2(IntParIO):
   151     50000        82003      1.6     13.5      IntLoc = IntParIO + 10
   152     50000        63162      1.3     10.4      while 1:
   153     50000        69065      1.4     11.4          if Char1Glob == 'A':
   154     50000        66354      1.3     10.9              IntLoc = IntLoc - 1
   155     50000        67263      1.3     11.1              IntParIO = IntLoc - IntGlob
   156     50000        65494      1.3     10.8              EnumLoc = Ident1
   157     50000        68001      1.4     11.2          if EnumLoc == Ident1:
   158     50000        63739      1.3     10.5              break
   159     50000        61575      1.2     10.1      return IntParIO

希望有帮助!


10
line_profiler是否可以在Python 3中使用?我没有得到任何信息。
user1251007 2012年

3
line_profiler没有为我显示点击数和时间。谁能告诉我为什么?以及如何解决?
I159 2013年

6
这是我写的装饰器:gist.github.com/kylegibson/6583590。如果正在运行鼻子测试,请确保使用-s选项,以便立即打印stdout。
凯尔·吉布森

5
产生此输出的python脚本是什么样的?import line_profiler;然后 ?
2014年

10
谁能展示如何实际使用此库?该自述文件教授如何安装,并回答了各种常见问题解答,但没有提到在点子安装后如何使用它
。.– cryanbhu

47

您也可以使用pprofilepypi)。如果要分析整个执行过程,则不需要修改源代码。您还可以通过两种方法来分析较大程序的子集:

  • 到达代码中的特定点时切换配置文件,例如:

    import pprofile
    profiler = pprofile.Profile()
    with profiler:
        some_code
    # Process profile content: generate a cachegrind file and send it to user.
    
    # You can also write the result to the console:
    profiler.print_stats()
    
    # Or to a file:
    profiler.dump_stats("/tmp/profiler_stats.txt")
  • 通过使用统计性能分析从调用堆栈异步切换性能分析(需要一种在考虑的应用程序中触发此代码的方法,例如信号处理程序或可用的工作线程):

    import pprofile
    profiler = pprofile.StatisticalProfile()
    statistical_profiler_thread = pprofile.StatisticalThread(
        profiler=profiler,
    )
    with statistical_profiler_thread:
        sleep(n)
    # Likewise, process profile content

代码注释输出格式非常类似于行分析器:

$ pprofile --threads 0 demo/threads.py
Command line: ['demo/threads.py']
Total duration: 1.00573s
File: demo/threads.py
File duration: 1.00168s (99.60%)
Line #|      Hits|         Time| Time per hit|      %|Source code
------+----------+-------------+-------------+-------+-----------
     1|         2|  3.21865e-05|  1.60933e-05|  0.00%|import threading
     2|         1|  5.96046e-06|  5.96046e-06|  0.00%|import time
     3|         0|            0|            0|  0.00%|
     4|         2|   1.5974e-05|  7.98702e-06|  0.00%|def func():
     5|         1|      1.00111|      1.00111| 99.54%|  time.sleep(1)
     6|         0|            0|            0|  0.00%|
     7|         2|  2.00272e-05|  1.00136e-05|  0.00%|def func2():
     8|         1|  1.69277e-05|  1.69277e-05|  0.00%|  pass
     9|         0|            0|            0|  0.00%|
    10|         1|  1.81198e-05|  1.81198e-05|  0.00%|t1 = threading.Thread(target=func)
(call)|         1|  0.000610828|  0.000610828|  0.06%|# /usr/lib/python2.7/threading.py:436 __init__
    11|         1|  1.52588e-05|  1.52588e-05|  0.00%|t2 = threading.Thread(target=func)
(call)|         1|  0.000438929|  0.000438929|  0.04%|# /usr/lib/python2.7/threading.py:436 __init__
    12|         1|  4.79221e-05|  4.79221e-05|  0.00%|t1.start()
(call)|         1|  0.000843048|  0.000843048|  0.08%|# /usr/lib/python2.7/threading.py:485 start
    13|         1|  6.48499e-05|  6.48499e-05|  0.01%|t2.start()
(call)|         1|   0.00115609|   0.00115609|  0.11%|# /usr/lib/python2.7/threading.py:485 start
    14|         1|  0.000205994|  0.000205994|  0.02%|(func(), func2())
(call)|         1|      1.00112|      1.00112| 99.54%|# demo/threads.py:4 func
(call)|         1|  3.09944e-05|  3.09944e-05|  0.00%|# demo/threads.py:7 func2
    15|         1|  7.62939e-05|  7.62939e-05|  0.01%|t1.join()
(call)|         1|  0.000423908|  0.000423908|  0.04%|# /usr/lib/python2.7/threading.py:653 join
    16|         1|  5.26905e-05|  5.26905e-05|  0.01%|t2.join()
(call)|         1|  0.000320196|  0.000320196|  0.03%|# /usr/lib/python2.7/threading.py:653 join

请注意,由于pprofile不依赖于代码修改,因此它可以分析顶级模块语句,从而可以分析程序启动时间(导入模块,初始化全局变量等所需的时间)。

它可以生成cachegrind格式的输出,因此您可以使用kcachegrind轻松浏览大结果。

披露:我是pprofile作者。


1
+1感谢您的贡献。看起来做得不错。我有一些不同的观点-测量语句和函数所花费的包容时间是一个目标。找出可以使代码更快的方法是另一个目标。随着代码变大,这种区别变得很明显-就像10 ^ 6行代码。该代码可能会浪费大量时间。我发现它的方法是,取少量非常详细的样本,然后用肉眼检查它们-而不是进行总结。问题所浪费的时间很少。
Mike Dunlavey

1
没错,当有人要分析较小的子集时,我没有提到pprofile的用法。我编辑了帖子以添加示例。
vpelletier'2

3
这正是我一直在寻找的:非侵入性和广泛的。
egpbos

1
不错的工具,但是它的运行速度比原始代码慢了几倍。
rominf

4

您可以为此使用line_profiler软件包的帮助

1.首先安装软件包:

    pip install line_profiler

2.使用magic命令将包加载到python / notebook环境

    %load_ext line_profiler

3.如果要分析功能代码,
请执行以下操作:

    %lprun -f demo_func demo_func(arg1, arg2)

如果您按照以下步骤操作,您将获得包含所有详细信息的格式化输出:)

Line #      Hits      Time    Per Hit   % Time  Line Contents
 1                                           def demo_func(a,b):
 2         1        248.0    248.0     64.8      print(a+b)
 3         1         40.0     40.0     10.4      print(a)
 4         1         94.0     94.0     24.5      print(a*b)
 5         1          1.0      1.0      0.3      return a/b

4

只是为了改善@Joe Kington的上述答案

对于Python 3.x,请使用line_profiler


安装:

pip install line_profiler

用法:

假设您具有该程序main.py及其中的功能fun_a()fun_b()并且要针对时间进行分析;您将需要@profile在函数定义之前使用装饰器。例如

@profile
def fun_a():
    #do something

@profile
def fun_b():
    #do something more

if __name__ == '__main__':
    fun_a()
    fun_b()

可以通过执行shell命令来分析程序:

$ kernprof -l -v main.py

可以使用获取参数 $ kernprof -h

Usage: kernprof [-s setupfile] [-o output_file_path] scriptfile [arg] ...

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -l, --line-by-line    Use the line-by-line profiler from the line_profiler
                        module instead of Profile. Implies --builtin.
  -b, --builtin         Put 'profile' in the builtins. Use 'profile.enable()'
                        and 'profile.disable()' in your code to turn it on and
                        off, or '@profile' to decorate a single function, or
                        'with profile:' to profile a single section of code.
  -o OUTFILE, --outfile=OUTFILE
                        Save stats to <outfile>
  -s SETUP, --setup=SETUP
                        Code to execute before the code to profile
  -v, --view            View the results of the profile in addition to saving
                        it.

结果将在控制台上显示为:

Total time: 17.6699 s
File: main.py
Function: fun_a at line 5

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    5                                           @profile
    6                                           def fun_a():
...

编辑:探查器的结果可以使用TAMPPA包进行解析。使用它,我们可以逐行获得所需的图 情节


By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.