У меня есть программа командной строки на Python, выполнение которой требует времени. Я хочу знать точное время, необходимое для завершения бега. Я посмотрел на timeit модуль, но, похоже, это только для небольших фрагментов кода. Я хочу рассчитать время для всей программы.
задан 12 окт.
30 ответы
Самый простой способ на Python:
import time start_time = time.time() main() print(«— %s seconds —» % (time.time() — start_time))
Это предполагает, что ваша программа запускается не менее десятой секунды. Печать:
— 0.764891862869 seconds —
Создан 15 июля ’17, 12:07
при этом рассчитывается реальное время (включая время, используемое другими программами), поэтому может показаться, что это займет больше времени, когда ваш компьютер занят другими делами — новыйаккт
в Windows сделайте то же самое, но используйте time.clock () вместо time.time (). Вы получите немного лучшую точность. — Кори Голдберг
Я рекомендую делать round(time.time() — start_time, 2) (или любое другое десятичное число, которое вы хотите), я получал научные числа, такие как 1.24e-5. — ТорСаммонер
Как измерить время выполнения кода в python #shorts #short
В этом методе есть большой недостаток. Если системное время изменяется во время работы программы (например, синхронизация с сервером времени), этот метод не будет работать или даже может нарушить код (отрицательная продолжительность . ) — Гилад
Я положил это 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 функция, она просто форматирует число секунд с плавающей запятой в форму hh: mm: ss.sss.) Примечание. Можно найти версию вышеуказанного кода для Python 3. здесь or здесь.
ответ дан 23 мая ’17, 13:05
Это настоящее чистое решение, которое также работает, если вы нажмете Ctrl-C, чтобы остановить программу. — Сорин
отличное решение, я обязательно воспользуюсь им и создам декоратор времени для определения узких мест — c24b
Для Python 3 добавьте from functools import reduce вверху и заключите в скобки каждое выражение для печати. Работает отлично! — PowerApp101
Примечание. Time.clock () устарело с версии 3.3: поведение этой функции зависит от платформы: вместо этого используйте perf_counter () [со временем ожидания] или process_time () [без времени ожидания], в зависимости от ваших требований, чтобы иметь четко определенное поведение «. — МАБ
Время выполнения задачи на Python
В Linux или Unix:
$ time python yourprogram.py
В Windows см. Этот вопрос StackOverflow: Как измерить время выполнения команды в командной строке Windows? Для более подробного вывода,
$ time -v python yourprogram.py Command being timed: «python3 yourprogram.py» User time (seconds): 0.08 System time (seconds): 0.02 Percent of CPU this job got: 98% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10 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): 9480 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 0 Minor (reclaiming a frame) page faults: 1114 Voluntary context switches: 0 Involuntary context switches: 22 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
ответ дан 23 дек ’19, 17:12
Итак, если я запускаю другой виджет, например, в приложении QT, как мы рассчитываем время, необходимое этому виджету, чтобы появиться? — Часто пекарз
В случае виджета, если вы запускаете программу на Python, используйте принятый ответ от rogeriopvl. — Стивеха
но это, похоже, не дает времени в минутах: секундах, оно заканчивается плавающим числом !! — Часто пекарз
Да, дает количество секунд. Вы можете преобразовать в мин: секунды, если хотите. Посмотрите на ответ Пола Макгуайра и его secondsToStr() функция. — Стивеха
import time start_time = time.clock() main() print time.clock() — start_time, «seconds»
time.clock() возвращает процессорное время, что позволяет нам рассчитать только время, используемое этим процессом (по крайней мере, в Unix). В документации говорится: «В любом случае, это функция, которую нужно использовать для тестирования Python или алгоритмов синхронизации».
ответ дан 16 мар ’15, в 17:03
time.time () лучше всего использовать в * nix. time.clock () лучше всего использовать в Windows. — Кори Голдберг
Я считаю, что это нельзя использовать для расчета «только времени, используемого этим процессом», потому что он использует системное время и будет зависеть от других системных процессов? Поправьте меня, если я ошибаюсь 🙂 — АннанФэй
Примечание. Time.clock () устарело с версии 3.3: поведение этой функции зависит от платформы: вместо этого используйте perf_counter () [со временем ожидания] или process_time () [без времени ожидания], в зависимости от ваших требований, чтобы иметь четко определенное поведение «. — МАБ
Мне нравится вывод 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
Как упоминал Дж. Ф. Себастьян, этот подход может столкнуться с некоторыми сложными случаями с местным временем, поэтому его безопаснее использовать:
import time from datetime import timedelta start_time = time.monotonic() end_time = time.monotonic() print(timedelta(seconds=end_time — start_time))
Создан 27 ноя.
ОК, ты имеешь в виду как start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time — start_time) . Надеюсь, вы правы, но вам также придется отформатировать его, когда вы вернетесь datetime.timedelta(0, 0, 76) . Кроме того, похоже, что монотонный метод был добавлен только в Python 3. — метакермит
Ах хорошо. Я вижу, ты можешь передать это str() сделать его «человечным». Обновлю ответ, спасибо. — метакермит
мне действительно нравится Ответ Пола Макгуайра, но я использую Python 3. Итак, для тех, кому интересно: вот модификация его ответа, которая работает с Python 3 на * nix (я полагаю, что под Windows это clock() следует использовать вместо time() ):
#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»)
Если вы сочтете это полезным, вы все равно должны проголосовать за его ответ, а не за этот, так как он проделал большую часть работы;).
Создан 23 сен.
Я нашел timedelta(seconds=t).total_seconds() полезный. — ню Эверест
Вы можете объяснить, что делают эти функции? что указано в команде журнала? что такое атексит? — СуммаНейрон
Вы можете использовать профилировщик Python cProfile для измерения Процессорное время и, кроме того, сколько времени тратится внутри каждой функции и сколько раз каждая функция вызывается. Это очень полезно, если вы хотите повысить производительность своего скрипта, не зная, с чего начать. Этот ответ к другому вопросу о переполнении стека довольно хорошо. Всегда хорошо заглянуть документация тоже. Вот пример того, как профилировать скрипт с помощью 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
Создан 27 ноя.
Еще лучше для Linux: time
$ 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
ответ дан 23 дек ’19, 19:12
Просто используйте timeit модуль.
Он работает как с Python 2, так и с Python 3.
import timeit start = timeit.default_timer() # All the program statements stop = timeit.default_timer() execution_time = stop — start print(«Program Executed in «+str(execution_time)) # It returns time in seconds
Он возвращается через секунды, и вы можете получить время выполнения. Это просто, но вы должны записать их в функцииw main, которая запускает выполнение программы. Если вы хотите получить время выполнения даже при возникновении ошибки, возьмите к нему свой параметр «Старт» и вычислите его следующим образом:
def sample_function(start,**kwargs): try: # Your statements except: # except statements run when your statements raise an exception stop = timeit.default_timer() execution_time = stop — start print(«Program executed in » + str(execution_time))
ответ дан 14 мая ’20, 20:05
Не должно быть той части под finally часть? — Alper
time.clock ()
Не рекомендуется, начиная с версии 3.3: поведение этой функции зависит от платформы: используйте perf_counter () or process_time () вместо этого, в зависимости от ваших требований, иметь четко определенное поведение.
time.perf_counter ()
Возвращает значение (в долях секунды) счетчика производительности, т. Е. Часы с наивысшим доступным разрешением для измерения короткой продолжительности. Это делает включает время, прошедшее во время сна, и является общесистемной.
time.process_time ()
Возвращает значение (в долях секунды) суммы системного и пользовательского процессорного времени текущего процесса. Это не включать время, прошедшее во время сна.
start = time.process_time() . do something elapsed = (time.process_time() — start)
ответ дан 18 мая ’16, 04:05
Пожалуй, начнем с вывода, «Используйте time.process_time ()» (или похожие)? — Питер Мортенсен
Следующий фрагмент кода выводит прошедшее время в удобном, удобном для чтения виде. формат.
import time from datetime import timedelta start_time = time.time() # # Perform lots of computations. # elapsed_time_secs = time.time() — start_time msg = «Execution took: %s secs (Wall clock time)» % timedelta(seconds=round(elapsed_time_secs)) print(msg)
Создан 20 фев.
здесь можно найти наиболее разумный ответ («разумный» означает максимальное использование встроенных функций и, следовательно, минимальное количество наборов текста). — иосеф
Для специалистов по данным, использующих Jupyter Notebook
В ячейке вы можете использовать Jupyter’s %%time волшебная команда для измерения времени выполнения:
%%time [ x**2 for x in range(10000)]
Результат
CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms Wall time: 4.12 ms
Это будет фиксировать только время выполнения конкретной ячейки. Если вы хотите зафиксировать время выполнения всей записной книжки (то есть программы), вы можете создать новую записную книжку в том же каталоге и в новой записной книжке выполнить все ячейки: Предположим, что записная книжка выше называется example_notebook.ipynb . В новой записной книжке в том же каталоге:
# Convert your notebook to a .py script: !jupyter nbconvert —to script example_notebook.ipynb # Run the example_notebook with -t flag for time %run -t example_notebook
Результат
IPython CPU timings (estimated): User : 0.00 s. System : 0.00 s. Wall time: 0.00 s.
Создан 27 ноя.
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)
ответ дан 06 апр.
мне нравится Ответ Пола Макгуайра тоже и придумал форму контекстного менеджера, которая больше соответствовала моим потребностям.
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))
Источник: stackovergo.com
блог JOHN_16
Здесь я планирую размещать небольшие статьи на интересующие меня темы.
четверг, 2 февраля 2012 г.
Python: модуль timeit — измерение времени выполнения маленьких фрагментов кода. Примеры использования.
Новое в версии 2.3
Этот модуль предоставляет простой способ замерить быстродействие некоторого фрагмента Python кода. Он имеет как интерфейс командной строки, так и интерфейс вызовов. Это позволяет избежать ряда общих ловушек для измерения времени выполнения.
Интерфейс вызовов
Модуль определяет следующий класс:
class timeit.Timer([stmt=’pass'[, setup=’pass'[, timer= ]]])
Класс для измерения скорости выполнения маленьких фрагментов кода.
Конструктор принимает аргумент stmt содержащий выражение которое будет замерено, дополнительный аргумент setup представляющий собой выражение, выполняемое перед основным выражением. Функция таймера timer является платформозависимой (см. модуль doc string). Выражения могут содержать символы новой строки, если они не содержат многострочных строковых литералов.
Для измерения времени выполнения первого выражения необходимо использовать метод timeit() . Метод repeat() удобен для многократного вызова timeit() , возвращает список с результатами.
Новое в версии 2.6
Параметры stmt и setup могут принимать объекты которые вызываются без аргументов.Это позволит встраивать вызовы в функцию таймер, который будет выполнен по timeit() . Обратите внимание, в этом случае будут произведены дополнительные затраты, из-за вызывов дополнительных функций.
Timer.print_exc([file=None])
Выводит информацию о полученном исключении из выполняемого кода. Приемущество данного метода перед стандартным выводом исключения состоит в том, что будут отображены исходные строки из компилированного шаблона. Дополнительный аргумент file указывает куда направить вывод об исключении, по-умолчанию это стандартный поток ошибок sys.stderr .
Например так выглядит обычное сообщение об ошибке:
import timeit, traceback
setup= ‘a=5’
stmt= ‘b=a/0’
t=timeit.Timer(stmt, setup)
try:
t.timeit()
except:
traceback.print_exc()
Traceback (most recent call last):
File «C:Documents and SettingsUsertmp.py», line 43, in
t.timeit()
File «C:Python26libtimeit.py», line 193, in timeit
timing = self.inner(it, self.timer)
File » «, line 6, in inner
ZeroDivisionError: integer division or modulo by zero
А так будет выглядеть сообщение об ошибке, используя метод класса:
except:
t.print_exc()
Traceback (most recent call last):
File «C:Documents and SettingsUsertmp.py», line 43, in
t.timeit()
File «C:Python26libtimeit.py», line 193, in timeit
timing = self.inner(it, self.timer)
File » «, line 6, in inner
b=a/0
ZeroDivisionError: integer division or modulo by zero
Timer.timeit([number=1000000])
Эта команда выполнит выражение setup один раз, а затем возвратит время в секундах типа float, которое требуется что бы выполнить основное выражение number раз.
Важно! По-умолчанию timeit() временно отключает сборщик мусора на время измерений. Преимущество этого поведения заключается в том, что независимые измерения становятся более сопоставимыми. Недостатком же является то что сборщик мусора может быть важным компонентом производительности исследуемой функции. В таком случае необходимо включить сборщик мусора, используя выражение setup как показано в примере:
timeit.Timer(‘for i in xrange(10): oct(i)’, ‘gc.enable()’).timeit()
Timer.repeat([repeat=3[,number=1000000]])
Вызов timeit() c заданным repeat количеством раз, аргумент number передается в timeit() .
Очень заманчиво для вычисления среднего и стандартного отклонения от вектора результата и сообщать о них. Однако, это не очень полезно. В типичном случае, наименьшее значение дает нижнюю границу для того что бы понять, как быстро ваш компьютер может выполнить данный фрагмент кода, более высокие значения в результате, как правило, вызваны не различиями в скорости Python, а вмешательством других процессов в точность синхронизации. Так min() результата, наверное, единственное значение, которое должно заинтересовать. После этого, вы должны смотреть на все вектор и применять здравый смысл, а не статистику.
Начиная с версии 2.6 были добавлены 2 удобные функции.
timeit.timeit(stmt[, setup[, timer[, number=1000000]]]])
Создает экземпляр класса Timer, передает в конструктор входные параметры, вызывает метод timeit() , возвращает результат в секундах типа float.
timeit.repeat(stmt[, setup[, timer[, repeat=3[, number=1000000]]]])
Создает экземпляр класса Timer, передает в конструктор входные параметры, вызывает метод repeat() , возвращает список результатов.
Источник: john16blog.blogspot.com
Профилировщики для Python. Измеряем скорость выполнения наших приложений
В прошлой статье («Python на стероидах», 198-й номер) мы поговорили о профилировании Python-приложений. Судя по полученному фидбэку, тема оказалась интересной, и, выходит, теперь, когда мы уже попробовали все на практике, настало время познакомиться с теорией :). В этой статье я постараюсь рассказать о том, что вообще такое производительность ПО, как и зачем ее измерять, и закончу тему с профилированием. В следующий раз мы углубимся в тему тестирования производительности ПО в теории и на практике.
WARNING
Никогда не забывай, что преждевременная оптимизация — это еще хуже, чем ее отсутствие. Используй профайлеры только тогда, когда это действительно необходимо.
А быстро ли все работает?
Итак, зачем нам вообще измерять скорость работы нашего софта? Чаще всего скорость работы ПО измеряют в двух случаях: когда пользователи начинают жаловаться на то, что все тормозит, и когда в техническом задании написано что, например, страница разрабатываемого сайта должна открываться не медленнее, чем N секунд. Скорость работы — это вообще, на мой взгляд, мифическое понятие в вакууме.
INFO
Из Википедии: производительность софта — это количественная характеристика скорости выполнения определенных операций
Поэтому я предпочитаю использовать более конкретные определения: «скорость работы функции А низкая» или «при тысяче пользователей онлайн наш сайт отвечает на запросы более трех секунд». При таком подходе становится ясно не только что нужно измерять, но и что именно мы подразумеваем под скоростью работы софта. Ведь в зависимости от того, что ты разрабатываешь, измерять необходимо совершенно разные вещи. Например, при разработке веб-сайта главное, чтобы пользовательский интерфейс быстро реагировал на действия пользователя, и нам может быть абсолютно безразлично, сколько времени занимает запрос к базе данных, когда это работает асинхронно, а если мы пишем ORM, то важнейшим показателем скорости работы для нас будет скорость выполнения генерируемых запросов.
Python vs C или С vs Assembler
По этой же причине сложно сравнивать скорость работы языков программирования, ведь в конечном итоге нам неважно, сколько выполняется операция возведения в степень, нам нужно, чтобы скорость работы конкретной фичи в конкретном приложении была не ниже заданного значения. Поэтому различные холивары на тему «что быстрее — Python или Ruby» не имеют никакого смысла. Можно измерить скорость работы «Hello, world», но практической пользы в этом нет никакой.
То же самое касается и сравнения скорости работы разных фреймворков. Пользы от такого сравнения гораздо больше, чем от сравнения языков программирования, но все-таки не стоит воспринимать эти данные как истину в последней инстанции. На мой взгляд, такие сравнения годятся только для того, чтобы понять, как фреймворки ведут себя со стандартными настройками.
Они показывают общие тенденции, но не могут дать точного ответа на вопрос, что подойдет именно тебе для использования в новом мегапроекте. Например, совершенно бесполезно вычислять скорость работы веб-фреймворка при чтении из базы данных. Ведь самое простое кеширование позволит практически уравнять их все по скорости чтения из БД. При этом в твоем проекте базы данных может вообще не быть, а все данные будут приходить из других источников (файлы, различные API и так далее). Поэтому еще раз повторю: определяй скорость только тех операций, которые нужны именно тебе, а не автору теста.
Другие статьи в выпуске:
Хакер #199. Как взломали SecuROM
- Содержание выпуска
- Подписка на «Хакер» -60%
С чего все началось
Первые профайлеры появились еще в начале семидесятых для IBM/360 и IBM/370. Утилита для анализа производительности performance-analysis tool работала на основе прерываний и, по сути, была, наверное, первым статистическим профилировщиком. Позже, в 1979-м, в составе UNIX появился профайлер prof, что стало началом разработки ПО с использованием профилировщиков. После запуска prof выводил время, которое потребовалось для выполнения каждой функции программы.
Позже, в 1982 году, появился на свет gprof, который в 1983-м вошел в состав известного 4.2BSD. Тогда же была опубликована статья под названием «Gprof: a Call Graph Execution Profiler». В 1988-м gprof был переписан и включен в состав GNU Binutils, который входит в любой современный *nix-дистрибутив. Gprof расширил функциональность своего родителя и имел возможность строить граф вызовов функций.
Спустя шесть лет компания DEC опубликовала документ, описывающий фреймворк Analysis Tools with OM, — «ATOM: A system for building customized program analysis tools». ATOM позволял инструментировать софт (проще говоря — встроить свой код) для последующего анализа скорости выполнения кода.
Современные профилировщики
Сейчас существует огромное количество всевозможных профайлеров для разных языков программирования. Есть и универсальные профилировщики, которым не требуется исходный код программы, но желательно, чтобы программа была скомпилирована с нужными флагами. При профилировании рекомендуется использовать профайлер, созданный для языка программирования, с которым ты работаешь. Это удобно тем, что если инструмент заточен под конкретный язык программирования, то, например, в случае с Python в результате профайлинга мы будем видеть привычные названия функции вместо системных вызовов. Тут подход совершенно такой же, как и при выборе дебаггера: есть универсальные, которые работают с любым кодом и часто доступны на большинстве Linux-хостов, а есть те, которые разрабатывались для специальных нужд и, например, подходят только для разработки.
Давай разберем подробнее, какие профилировщики бывают и каковы их особенности.