как узнать скорость выполнения кода на python
Как мне узнать время выполнения программы на Python?
У меня есть программа командной строки на Python, которая требует времени, чтобы закончить. Я хочу знать точное время, необходимое для завершения бега.
27 ответов
Самый простой способ в Python:
Это предполагает, что вашей программе требуется не менее десятой секунды для запуска.
Чтобы использовать обновленный ответ metakermit для Python 2.7, вам потребуется монотонный пакет.
Тогда код будет следующим:
Время выполнения программы Python может быть несогласованным в зависимости от:
Это потому, что наиболее эффективным способом является использование «Порядка роста» и изучение большой нотации «О» сделать это правильно.
В любом случае, вы можете попытаться оценить производительность любой программы Python на конкретном подсчете числа шагов в секунду, используя этот простой алгоритм: адаптируйте это к программе, которую вы хотите оценить
Пример кода выглядит следующим образом:
Вызовите timing.main() из вашей программы после импорта файла.
Вы делаете это просто в Python. Нет необходимости усложнять.
Я использовал очень простую функцию для измерения времени выполнения кода:
И чтобы использовать его, просто вызовите его перед кодом для измерения, чтобы получить синхронизацию функции, а затем вызовите функцию после кода с комментариями. Время появится перед комментариями. Например:
Тогда вывод будет выглядеть так:
Или даже проще (если у вас есть одна функция):
Он заботится о единицах и округлениях. Он работает с Python 3.6 или новее.
Line_profiler профилирует время выполнения отдельных строк кода. Профилировщик реализован в C с помощью Cython, чтобы уменьшить накладные расходы на профилирование.
Результаты будут такими:
Я посмотрел на модуль timeit, но кажется, что он только для небольших фрагментов кода. Я хочу, чтобы время всей программы.
Он запускает функцию your_module.main() один раз и печатает прошедшее время, используя функцию time.time() в качестве таймера.
Чтобы измерить время процессора (например, не включать время в течение time.sleep() ) для каждой функции, вы можете использовать модуль profile ( cProfile в Python 2):
Отслеживаем прогресс выполнения в Python
Индикаторы прогресса (progress bar) — визуальное отображение процесса работы. Они избавляют нас от необходимости беспокоиться о том, не завис ли скрипт, дают интуитивное представление о скорости его выполнения и подсказывают, сколько времени осталось до завершения.
Человек ранее не использовавший индикаторы прогресса может предположить, что их внедрение может сильно усложнить код. К счастью, это не так. Небольшие примеры ниже покажут, как быстро и просто начать отслеживать прогресс в консоли или в интерфейсе быстро набирающей популярность графической библиотеки PySimpleGUI.
Используем Progress
Первым у нас идёт модуль Progress.
Всё, что от вас потребуется, это указать количество ожидаемых итераций, тип индикатора и вызывать функцию при каждой итерации:
Есть индикаторы на любой вкус:
Используем tqdm
Следующей на очереди идёт библиотека tqdm.
Быстрый и расширяемый индикатор прогресса для Python и CLI
Всего один вызов функции понадобится для получения результата аналогичного предыдущему:
Само собой, в комплекте идёт куча настроек и опций.
Используем alive-progress
Ещё один вариант синтаксиса, побольше дефолтных анимаций, чем в предыдущих примерах:
GUI индикатор прогресса для скрипта
Иногда возникает необходимость предоставить конечному пользователю графический индикатор.
Сколько кода нужно, чтобы достигнуть такого результата? Немного:
Индикатор в приложении PySimpleGUI
Рассмотрим реализацию индикатора в PySimpleGUI.
Вот как это сделать:
Заключение
Как видите, нет ничего сложного в добавлении информации о прогрессе выполнения: кода немного, а отзывчивость повышается очень сильно. Используйте индикаторы, чтобы больше никогда не гадать, завис ли процесс или нет!
Как можно засечь время выполнения каждой из функций и суммарное время выполнения программы
Есть код с тремя сотрировками, есть отчет о времени выполнения программы. Как можно засечь время выполнения каждой из функций и суммарное время выполнения программы. Еще, если не сложно, посоветуйте как сократить программу.
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 :
К примеру, чтобы сравнить поведение функций на уже отсортированном вводе:
Поведение на случайном вводе:
Или сравнить поведение одной функции для разных типов ввода на одном графике:
Быстрый тест производительности Python для вычислительных задач
Мотивация
Совсем недавно вышла новая версия 0.34 библиотеки оптимизирующего JIT компилятора Numba для Python. И там ура! появилась долгожданная семантика аннотаций и набор методов для организации параллельных вычислений. За основу была взята технология Intel Parallel Accelerator.
В данной статье я хочу поделиться результатами первого тестирования скорости вычислений на основе этой библиотеки для некоторой современной машины с четырехядерным процессором.
Введение
В настоящее время Python очень активно используется в научных вычислениях, а в области Machine Learning вообще является практически одним из стандартов. Но если посмотреть чуть глубже, то почти везде Python используется как обертка над библиотеками более низкого уровня, написанных большей частью на C/C++. А можно ли на чистом Python писать на самом деле быстрый и параллельный код?
Рассмотрим совсем простую задачу. Пусть нам даны два набора N точек в трехмерном пространстве: p и q. Необходимо вычислить специальную матрицу на основе попарных расстояний между всеми точками:
Для всех тестов возьмем N = 5000. Время вычисления усредняется для 10 запусков.
Реализация на C++
Как точку отсчета возьмем следующую реализацию на C++:
Внешний цикл по точкам p выполняется параллельно с использованием технологии OpenMP.
Время выполнения: 44 мс.
Чистый Python
Начнем тест скорости с кода на чистом Python:
Время выполнения: 52 861 мс, медленнее базовой реализации больше, чем в 1000 раз.
Python интерпретируемый язык, Python использует внутри себя GIL, что делает невозможным параллелизацию на уровне самого кода. Это все очень медленно. Теперь начнем это все ускорять.
Python + NumPy + SciPy
Проблему медленности Python для численных задач осознали очень давно. И ответом на эту проблему была библиотека NumPy. Идеология NumPy во многом близка MatLab, который является общепризнанным инструментом научных расчетов.
Мы прекращаем мыслить итерационно, мы начинаем мыслить матрицами и векторами как атомарными объектами для вычисления. А все операции с матрицам и векторами на нижнем уровне уже выполняются высокопроизводительными библиотеками линейной алгебры Intel MKL или ATLAS.
Реализация на NumPy выглядит так:
В этой реализации вообще нет ни одного цикла!
Время выполнения: 839 мс, что медленнее базовой реализации где-то в 19 раз.
Более того, в NumPy и SciPy есть огромное количество встроенных функций. Реализация данной задачи на SciPy выглядит так:
Время выполнения: 353 мс, что медленнее базовой реализации в 8 раз.
Для большинства задач это уже вполне приемлемое время работы. Ценой этого является переключение способа мышления, теперь необходимо собирать код из базовых операций линейной алгебры. Иногда это выглядит очень красиво, но порой приходится придумывать разные трюки.
Но а как быть с параллельностью? Здесь она неявная. Мы надеемся, что на низком уровне все операции с матрицами и векторами реализованы эффективно и параллельно.
А что делать, если наш код не вписывается в линейную алгебру, или мы хотим явную параллелизацию?
Python + Cython
Что тут происходит? На вход функция принимает python numpy объекты, далее они преобразуются в типизированные Cython С-структуры, а далее отключается gil и при помощи специальной конструкции ‘prange’ внешний цикл выполняется параллельно.
Время выполнения: 76 мс, что в 1.75 раз медленнее, чем базовая реализация.
Ну что, мы почти приблизились к базовой реализации, мы начали писать явный параллельный код. Но ценой этого стал менее читаемый код, мы ушли от чистого Python.
В целом, большинство численных расчетов так и пишутся. Большая часть на NumPy, а некоторые места критичные по быстродействию выносятся в отдельные модули и реализуются на cython.
Python + Numba
Мы проделали длинный путь. Мы начали с чистого Python, потом пошли по пути магии матричных вычислений, потом погрузились в специальных язык расширений. Пора вернуться обратно к тому, с чего мы начали. Итак, реализация на Python + Numba:
Время выполнения: 46 мс, что практически совпадает с базовой реализацией!
И все, что нужно было сделать для этого с исходным медленным Python кодом:
Как получить время выполнения программы 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 в конкретных шагах подсчета машин в секунду, используя этот простой алгоритм: адаптируйте это к программе, которую вы хотите оценить
надеюсь, это поможет вам.
я использовал очень простую функцию для синхронизации части выполнения кода:
и использовать его, просто вызовите его перед кодом для измерения, чтобы получить функцию синхронизации, затем вызовите функцию после кода с комментариями, и время появится перед комментариями, например:
тогда выход будет выглядеть так:
Я чувствую себя немного элегантной таким образом.