python замер времени выполнения участка кода

Как можно засечь время выполнения каждой из функций и суммарное время выполнения программы

Есть код с тремя сотрировками, есть отчет о времени выполнения программы. Как можно засечь время выполнения каждой из функций и суммарное время выполнения программы. Еще, если не сложно, посоветуйте как сократить программу.

4 ответа 4

Чтобы измерить время выполнения программы, можно time команду использовать (часто встроена в shell):

Чтобы посмотреть сколько времени индивидуальные функции занимают, можно cProfile модуль использовать:

В графическом виде результаты удобно в KCachegrind просматривать. Пример команд. Больше вариантов: How can you profile a script?

line_profiler позволяет построчно сравнение производить.

Содержание:

timeit

Чтобы измерить производительность отдельной функции, можно timeit модуль использовать:

Тот же интерфейс предоставляет pyperf модуль (помимо прочего):

Для интерактивной работы можно %timeit magic в ipython/jupyter notebook использовать.

reporttime.py

Оптимизируя выполнение функции, стоит убедиться что она работает корректно (тесты), что изменения действительно ускорили её работу (сравнение производительности). Для этого можно pytest-benchmark использовать.

Результаты

Таблица показывает, что на уже отсортированном вводе sorted_insertion() функция заметно выигрывает (в этом случае линейное время для этой функции требуется по сравнению с квадратичным для sorted_selection() и sorted_bubble() ). Для случайного ввода, производительность примерно одинаковая. sorted_bubble() хуже во всех вариантах.

make-figures.py

Чтобы нарисовать время выполнения функций для разных вводов:

Результаты

Рисунки подтверждают, что sorted_insertion() показывает линейное поведение на отсортированном вводе ( seq_range =0,1,2,3,4. n-1 ). И квадратичное на случайном вводе ( seq_random ). Коэффициент перед log2(N) показывает приближённо соответствующую степень в функции роста алгоритма в зависимости от размера ввода:

reporttime + pandas

Собрав результаты измерений времени выполнения функций сортировки из daedra.py ( sorted_*() ) для разных типов (уже отсортированный/случайный) и размеров ввода (длины от 1 до 100000):

Удобно исследовать результаты интерактивно, используя pandas.DataFrame :

К примеру, чтобы сравнить поведение функций на уже отсортированном вводе:

Поведение на случайном вводе:

Или сравнить поведение одной функции для разных типов ввода на одном графике:

Источник

timeit – время выполнения небольших фрагментов кода Python.

Время выполнения небольших фрагментов кода Python.

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

Содержание модуля

Метод timeit () запускает оператор настройки один раз, затем повторно выполняет основной оператор и возвращает количество прошедшего времени. Аргумент timeit () определяет, сколько раз запускать оператор; по умолчанию – 1000000.

Базовый пример

timeit () выполняет оператор установки один раз, затем вызывает основной оператор count раз. Он возвращает одно значение с плавающей запятой, представляющее совокупное количество времени, затраченного на выполнение основного оператора.

Сохранение значений в словаре

В этом более сложном примере сравнивается количество времени, которое требуется для заполнения словаря большим количеством значений с использованием различных методов. Во-первых, для настройки Timer необходимо несколько констант. Переменная setup_statement инициализирует список кортежей, содержащих строки и целые числа, которые будут использоваться основными операторами для создания словарей, используя строки в качестве ключей и сохраняя целые числа в качестве связанных значений.

Служебная функция show_results () предназначена для печати результатов в удобном формате. Метод timeit () возвращает количество времени, необходимое для повторного выполнения оператора. Вывод show_results () преобразует это в количество времени, которое требуется на одну итерацию, а затем дополнительно уменьшает значение до среднего количества времени, необходимого для сохранения одного элемента в словаре.

Первый аргумент Timer – это многострочная строка с сохраненными пробелами для обеспечения правильного анализа при запуске. Второй аргумент – это константа, установленная для инициализации списка значений и словаря.

