Шрифт:
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 значений. Необходимо отметить, что на результаты может влиять загруженность компьютера, на котором проводятся испытания.
Оптимизация
Основная реализация языка Python пока что не имеет оптимизирующего компилятора, поэтому разговор об оптимизации касается только оптимизации кода самим программистом. В любом языке программирования имеются свои характерные приемы оптимизации кода. Оптимизация (улучшение) кода может происходить в двух (зачастую конкурирующих) направлениях: скорость и занимаемая память. В условиях достатка оперативной памяти приложения обычно оптимизируют по скорости. При оптимизации по времени программы для одноразового вычисления следует иметь в виду, что в общее время решения задачи входит не только выполнение программы, но и время ее написания. Не стоит тратить усилия на оптимизацию программы, если она будет использоваться очень редко.
Следует учитывать, что программа, реализующая некоторый алгоритм, не может быть оптимизирована до бесконечно малого времени вычисления: используемый алгоритм имеет определенную временную сложность и программу, основанную на слишком сложном алгоритме, существенно оптимизировать не удастся. Можно попытаться сменить алгоритм (хотя многие задачи этого сделать не позволяют) или ослабить требования к решениям. Иногда помогает упрощение алгоритма. К сожалению, оптимизация кода, как и программирование — задача неформальная, поэтому умение оптимизировать код приходит с опытом.