相关疑难解决方法(0)

可能重复：
如何分析我的代码？

什么是用于分析和性能测试python代码的最佳实践和工具？这里有任何快速获胜或建议。

CProfile接缝很流行，下面还有一些很棒的注释/答案，都是很好的答案/教程。投票出去，我将在一两天内选出最热门的一个。谢谢@senderle和@ campos.ddc

一旦发现问题区域，是否有任何惯用法和/或技巧可用于转换代码以使其更快？

我编写了一个Python脚本,但是运行它比我预期的要花费更长的时间,并且我没有明显的候选者在脚本占用运行时的特殊行.

我可以在代码中添加任何内容来检查每条线路的运行时间吗？

非常感谢.

大约在 8-9 年前，我看到了一个 Visual Studio 工具（我真的不记得名字了），它可以可视化函数调用及其性能。我真的很喜欢它，所以我想知道 Python 中是否有类似的东西。假设您有三个功能：

def first_func():
    ...

def second_func():
    ...
    for i in xrange(10):
        first_function()
    ...

def third_func():
    ...
    for i in xrange(5):
        second_function()
    ...

所以，那个工具的最终报告是这样的（包括连接图）：

first_func[avg 2ms] <--50 times--< second_func[avg 25ms] <--5 times--< third_func[avg 140ms]

像这样的工具可以更容易地找到系统的瓶颈。特别是对于大型系统。

我想从对象的角度来描述python代码.例如:

foo = Foo()
profiled_foo = add_profiling(foo)

# use profiled_foo like foo
...

# later
profiled_foo.print_profile()

我希望按方法调用每个方法花费的累计时间.我没有发现任何类似的东西,虽然我认为写起来不应该太难.

这样的图书馆存在吗？或者也许不是因为这种方式分析会是一个坏主意？

根据Paul McGuire的回答:

import inspect

from time import sleep
from profilehooks import profile

class Foo(object):
    def a(self):
        sleep(0.1)

    def b(self):
        sleep(0.3)

    def c(self):
        sleep(0.5)

def add_profiling(obj):
    for k in dir(obj):
        attr = getattr(obj, k)
        if inspect.ismethod(attr) and k != '__init__':
            setattr(obj, k, profile(attr))

if __name__ == '__main__':
    foo = Foo()
    add_profiling(foo)

    foo.a()
    foo.a()
    foo.b()
    foo.b()
    foo.a()
    foo.c()

.

*** PROFILER RESULTS ***
c …

我是Python的初学者,试图变得更好,我偶然发现了以下练习:

设n是大于1的整数,s(n)是n的d个的和.例如,

s(12) 1 + 2 + 3 + 4 + 6 + 12 = 28

Run Code Online (Sandbox Code Playgroud)

也,

s(s(12)) = s(28) = 1 + 2 + 4 + 7 + 14 + 28 = 56

Run Code Online (Sandbox Code Playgroud)

和

s(s(s(12))) = s(56) = 1 + 2 + 4 + 7 + 8 + 14 + 28 + 56 = 120

Run Code Online (Sandbox Code Playgroud)

我们使用符号:

s^1(n) = s(n)
s^2(n) = s(s(n))
s^3(n) = s(s(s(n)))
s^ m (n) = s(s(. . .s(n) . . .)), m times

Run Code Online (Sandbox Code Playgroud)

对于整数n,其中存在正整数k

 s^m(n) …

Run Code Online (Sandbox Code Playgroud)

与这样的东西：

def time_this(func):
    @functools.wraps(func)
    def what_time_is_it(*args, **kwargs):
        start_time = time.clock()
        print 'STARTING TIME: %f' % start_time
        result = func(*args, **kwargs)
        end_time = time.clock()
        print 'ENDING TIME: %f' % end_time
        print 'TOTAL TIME: %f' % (end_time - start_time)
        return result
     return what_time_is_it

我这么问是因为对我来说编写这样的描述符似乎更容易、更清晰。我认识到 profile/cprofile 尝试估计字节码编译时间等（并从运行时间中减去这些时间），所以更具体地说。

我想知道：

• a) 编译时间什么时候变得足够重要以至于这些差异变得重要？
• b) 我如何编写自己的分析器来考虑编译时间？

