Как измерить время выполнения программы в питон

Содержание

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

time() и clock()

Очень долго их было ровно две: time.time() и time.clock() .

Использование предельно простое:

t1 = time.time() # do tested stuff print(time.time() — t1)

Получаем время выполнения кода в секундах.

Две функции нужны для того, чтобы усложнить жизнь программиста. Дело в том, что на Windows точнее работает функция time.clock , а на прочих Unix/Linux — time.time .

Дальнейшее касается Linux и (отчасти) других Posix систем. Все нововведения появятся в грядущем Python 3.3

clock_gettime(clk_id)

Вот уже много лет time.time использует системный вызов gettimeofday(2) на тех ОС, где он доступен (Linux, например). gettimeofday(2) позволяет измерять время с точностью до микросекунд в отличие от посекундного time(2) .

Прогресс не стоит на месте, и появились функции c наносекундным разрешением: time.clock_gettime и time.clock_getres являются тонкими обёртками над одноимёнными Posix вызовами.

Расчёт времени выполнения программы на python #short

Зачем вообще нужны эти наносекунды и почему не хватает микросекундных интервалов?

Вот вполне жизненный пример: мы используем Redis для кеширования. Он работает на той же машине, где и основное приложение. Используются unix sockets и pipelining. В результате время обработки запросов сопоставимо с 1 мс. Если мы хотим знать, какую часть времени приложение тратит на общение с redis — нужно измерять интервалы с более высокой точностью.

clock_gettime возвращает время, а clock_getres показывает, с какой точностью оперирует clock_gettime .

Не вполне ясно, какой тип таймера выбирать. Вот список таймеров, имеющихся в ядре Linux 3:

CLOCK_REALTIME — абсолютное системное время.
CLOCK_MONOTONIC — относительное время.
CLOCK_MONOTONIC_RAW — относительное время без коррекции NTP.
CLOCK_PROCESS_CPUTIME_ID — высокоточный таймер процесса.
CLOCK_THREAD_CPUTIME_ID — высокоточный таймер потока.

Во первых, возвращаемое время может быть абсолютным и относительным. Если по абсолютному времени можно узнать «который час», то относительное годится лишь для измерения интервалов. Относительное время отсчитывается от какой-то точки (для простоты пусть это будет момент включения компьютера), абсолютное традиционно начинается 1 января 1970 года (UNIX Epoch).

Поскольку Питон возвращает результат clock_gettime как float , то наносекундная точность возможна лишь в течении 194 дней от UNIX Epoch timestamp, микросекудная точность «заканчивается» за 272 года. 100 наносекндная точность исчерпывается за 17 лет. Вывод простой: для измерения интервалов с точностью выше микросекунды пригодно только относительное время.

Абсолютное время можно менять путём ручной или автоматизированной (службой NTP) подстройки компьютерных часов. Относительное при этом не изменяется.

На относительное время может оказывать влияние автоматическая коррекция времени (NTP), которая за сутки сдвигает системное время на доли секунды относительно аппаратных компьютерных часов. Когда работаем с наносекундными интервалами — это имеет значение. CLOCK_MONOTONIC_RAW лишён такого недостатка.

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

Широко распространённые однопроцессорные многоядерные системы этим недостатком не страдают. Простой совет: никогда не используете эти таймеры счётчиков процесса, не поняв до конца всех деталей. Для практических целей обычно достаточно менее экзотичных вариантов.

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

time.monotonic() и time.wallclock()

Обычно желание простое: измерить интервал времени с максимально возможной точностью, причём способ не должен зависеть от установленной операционной системы и используемого «железа».

Вот тут и приходят на помощь функции time.monotonic() и time.wallclock() . Они не требуют параметров, работают везде и используют максимально точный из доступных таймеров. Для Windows это clock() , на Linux последовательно перебираются CLOCK_MONOTONIC_RAW , CLOCK_MONOTONIC и CLOCK_REALTIME . Кто первый отзовётся — тот и лучший.

Разница между функциями незначительная: time.wallclock() попытается перейти к таймеру абсолютного времени если не найдет лучший вариант (и никогда не закончится исключением), time.monotonic() выбросит OSError .

Итог

На самом деле, думаю, ни на одной современной системе до крайности не дойдет и можно никогда не ощутить разницу на себе. И всё же time.wallclock() чуть-чуть больше похожа на то «стандартное поведение», которое требуется от функции для измерения временных интервалов. Если вам нужно оценить время выполнения чего-либо — используйте её.

Источник: asvetlov.blogspot.com

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

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

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

ответ

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

import time start_time = time.time() main() print(«— %s seconds —» % (time.time() — start_time))

Это предполагает, что ваша программа берет на менее одной десятой секунды для запуска.

— 0.764891862869 seconds —

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