Этот метод добавляет значение, только если возникает исключение KeyError при поиске существующего значения.

И последний метод использует « in », чтобы определить, есть ли в словаре конкретный ключ.

При запуске скрипт выдает следующий результат.

Из командной строки

В дополнение к программному интерфейсу timeit предоставляет интерфейс командной строки для тестирования модулей без инструментов.

Например, чтобы получить помощь:

Также можно определить функцию с более сложным кодом, а затем вызвать функцию из командной строки.

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

Источник

Как получить время выполнения программы Python?

У меня есть программа командной строки в Python, который занимает некоторое время, чтобы закончить. Я хочу знать точное время, которое нужно, чтобы закончить бег.

и timeit module, но, похоже, это только для небольших фрагментов кода. Я хочу засечь время всей программы.

24 ответов

самый простой способ в Python:

это предполагает, что ваша программа занимает по крайней мере десятую часть секунды для запуска.

Я положил это timing.py модуль в свои

time.clock() возвращает процессорное время, что позволяет рассчитать только время, используемое этим процессом (в Unix в любом случае). В документации говорится:»в любом случае, это функция для использования для бенчмаркинга Python или алгоритмов синхронизации»

Мне очень нравится ответ пола Макгира, но я использую Python3. Итак, для тех, кому интересно: вот модификация его ответа, которая работает с Python 3 на *nix (я полагаю, под Windows, что часы () должны использоваться вместо time ()):

Если вы считаете это полезным, вы все равно должны проголосовать за его ответ вместо этого, так как он сделал большую часть работы ;).

вы можете использовать профайл python profiler для измерения процессорного времени и дополнительно, сколько времени тратится внутри каждой функции и сколько раз вызывается каждая функция. Это очень полезно, если вы хотите улучшить производительность вашего скрипта, не зная, с чего начать. ответ к другому вопросу SO довольно хорошо. Всегда хорошо посмотреть в документы тоже.

вот пример того, как профилировать скрипт с помощью cProfile из командной строки:

мне нравится вывод datetime модуль обеспечивает, где объекты перепада времени показывают дни, часы, минуты etc. по мере необходимости в удобочитаемом виде.

пример вывода, например

обновление:

еще лучше для Linux: /usr/bin/time

решение rogeriopvl отлично работает, но если вам нужна более конкретная информация, вы можете использовать встроенный профилировщик python. Проверьте эту страницу:

профилировщик говорит вам много полезной информации, такой как время, проведенное в каждой функции

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

он работает your_module.main() функция один раз и печать прошедшего времени с помощью в качестве таймера.

для измерения времени процессора (например, не включают время time.sleep() ) для каждой функции вы можете использовать profile модуль ( cProfile на Python 2):

Ipython «timeit» любой скрипт:

времени.clock()

времени.perf_counter()

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

времени.process_time()

возвращает значение (в дробных секундах) суммы системы и время использования процессора для текущего процесса. Это не включить времени во время сна.

Просто Использовать timeit модуль. Он работает как с Python 2, так и с Python 3

он возвращается через несколько секунд, и Вы можете иметь время выполнения. Просто, но вы должны написать их в основной функции, которая запускает выполнение программы. Если вы хотите получить время выполнения, даже если вы получаете ошибку, то возьмите свой параметр «Start» и вычислите его как