我在Objective-c中实现了几乎相同的代码,它的运行速度比Java快两到三倍.我正在试图找出哪些指令可能是最耗费资源的,并且看看是否有更好的方法来做同样的事情,这在Java中更有效.

这是从数据库中读取大型结果集的例程的一部分,对于返回的每个单词,它会检查该单词是否可以从播放器具有的字母区块中创建.它包括对空白图块的支持,可以用作任何字母.空白图块将由下划线字符表示.

基本上,对于从数据库返回的每个单词,我遍历单词的每个字母,并查看可用字母的玩家数组.如果我找到那封信,我将其从玩家阵列中移除并继续前进.如果我没有找到该字母,则该字被丢弃并且下一个字被读取.除非,我在播放器的数组中找到一个下划线字符,然后,我将使用它作为字母,并将其从数组中删除.如果我到达数据库字的字母数组的末尾并且每个字母都"找到",那么该单词将保存在列表中.

我已经计时了整个函数的各个部分,数据库查询发生得非常快.这只是对这个游标的处理非常慢.任何建议,将不胜感激!

if (c.moveToFirst()) {

    do { 
        boolean found = false;
        int aValue = 0;
        int letterValue = 0;

        // Word and Word's length from the database
        String sWord = c.getString(0);
        int wordLength = c.getInt(1);

        // Refresh the Tile array, underscores sorted to the front
        // sortedTiles sorted the players tiles {_,_,a,b,c}
        char[] aTiles = sortedTiles.clone();

        // Calculate the value of the word
        for (int i = 0; i < wordLength; i++) {

            // For each character in …

我有一个关于Java和Python中特定代码片段性能的问题.

算法:
我生成随机的N维点,然后对于彼此在一定距离阈值之下的所有点我做一些处理.处理本身并不重要,因为它不会影响总执行时间.在两种情况下生成点也需要几分之一秒,因此我只对进行比较的部分感兴趣.

执行时间:
对于3000点和2维的固定输入,Java在2到4秒内执行此操作,而Python需要15到200秒之间的任何时间.

我对Python的执行时间有点怀疑.这个Python代码中有什么我想念的吗？是否有任何算法改进建议(例如预分配/重用内存,降低Big-Oh复杂性的方法等)？

Java的

double random_points[][] = new double[number_of_points][dimensions];
for(i = 0; i < number_of_points; i++)
  for(d = 0; d < dimensions; d++)
    random_points[i][d] = Math.random();

double p1[], p2[];
for(i = 0; i < number_of_points; i++)
{
  p1 = random_points[i];
  for(j = i + 1; j < number_of_points; j++)
  {
    p2 = random_points[j];

    double sum_of_squares = 0;
    for(d = 0; d < DIM_; d++)
      sum_of_squares += (p2[d] - p1[d]) …

我想在日期对象上做一个df.apply,但它太慢了!

我的修剪输出给....

 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
  1999   14.563    0.007   14.563    0.007 {pandas.tslib.array_to_timedelta64}
 13998    0.103    0.000   15.221    0.001 series.py:126(__init__)
  9999    0.093    0.000    0.093    0.000 {method 'reduce' of 'numpy.ufunc' objects}
272012    0.093    0.000    0.125    0.000 {isinstance}
  5997    0.089    0.000    0.196    0.000 common.py:199(_isnull_ndarraylike)

所以基本上它是一个2000长度阵列的14秒.我的实际数组大小> 100,000,转换为运行时间> 15分钟或更长.

调用这个函数"pandas.tslib.array_to_timedelta64"这是一个瓶颈,这是熊猫的愚蠢行为吗？我真的不明白为什么这个函数调用是必要的??? 减法中的运算符都具有相同的数据类型.我明确地使用pd.to_datetime()方法转换它们.并且此计算中不包括此转换时间.

所以你可以理解我对这个可怜代码的沮丧!

实际代码看起来像这样

 df  = pd.DataFrame(bet_endtimes)

def testing():
    close_indices = df.apply(lambda x: np.argmin(np.abs(currentdata['date'] - x[0])),axis=1)
    print close_indices

 %prun testing()