на Windows, делайте то же самое, но используйте time.clock() вместо времени .время(). Вы получите немного лучшую точность. –

Ответ Павла лучше, см. Http://stackoverflow.com/questions/1557571/how-to-get-time-of-a-python-program-execution/1557906#1557906 – sorin

В Linux или UNIX:

time python yourprogram.py

так, если я запускать другой виджет, пример в QT приложения как вычислить время, затраченное на этот виджет, чтобы показать? –

Для случая виджета, если вы запускаете программу Python, используйте принятый ответ rogeriopvl. – steveha

, но это, кажется, не дает времени в мин: секунды он заканчивается плавающим числом! –

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

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

import time start_time = time.clock() main() print time.clock() — start_time, «seconds»

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

time.time() лучше всего использовать на * nix. time.clock() лучше всего использовать в Windows. –

Я считаю, что это невозможно использовать для вычисления «только времени, используемого этим процессом», потому что оно использует системное время и будет осуществляться другими системными процессами? Исправьте меня, если я ошибаюсь в этом 🙂 – Annan

Примечание: time.clock() является «Устаревшим с версии 3.3: поведение этой функции зависит от платформы: используйте perf_counter() [со временем спал] или process_time() [ без времени спал] вместо этого, в зависимости от ваших требований, чтобы иметь четко определенное поведение ». – mab

Я поставил этот timing.py модуль в мой собственный site-packages каталог, а просто вставить import timing в верхней части моего модуля:

import atexit from time import clock def secondsToStr(t): return «%d:%02d:%02d.%03d» % reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = «=»*40 def log(s, elapsed=None): print line print secondsToStr(clock()), ‘-‘, s if elapsed: print «Elapsed time:», elapsed print line print def endlog(): end = clock() elapsed = end-start log(«End Program», secondsToStr(elapsed)) def now(): return secondsToStr(clock()) start = clock() atexit.register(endlog) log(«Start Program»)

Я также могу позвонить по номеру timing.log из моей программы, если есть значительные этапы внутри программы, которую я хочу показать. Но только в том числе import timing напечатает время начала и окончания и общее прошедшее время. (Простите мою неясное secondsToStr функции, просто форматирует число с плавающей точкой секунд до чч: мм:. СС.ссс формы)

Примечания: версию Python 3 из приведенной выше коды можно найти here или here.

Это действительно чистое решение, которое также работает, если вы нажмете Ctrl-C, чтобы остановить программу. – sorin

Действительно приятное решение и легко интегрируется с существующим кодом. Благодаря! – nover

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

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

$ /usr/bin/time -v python rhtest2.py Command being timed: «python rhtest2.py» User time (seconds): 4.13 System time (seconds): 0.07 Percent of CPU this job got: 91% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 0 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 15 Minor (reclaiming a frame) page faults: 5095 Voluntary context switches: 27 Involuntary context switches: 279 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0

Обычно просто time является более простой оболочкой, что тень встроенным более способна /usr/bin/time .

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

#python3 import atexit from time import time, strftime, localtime from datetime import timedelta def secondsToStr(elapsed=None): if elapsed is None: return strftime(«%Y-%m-%d %H:%M:%S», localtime()) else: return str(timedelta(seconds=elapsed)) def log(s, elapsed=None): line = «=»*40 print(line) print(secondsToStr(), ‘-‘, s) if elapsed: print(«Elapsed time:», elapsed) print(line) print() def endlog(): end = time() elapsed = end-start log(«End Program», secondsToStr(elapsed)) start = time() atexit.register(endlog) log(«Start Program»)

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

Я нашел ‘timedelta (seconds = t) .total_seconds()’ полезно. –

Можете ли вы объяснить, что делают эти функции? Что такое s в команде журнала? Что такое atexit? – SumNeuron

Вы можете использовать профайлер python cProfile для измерения CPU time и дополнительно, сколько времени тратится на каждую функцию и сколько раз каждую функцию вызывается. Это очень полезно, если вы хотите повысить производительность своего скрипта, не зная, с чего начать. This answer к другому вопросу SO довольно хорошо. Всегда хорошо смотреть в the docs.

Вот пример того, как профилировать скрипт, используя Cprofile из командной строки:

$ python -m cProfile euler048.py 1007 function calls in 0.061 CPU seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.061 0.061 :1() 1000 0.051 0.000 0.051 0.000 euler048.py:2() 1 0.005 0.005 0.061 0.061 euler048.py:2() 1 0.000 0.000 0.061 0.061 1 0.002 0.002 0.053 0.053 1 0.000 0.000 0.000 0.000 1 0.000 0.000 0.000 0.000 1 0.003 0.003 0.003 0.003

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

from datetime import datetime start_time = datetime.now() # do your work here end_time = datetime.now() print(‘Duration: <>’.format(end_time — start_time))

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