есть timeit модуль, который может использоваться для времени выполнения кодов python. Он имеет подробную документацию и примеры в документах python (https://docs.python.org/2/library/timeit.html)

Мне тоже нравится ответ пола Макгира и придумал форму контекстного менеджера, которая больше соответствовала моим потребностям.

это ответ пола Макгира, который работает для меня. На случай, если у кого-то возникнут проблемы с управлением.

вызов timing.main() из вашей программы после импорта файла.

Timeit-класс в python, используемый для вычисления времени выполнения небольших блоков кода.

Default_timer-это метод в этом классе, который используется для измерения времени настенных часов, а не времени выполнения процессора. Таким образом, этому может помешать другое выполнение процесса. Таким образом, он полезен для небольших блоков кода.

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

line_profiler будет профилировать время выполнения отдельных строк кода. Профилировщик реализован в C через Cython, чтобы уменьшить накладные расходы на профилирование.

для людей данных, использующих Jupyter Notebooks

в ячейку, вы можете использовать Jupyter это %%time волшебная команда для измерения времени выполнения:

выход
Время процессора: пользователь 4.54 ms, sys: 0 ns, всего: 4.54 ms
Время стены: 4,12 МС

это будет захватывать только время выполнения конкретной ячейки. Если вы хотите записать время выполнения всего ноутбука (т. е. программы), вы можете создать новый ноутбук в тот же каталог и в новом ноутбуке выполните все ячейки:

выход
IPython тайминги процессора (оценочные): Пользователь: 0.00 s.
Система: 0.00 s.
Время стены: 0.00 s.

использовать обновленный ответ metakermit для python 2.7 вам потребуется монотонная.

код будет выглядеть следующим образом:

время выполнения программы Python может быть несовместимым в зависимости от:

Это потому, что наиболее эффективным способом является использование «Порядок роста» и выучите большую нотацию «о», Чтобы сделать это правильно,https://en.wikipedia.org/wiki/Big_O_notation

в любом случае вы можете попытаться оценить производительность любой программы Python в конкретных шагах подсчета машин в секунду, используя этот простой алгоритм: адаптируйте это к программе, которую вы хотите оценить

надеюсь, это поможет вам.

я использовал очень простую функцию для синхронизации части выполнения кода:

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

тогда выход будет выглядеть так:

Я чувствую себя немного элегантной таким образом.

Источник

timeit — Измерение времени выполнения небольших фрагментов кода¶

Исходный код: Lib/timeit.py

Основные примеры¶

В следующем примере показано, как можно использовать интерфейс командной строки для сравнения трёх различных выражений:

Этого можно было достичь за счёт python интерфейса

Вызываемый также может быть передан из python интерфейса :

Однако timeit() автоматически определяет количество повторений только при использовании интерфейса командной строки. В разделе Примеры приведены дополнительные примеры.

Python Интерфейс¶

Модуль определяет три удобные функции и публичный класс:

Создать Timer сущность с переданным оператором, setup кодом и timer функцией с последующим запуском её методом timeit() с number выполнений. Необязательный аргумент globals указывает пространство имён для выполнения кода.

Изменено в версии 3.5: Добавлен необязательный параметр globals.

Создать Timer сущность с переданным оператором, setup кодом и timer функцией с последующим запуском её методом repeat() с заданным repeat счётчиком и number выполнений. Необязательный аргумент globals указывает пространство имён для выполнения кода.

Изменено в версии 3.5: Добавлен необязательный параметр globals.

Изменено в версии 3.7: По умолчанию значение repeat изменено с 3 на 5.

Изменено в версии 3.3: time.perf_counter() теперь является таймером по умолчанию.

Класс для замеров скорости выполнения небольших фрагментов кода.

Конструктор принимает оператор для синхронизации, дополнительный оператор используемый для настройки и функцию таймера. Оба оператора по умолчанию — ‘pass’ ; функция таймера зависит от платформы (см. doc string модуля). stmt и setup могут также содержать несколько операторов, разделенных ; или новыми строками, если они не содержат многострочных строковых литералов. По умолчанию оператор будет выполняться в пространстве имён timeit; этим поведением можно управлять путём передачи пространства имён в globals.

Время выполнения setup исключается из общего времени выполнения.

Изменено в версии 3.5: Добавлен необязательный параметр globals.

Время number выполнений основного оператора. При этом оператор установки выполняется один раз, а затем возвращает время, необходимое для выполнения основного оператора, несколько раз, измеренное в секундах как float. Аргумент — это число раз в цикле, по умолчанию равное одному миллиону. Главный оператор, оператор установки и используемая функция таймера передаются конструктору.

По умолчанию timeit() временно отключает сборщик мусора во время синхронизации. Преимущество этого подхода в том, что он делает независимые тайминги более сопоставимыми. Недостатком является то, что GC может быть важным компонентом эффективности измеряемой функции. Если это так, GC может быть повторно включен в качестве первого оператора в setup строке. Например:

Это удобная функция, которая вызывает timeit() повторно, так что общее время >= 0.2 секунды, возвращая возможное (количество циклов, время, занятое для этого числа циклов). Она вызывает timeit() с возрастающими числами из последовательности 1, 2, 5, 10, 20, 50, … пока время не составит не менее 0.2 секунды.

Добавлено в версии 3.6.

Вызов timeit() несколько раз.

Соблазнительно вычислить среднее и стандартное отклонение от вектора результата и сообщить об этом. Однако это не очень полезно. В типовом случае самое низкое значение даёт нижнюю границу для того, как быстро машина может запустить данный фрагмент код; более высокие значения вектора результата обычно вызваны не изменчивостью скорости Python’а, а другими процессами, мешающими точности синхронизации. Так что min() результата, наверное, единственное число, которое вас должно заинтересовать. После этого следует посмотреть на весь вектор и применить здравый смысл, а не статистику.

Изменено в версии 3.7: Значение repeat по умолчанию изменено с 3 на 5.

Помощник для печати трейсбэка из замеряемого кода.

Интерфейс командной строки¶

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

Далее приводится объяснение назначений опций:

сколько раз выполнить „statement“

сколько раз повторять таймер (по умолчанию 5)

оператор для выполнения один раз изначально (по умолчанию pass )

Добавлено в версии 3.3.

определяют единицу времени для вывода таймера; можно выбрать nsec, usec, msec или sec

Добавлено в версии 3.5.

печать необработанных результатов замеров; повтор для большей точности цифр

распечатать короткое сообщение об использовании и выйти из программы

Есть определенные базовые накладные расходы, связанные с выполнением оператора pass. Здесь код не пытается скрыть, но вы должны знать об этом. Базовые издержки могут быть измерены путём вызова программы без аргументов, и они могут отличаться между Python версиями.

Примеры¶

Можно предоставить оператор настройки, который выполняется только один раз в начале:

Источник

Функции тайминга Python: три способа контролировать ваш код

Хотя многие разработчики признают Python эффективным языком программирования, программы на чистом Python могут работать медленнее, чем их аналоги на скомпилированных языках, таких как C, Rust и Java. В этом руководстве вы узнаете, как использовать таймеры Python для отслеживания скорости выполнения ваших программ.

В этом уроке вы узнаете, как использовать:

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

Таймеры Python

Во-первых, оснакомьтесь с некоторыми примерами кода, которые вы будете использовать на протяжении всего урока. Позже вы добавите в этот код таймер Python, для мониторинга его производительность. Вы также увидите некоторые из самых простых способов измерения времени выполнения этого примера.

Функции таймера Python

Если вы посмотрите на встроенный модуль time в Python, то заметите несколько функций, которые могут измерять время:

Возвращает значение (в долях секунд) счетчика производительности, то есть часов с самым высоким доступным разрешением для измерения короткого промежутка времени.

Во-первых, вы будете использовать perf_counter() для создания таймера Python. Позже вы сравните это с другими функциями таймера Python и узнаете, почему perf_counter() обычно является лучшим выбором.

Пример: Последовательность Фибоначчи

Чтобы лучше сравнить различные способы добавления таймера Python к своему коду, вы будете применять разные функции таймера Python к одному и тому же примеру кода в этом руководстве. Если у вас уже есть код, который вы хотели бы измерить, смело следуйте этим примерам.

Вычисление n-го числа ряда Фибоначчи с помощью цикла while:

Ваш первый таймер Python

Теперь вы можете добавить таймер Python к коду примера:

Обратите внимание, что perf_counter() вызывается как до, так и после вычисления значения функции. Затем печатается время, необходимое для вычисления, вычисляя разницу между двумя вызовами.

f-строки доступны только в Python 3.6 и более поздних версиях. Для получения дополнительной информации ознакомьтесь с официальной документацией Python 3.

Теперь, когда вы запустите пример, вы увидите потраченное время на вычисления:

Вы рассмотрели основы тайминга своего кода Python. В оставшейся части руководства вы узнаете, как можно обернуть Python-таймер в класс, менеджер контекста и декоратор, чтобы сделать его более консистентным и удобным в использовании.

Python класс Timer

В этом руководстве вы создадите и обновите класс Timer, который вы можете использовать для определения таймингов кода несколькими различными способами. Окончательный код также доступен в PyPI под названием codetiming. Вы можете установить в вашу систему следующим образом:

Понимание классов в Python

Создание класса таймера Python

Здесь происходит несколько разных вещей, поэтому давайте пройдемся по коду шаг за шагом.

Использование класса Timer :

Сравните это с предыдущим примером, где вы использовали perf_counter() напрямую. Структура кода довольно похожа, но теперь код стал более понятным, и это является одним из преимуществ использования классов. Тщательно выбирая имена классов, методов и атрибутов, вы можете сделать свой код очень информативным!

Использование класса Timer Python

Обратите внимание, что код очень похож на то, что вы видели ранее. В дополнение к тому, чтобы сделать код более читабельным, Timer заботится о печати прошедшего времени на консоль, что делает логгирование затраченного времени более последовательным. Когда вы запустите код, вы увидите примерно такой же вывод:

Печать прошедшего времени из Timer может быть последовательной, но, похоже, этот подход не очень гибкий. В следующем разделе вы увидите, как настроить свой класс.

Добавление большего удобства и гибкости

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

После обновления timer.py вы можете изменить текст следующим образом:

Вот два примера, которые показывают новую функциональность в действии:

Когда вы запускаете эти примеры в интерактивной оболочке, Python автоматически печатает возвращаемое значение.

Одна тонкая проблема с этим кодом заключается в том, что вы измеряете не только время, необходимое для вычисления элемента последовательности, но и время, которое Python тратит на печать результатов на экран. Это может быть не так важно, поскольку время, потраченное на печать, должно быть незначительным по сравнению со временем, потраченным на вычисления. Тем не менее, было бы хорошо иметь возможность точно определить время.

Переменные класса могут быть доступны либо непосредственно в классе, либо через экземпляр класса:

В обоих случаях код возвращает один и тот же пустой словарь классов.

Затем добавим дополнительные имена к вашему таймеру Python. Вы можете использовать имя для двух разных целей:

Теперь вернёмся к series_numbers.py и убедиться, что измеряется только время, потраченное на вычисления:

Повторный запуск сценария даст такой же результат, как и раньше, хотя сейчас измеряется только фактическое время вычислений:

Последняя строка является способом, которым Python представляет объекты по умолчанию. Хотя вы можете почерпнуть из него некоторую информацию, она обычно не очень полезна. Вместо этого было бы неплохо увидеть такие вещи, как имя Timer или как он будет сообщать о времени.

В Python 3.7 классы данных были добавлены в стандартную библиотеку. Они обеспечивают несколько удобств для ваших классов, включая более информативную строку представления.

Вот несколько заметок о классе данных Timer :

Новый класс данных Timer работает так же, как ваш предыдущий обычный класс, за исключением того, что теперь он имеет хорошее представление:

Прежде чем закончить этот раздел, давайте взглянем на полный исходный код Timer в его нынешнем виде. Вы заметите добавление подсказок типа к коду для дополнительной документации:

Использование класса для создания таймера, Python предлагает несколько преимуществ:

Класс очень гибкий, и вы можете использовать его практически в любой ситуации, когда вы хотите отслеживать время, необходимое для выполнения кода. Тем не менее, в следующих разделах вы узнаете об использовании менеджеров контекста и декораторов, которые будут более удобными для замеров блоков кода и функций.

Менеджер контекста Python Timer

Python класс Timer прошел долгий путь! По сравнению с первым созданным таймером Python код стал достаточно мощным. Тем не менее, для использования таймера все еще есть немного стандартного кода:

Понимание контекстных менеджеров в Python

Менеджеры контекста были частью Python в течение долгого времени. Они были представлены PEP 343 в 2005 году и впервые реализованы в Python 2.5. Вы можете распознать контекстные менеджеры в коде с помощью ключевого слова with :

Наиболее распространенное использование контекстных менеджеров, вероятно, обработка различных ресурсов, такие как файлы, блокировки и соединения с базой данных. Затем менеджер контекста используется для освобождения и очистки ресурса после его использования. В следующем примере раскрывается фундаментальная структура timer.py путем печати только строк, содержащих двоеточие. Что еще более важно, он показывает общую идиому для открытия файла в Python:

Что это значит, что fp является контекстным менеджером? Технически это означает, что fp реализует протокол менеджера контекста. В основе языка Python лежит много разных протоколов. Вы можете думать о протоколе как о контракте, в котором указано, какие конкретные методы должен реализовывать ваш код.

Протокол менеджера контекста состоит из двух методов:

Вы можете увидеть, что «See you later, Rascal» печатается, даже если в коде есть ошибка.

Теперь вы знаете, что такое контекстные менеджеры и как вы можете создать свой собственный. Если вы хотите погрузиться глубже, то посмотрите contextlib в стандартной библиотеке. Он включает в себя удобные способы определения новых контекстных менеджеров, а также готовые контекстные менеджеры, которые можно использовать для закрытия объектов, устранения ошибок или даже бездействия!

Создание менеджера контекста Python Timer

Вы также должны отметить еще две тонкие детали:

Использование менеджера контекста Python Timer

Давайте посмотрим, как использовать менеджер контекста Timer для определения времени вычисления числа Фибоначчи. Вспомните, как вы использовали Timer ранее:

Запуск скрипта должен дать знакомый результат:

Есть несколько преимуществ для добавления возможностей менеджера контекста к вашему классу таймера Python:

Python Timer декоратор

Ваш класс Timer теперь очень универсален. Однако есть один вариант использования, где он может быть еще более упорядоченным. Скажем, вы хотите отслеживать время, проведенное внутри одной данной функции в вашей кодовой базе. Используя контекстный менеджер, у вас есть два основных варианта:

1. Используйте Timer каждый раз, когда вы вызываете функцию:

Если вы вызовете do_something() во многих местах, это станет громоздко и сложно в обслуживании.

2. Обернём код функцией содержащей внутри контекстный менеджер:

Понимание декораторов в Python

В качестве первого примера создадим декоратор, который ничего не делает:

Вместо этого create_multiplier() используется для создания новых функций умножения, каждая из которых основана на различном factor :

Символ @ используется для применения декораторов. В этом случае @triple означает, что triple() применяется к функции, определенной сразу после нее.

Иногда декорированные функции должны иметь правильные метаданные. @functools.wraps исправляют именно эту проблему:

С новым определением @triple метаданные сохраняются:

Обратите внимание, что knock() теперь сохраняет свое собственное имя, даже после того, как был декорирован. Это хорошая форма, чтобы использовать @functools.wraps всякий раз, когда вы определяете декоратор. Схема, которую вы можете использовать для большинства ваших декораторов, выглядит следующим образом:

Создание декоратора Timer Python

В этом разделе вы узнаете, как расширить свой таймер Python, чтобы вы также могли использовать его в качестве декоратора. Однако в качестве первого упражнения давайте создадим Python декоратор Timer с нуля.

Основываясь на приведенной выше схеме, вам нужно только решить, что делать до и после вызова декорированной функции. Это похоже на соображения о том, что делать при входе и выходе из контекстного менеджера. Вы хотите запустить таймер Python перед вызовом декорированной функции и остановить таймер Python после завершения вызова. Декоратор @timer может быть определен следующим образом:

Обратите внимание, насколько wrapper_timer() напоминает ранний шаблон, установленный вами для замеров кода Python. Вы можете применить @timer следующим образом:

Напомним, что вы также можете применить декоратор к ранее определенной функции:

Поскольку @ применяется при определении функций, в этих случаях необходимо использовать более простую форму. Одно из преимуществ использования декоратора заключается в том, что вам нужно применить его только один раз, и он будет каждый раз определять время выполнения функции:

@timer делает свою работу. Тем не менее, в некотором смысле вы вернулись к исходной точке, поскольку @timer не обладает никакой гибкостью или удобством Timer. Можете ли вы также заставить свой класс Timer действовать как декоратор?

Здесь square-это экземпляр, который может быть вызван и может содержать квадрат числа, точно так же, как функция square() в первом примере.

Это дает вам возможность добавить возможности декоратора к существующему классу таймера:

Теперь вы можете использовать Timer в качестве декоратора:

Прежде чем завершить этот раздел, знайте, что есть более простой способ превратить ваш таймер Python в декоратор. Вы уже видели некоторые сходства между контекстными менеджерами и декораторами. Они оба обычно используются для выполнения чего-то до и после выполнения некоторого заданного кода.

Использование декоратора таймера Python

Если вы сравните эту реализацию с оригинальной реализацией без какого-либо времени, то заметите, что единственными различиями являются импорт Timer в строке 3 и применение @Timer() в строке 6. Существенным преимуществом использования декораторов является то, что они обычно просты в применении, как вы видите.

Тем не менее, декоратор по-прежнему относится ко всей функции. Это означает, что ваш код учитывает время, необходимое для печати результата. Давайте запустим сценарий в последний раз:

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

При использовании таймера в качестве декоратора вы увидите те же преимущества, что и при использовании контекстных менеджеров:

Однако декораторы не так гибки, как контекстные менеджеры. Вы можете применять их только для выполнения функций. Можно добавить декораторы к уже определенным функциям, но это немного неуклюже и менее распространено.

Код Timer Python

Вы можете использовать код самостоятельно, сохранив его в файле с именем timer.py и импортировать его в вашу программу. Запустим новый таймер в качестве менеджера контекста:

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

Другие функции таймеры в Python

Существует множество вариантов замеров выполнения вашего кода Python. В этом уроке вы узнаете, как создать гибкий и удобный класс, который можно использовать несколькими различными способами. Быстрый поиск по PyPI показывает, что уже существует множество проектов, предлагающих решения тайминга Python.

В этом разделе вы сначала узнаете больше о различных функциях, доступных в стандартной библиотеке для измерения времени, и о том, почему perf_counter() предпочтительнее. Затем вы увидите альтернативы оптимизации вашего кода, для которых таймер не очень хорошо подходит.

Использование альтернативных функций таймеров в Python

Вы использовали perf_counter() на протяжении всего этого урока для выполнения фактических измерений времени, но библиотека time Python поставляется с несколькими другими функциями, которые также измеряют время. Вот некоторые альтернативы:

Одна из причин, почему существует несколько функций, заключается в том, что Python представляет время как float. Числа с плавающей запятой по своей природе неточны. Возможно, вы уже видели подобные результаты раньше:

Float Python следует стандарту IEEE 754 для арифметики с плавающей запятой, который пытается представить все числа с плавающей запятой в 64 битах. Поскольку существует бесконечно много чисел с плавающей запятой, вы не можете выразить их в виде конечного числа битов.

IEEE 754 предписывает систему, в которой плотность чисел, которые вы можете представить, изменяется. Чем ближе вы к 1, тем больше чисел вы можете представить. Для больших чисел есть больше пространства между числами, которые вы можете выразить. Это имеет некоторые последствия, когда вы используете float для представления времени.

Здесь вы видите, что добавление наносекундного числа на самом деле влияет на результат.

Поскольку perf_counter() уже обеспечивает наносекундное разрешение, у использования perf_counter() меньше преимуществ.

Примечание: perf_counter_ns() доступен только в Python 3.7 и более поздних версиях. В этом уроке вы использовали perf_counter() в своем классе Timer. Таким образом, таймер можно использовать и в более старых версиях Python. Для получения дополнительной информации о функциях _ns в time ознакомьтесь с новыми классными функциями в Python 3.7.

Результаты могут быть разными в вашей системе.

PIP 418 описывает некоторые обоснования введения этих функций. Она включает в себя следующие краткие описания:

Как вы можете видеть, обычно это лучший выбор для вас, чтобы использовать perf_counter() для вашего таймера Python.

Оценка времени работы со временем timeit

Допустим, нужно выжать из кода последний бит производительности и задаетесь вопросом о наиболее эффективном способе преобразования списка в множество. Вы хотите сравнить, использование set() и литерал множества <. >. Для этого вы можете использовать свой таймер Python:

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

Лучше всего воспользоваться стандартной библиотекой. Она предназначен именно для измерения времени выполнения небольших фрагментов кода. Для этого импортируем и вызовем timeit.timeit() из Python как обычную функцию в интерфейсе командной строки. Вы можете рассчитать эти два варианта следующим образом:

Примечание: будьте осторожны, когда вы используете timeit на коде, который может загружать файлы или получать доступ к базам данных. Поскольку время от времени он автоматически вызывает вашу программу несколько раз, вы можете непреднамеренно в конечном итоге заспамить сервер запросами!

Наконец, интерактивная оболочка IPython и Jupyter notebook имеют дополнительную поддержку этой функции с помощью команды %timeit magic :

Опять же, измерения показывают, что использование литерала множества происходит быстрее.

Поиск узких мест в коде с помощью профилирования

timeit отлично подходит для бенчмаркинга конкретного фрагмента кода. Однако было бы очень громоздко использовать его для проверки всех частей вашей программы и определения того, какие разделы занимают больше всего времени. Вместо этого можно использовать профилировщик.

Этот вывод показывает, что общее время выполнения составило 0.002 секунды. В нем также перечислены десять функций, на которые ваш код потратил большую часть своего времени. Здесь вы отсортированы по кумулятивному времени (cumtime), что означает, что ваш код считает время, когда данная функция вызвала другую функцию.

Столбец общее время (tottime) показывает, сколько времени ваш код провел внутри функции, исключая время в подфункциях. Вы можете видеть, что ни одна из вышеперечисленных функций на самом деле не тратит на это никакого времени. Чтобы найти, где код провел большую часть своего времени, выполните другую команду sort :

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

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

Примечание: Вы также можете профилировать потребление памяти вашего кода. Это выходит за рамки данного руководства. Однако вы можете взглянуть на memory-profiler, если вам нужно контролировать потребление памяти вашими программами.

Обратите внимание, что line_profiler требует времени и добавляет изрядную часть накладных расходов к вашей среде выполнения. Более стандартный рабочий процесс заключается в том, чтобы сначала использовать cProfile для определения того, какие функции нужно просмотреть, а затем запустить line_profiler для этих функций. line_profiler не является частью стандартной библиотеки, поэтому вы должны сначала следовать инструкциям по установке, чтобы настроить его.

Перед запуском профилировщика необходимо указать ему, какие функции следует профилировать. Это выполняется, добавлением декоратора @profile в свой исходный код. Например, для профилирования Timer.stop() вы добавляете следующее в timer.py :

Вывод

В этом руководстве вы увидели несколько разных подходов к добавлению таймера Python в свой код:

Теперь вы можете добавить функции Timer Python в свой собственный код! Отслеживание скорости выполнения вашей программы в журналах поможет вам отслеживать ваши сценарии.

Источник