Профайлер.

Для определения мест в программе, на выполнение которых уходит значительная часть времени, обычно применяется профайлер.

Модуль profile.

Этот модуль позволяет проанализировать работу функции и выдать статистику использования процессорного времени на выполнение той или иной части алгоритма.

В качестве примера можно рассмотреть профилирование функции для поиска строк из списка, наиболее похожих на данную. Для того чтобы качественно профилировать функцию difflib.get_close_matches(), нужен большой объем данных. В файле russian.txt собрано 160 тысяч слов русского языка. Следующая программа поможет профилировать функцию difflib.get_close_matches():

Import difflib, profile.

Def print_close_matches(word):

 print "\n".join(difflib.get_close_matches(word + "\n", open("russian.txt"))).

Profile.run(r'print_close_matches("профайлер")').

При запуске этой программы будет выдано примерно следующее:

Провайдер.

Трайлер.

Бройлер.

899769 function calls (877642 primitive calls) in 23.620 CPU seconds.

Ordered by: standard name.

    ncalls tottime percall cumtime percall filename:lineno(function).

         1   0.000   0.000  23.610  23.610 <string>:1(?).

         1   0.000   0.000  23.610  23.610 T.py:6(print_close_matches).

         1   0.000   0.000   0.000   0.000 difflib.py:147(__init__).

         1   0.000   0.000   0.000   0.000 difflib.py:210(set_seqs).

    159443   1.420   0.000   1.420   0.000 difflib.py:222(set_seq1).

         2   0.000   0.000   0.000   0.000 difflib.py:248(set_seq2).

         2   0.000   0.000   0.000   0.000 difflib.py:293(__chain_b).

    324261   2.240   0.000   2.240   0.000 difflib.py:32(_calculate_ratio).

     28317   1.590   0.000   1.590   0.000 difflib.py:344(find_longest_match).

      6474   0.100   0.000   2.690   0.000 difflib.py:454(get_matching_blocks).

28317/6190   1.000   0.000   2.590   0.000 difflib.py:480(__helper).

      6474   0.450   0.000   3.480   0.001 difflib.py:595(ratio).

     28686   0.240   0.000   0.240   0.000 difflib.py:617(<lambda>).

    158345   8.690   0.000   9.760   0.000 difflib.py:621(quick_ratio).

    159442   2.950   0.000   4.020   0.000 difflib.py:650(real_quick_ratio).

         1   4.930   4.930  23.610  23.610 difflib.py:662(get_close_matches).

         1   0.010   0.010  23.620  23.620 profile:0(print_close_matches("профайлер")).

         0   0.000   0.000                 profile:0(profiler).

Здесь колонки таблицы показывают следующие значения: ncalls — количество вызовов (функции), tottime — время выполнения кода функции (не включая времени выполнения вызываемых из нее функций), percall — то же время, в пересчете на один вызов, cumtime — суммарное время выполнения функции (и всех вызываемых из нее функций), filename — имя файла, lineno — номер строки в файле, function — имя функции (если эти параметры известны).

Из приведенной статистики следует, что наибольшие усилия по оптимизации кода необходимо приложить в функциях quick_ratio() (на нее потрачено 8,69 секунд), get_close_matches() (4,93 секунд), затем можно заняться real_quick_ratio() (2,95 секунд) и _calculate_ratio() (секунд).

Это лишь самый простой вариант использования профайлера: модуль profile (и связанный с ним pstats) позволяет получать и обрабатывать статистику: их применение описано в документации.

Модуль timeit.

Предположим, что проводится оптимизация небольшого участка кода. Необходимо определить, какой из вариантов кода является наиболее быстрым. Это можно сделать с помощью модуля timeit.

В следующей программе используется метод timeit() для измерения времени, необходимого для вычисления небольшого фрагмента кода. Измерения проводятся для трех вариантов кода, делающих одно и то же: конкатенирующих десять тысяч строк в одну строку. В первом случае используется наиболее естественный, «лобовой» прием инкрементной конкатенации, во втором — накопление строк в списке с последующим объединением в одну строку, в третьем применяется списковое включение, а затем объединение элементов списка в одну строку:

From timeit import Timer.

T = Timer(""".

Res = "".

For k in range(1000000,1010000):

 res += str(k).

""").

Print t.timeit(200).

T = Timer(""".

Res = [].

For k in range(1000000,1010000):

 res.append(str(k)).

Res = ",".join(res).

""").

Print t.timeit(200).

T = Timer(""".

Res = ",".join([str(k) for k in range(1000000,1010000)]).

""").

Print t.timeit(200).

Разные версии Python дадут различные результаты прогонов:

# Python 2.3.

77.6665899754.

10.1372740269.

9.07727599144.

# Python 2.4.

9.26631307602.

9.8416929245.

7.36629199982.

В старых версиях Python рекомендуемым способом конкатенации большого количества строк являлось накопление их в списке с последующим применением функции join() (кстати, инкрементная конкатенация почти в восемь раз медленнее этого приема). Начиная с версии 2.4, инкрементная конкатенация была оптимизирована и теперь имеет даже лучший результат, чем версия со списками (которая вдобавок требует больше памяти). Но чемпионом все–таки является работа со списковым включением, поэтому свертывание циклов в списковое включение позволяет повысить эффективность кода.

Если требуются более точные результаты, рекомендуется использовать метод repeat(n, k) — он позволяет вызывать timeit(k) n раз, возвращая список из n значений. Необходимо отметить, что на результаты может влиять загруженность компьютера, на котором проводятся испытания.