Duration: 0:00:08.309267
Duration: 1 day, 1:51:24.269711

Update: Как упоминалось JF Sebastian, этот подход может столкнуться с некоторыми сложные случаи с местным временем, так что безопаснее использовать:

import time from datetime import timedelta start_time = time.monotonic() end_time = time.monotonic() print(timedelta(seconds=end_time — start_time))

ОК, вы имеете в виду, например, ‘start_time = time.monotonic(); end_time = time.monotonic(); timedelta (seconds = end_time — start_time) ‘. Я верю, что вы правы, но тогда вам также нужно отформатировать его, когда вы вернетесь к ‘datetime.timedelta (0, 0, 76)’. Кроме того, кажется, что монотонный метод был добавлен только в Python 3. – metakermit

А, ОК. Я вижу, вы можете передать его на ‘str()’, чтобы сделать его «человеком». Спасибо, спасибо. – metakermit

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

OP явно упоминает ‘timeit’ в вопросе. Вопрос в том, как его можно использовать здесь (или он должен использоваться здесь и каковы альтернативы). Вот [возможный ответ] (http://stackoverflow.com/a/28827752/4279). – jfs

Мне также нравится ответ Пола МакГира и вышла с формой менеджера контекста, которая соответствовала моим потребностям.

import datetime as dt import timeit class TimingManager(object): «»»Context Manager used with the statement ‘with’ to time some execution. Example: with TimingManager() as t: # Code to time «»» clock = timeit.default_timer def __enter__(self): «»» «»» self.start = self.clock() self.log(‘n=> Start Timing: <>’) return self def __exit__(self, exc_type, exc_val, exc_tb): «»» «»» self.endlog() return False def log(self, s, elapsed=None): «»»Log current time and elapsed time if present. :param s: Text to display, use ‘<>’ to format the text with the current time. :param elapsed: Elapsed time to display. Dafault: None, no display. «»» print s.format(self._secondsToStr(self.clock())) if(elapsed is not None): print ‘Elapsed time: <>n’.format(elapsed) def endlog(self): «»»Log time for the end of execution with elapsed time. «»» self.log(‘=> End Timing: <>’, self.now()) def now(self): «»»Return current elapsed time as hh:mm:ss string. :return: String. «»» return str(dt.timedelta(seconds = self.clock() — self.start)) def _secondsToStr(self, sec): «»»Convert timestamp to h:mm:ss string. :param sec: Timestamp. «»» return str(dt.datetime.fromtimestamp(sec))

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

$ python -mtimeit -n1 -r1 -t -s «from your_module import main» «main()»

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

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

$ python3 -mprofile your_module.py

Вы можете передать -p в timeit команду выше если вы хотите использовать тот же таймер, что и модуль profile .

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

import atexit from time import clock def reduce(function, iterable, initializer=None): it = iter(iterable) if initializer is None: value = next(it) else: value = initializer for element in it: value = function(value, element) return value def secondsToStr(t): return «%d:%02d:%02d.%03d» % reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = «=»*40 def log(s, elapsed=None): print (line) print (secondsToStr(clock()), ‘-‘, s) if elapsed: print («Elapsed time:», elapsed) print (line) def endlog(): end = clock() elapsed = end-start log(«End Program», secondsToStr(elapsed)) def now(): return secondsToStr(clock()) def main(): start = clock() atexit.register(endlog) log(«Start Program»)

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

IPython «timeit» любой сценарий:

def foo(): %run bar.py timeit foo()
from time import time start_time = time() . end_time = time() time_taken = end_time — start_time # time_taken is in seconds hours, rest = divmod(time_taken,3600) minutes, seconds = divmod(rest, 60)

time.clock()

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

time.perf_counter()

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

time.process_time()

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

start = time.process_time() . do something elapsed = (time.process_time() — start)

PYTHON ВРЕМЯ ВЫПОЛНЕНИЯ ПРОГРАММЫ

Измерение времени выполнения программы на Python может быть полезным при оптимизации ее производительности и выявлении узких мест в ее работе.

Для измерения времени выполнения программы в Python можно использовать модуль timeit. Этот модуль предоставляет механизмы для повторного запуска данного кода с целью получения более точных результатов.

import timeit
def my_func():
return sum(range(100))
print(timeit.timeit(my_func, number=1000))

В этом примере мы импортируем модуль timeit и создаем функцию my_func, которая вычисляет сумму чисел от 0 до 99. Затем мы используем функцию timeit для измерения времени выполнения этой функции 1000 раз. Результат будет выведен на экран.

Кроме модуля timeit, в Python существует также модуль datetime, который можно использовать для измерения времени выполнения программы. Однако этот модуль предназначен для работы с датами и временем, и его использование для измерения времени выполнения программы может быть несколько менее эффективно.

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