Измерение времени, прошедшего в Python?

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

import timeit start = timeit.timeit() print "hello" end = timeit.timeit() print end - start 

18 Solutions collect form web for “Измерение времени, прошедшего в Python?”

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

 import time start = time.time() print("hello") end = time.time() print(end - start) 

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

Другим вариантом с 3.3 может быть использование perf_counter или process_time , в зависимости от ваших требований. До 3.3 рекомендуется использовать время использования.clock (спасибо @Amber). Однако в настоящее время он устарел:

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

В Windows эта функция возвращает часы настенных часов, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой, на основе функции Win32 QueryPerformanceCounter() . Разрешение обычно лучше, чем одна микросекунда.

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

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

 from timeit import default_timer as timer start = timer() # ... end = timer() print(end - start) 

timeit.default_timer присваивается time.time () или time.clock () в зависимости от ОС. В Python 3.3+ default_timer – time.perf_counter () на всех платформах. См. Python – time.clock () vs. time.time () – точность?

Смотрите также:

  • Оптимизация кода
  • Как оптимизировать скорость

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

test.py:

 def foo(): # print "hello" return "hello" 

timeit простой способ использовать timeit – вызвать его из командной строки:

 % python -mtimeit -s'import test' 'test.foo()' 1000000 loops, best of 3: 0.254 usec per loop 

Не пытайтесь использовать time.time или time.clock (наивно), чтобы сравнить скорость функций. Они могут давать неверные результаты .

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

Только Python 3:

Поскольку time.clock () устарел от Python 3.3 , вы захотите использовать time.perf_counter() для общесистемного времени или time.process_time() для времени процесса в целом, так же, как вы использовали time.clock() :

 import time t = time.process_time() #do some stuff elapsed_time = time.process_time() - t 

Новая функция process_time не будет включать время, прошедшее во время сна.

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

В основной библиотеке этого нет (но, вероятно, должно). После этого вы можете делать такие вещи, как:

 with elapsed_timer() as elapsed: # some lengthy code print( "midpoint at %.2f seconds" % elapsed() ) # time so far # other lengthy code print( "all done at %.2f seconds" % elapsed() ) 

Вот код contextmanager, достаточный для выполнения трюка:

 from contextlib import contextmanager from timeit import default_timer @contextmanager def elapsed_timer(): start = default_timer() elapser = lambda: default_timer() - start yield lambda: elapser() end = default_timer() elapser = lambda: end-start 

И некоторый runnable демонстрационный код:

 import time with elapsed_timer() as elapsed: time.sleep(1) print(elapsed()) time.sleep(2) print(elapsed()) time.sleep(3) 

Обратите внимание, что при создании этой функции возвращаемое значение elapsed() замерзает при выходе блока, а дальнейшие вызовы возвращают ту же самую длительность (примерно 6 секунд в этом примере игрушек).

Использование time.time для измерения исполнения дает вам общее время выполнения ваших команд, включая время работы других процессов на вашем компьютере. Это время, когда пользователь замечает, но не очень хорошо, если вы хотите сравнить разные фрагменты кода / алгоритмы / функции / …

Дополнительная информация о timeit :

  • Использование модуля timeit
  • timeit – время выполнения небольших битов кода Python

Если вы хотите более глубокое понимание профилирования:

Обновление : в течение прошлого года я многократно использовал http://pythonhosted.org/line_profiler/ и нашел его очень полезным и рекомендовал использовать его вместо модуля профиля Pythons.

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

Например, если у вас есть скрипт python timeFunctions.py:

 import time def hello(): print "Hello :)" time.sleep(0.1) def thankyou(): print "Thank you!" time.sleep(0.05) for idx in range(10): hello() for idx in range(100): thankyou() 

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

 python -m cProfile -o timeStats.profile timeFunctions.py 

Это делается с помощью модуля cProfile для профилирования всех функций в timeFunctions.py и сбора статистики в файле timeStats.profile. Обратите внимание, что нам не нужно было добавлять код в существующий модуль (timeFunctions.py), и это можно сделать с помощью любого модуля.

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

 python -m pstats timeStats.profile 

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

 Welcome to the profile statistics browser. timeStats.profile% stats hello <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'hello'> ncalls tottime percall cumtime percall filename:lineno(function) 10 0.000 0.000 1.001 0.100 timeFunctions.py:3(hello) timeStats.profile% stats thankyou <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'thankyou'> ncalls tottime percall cumtime percall filename:lineno(function) 100 0.002 0.000 5.012 0.050 timeFunctions.py:7(thankyou) 

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

Вот крошечный класс таймера, который возвращает строку «hh: mm: ss»:

 class Timer: def __init__(self): self.start = time.time() def restart(self): self.start = time.time() def get_time_hhmmss(self): end = time.time() m, s = divmod(end - self.start, 60) h, m = divmod(m, 60) time_str = "%02d:%02d:%02d" % (h, m, s) return time_str 

Применение:

 # Start timer my_timer = Timer() # ... do something # Get time string: time_hhmmss = my_timer.get_time_hhmmss() print("Time elapsed: %s" % time_hhmmss ) # ... use the timer again my_timer.restart() # ... do something # Get time: time_hhmmss = my_timer.get_time_hhmmss() # ... etc 

Вот еще один менеджер контекста для кода времени –

Применение:

 from benchmark import benchmark with benchmark("Test 1+1"): 1+1 => Test 1+1 : 1.41e-06 seconds 

или, если вам нужно значение времени

 with benchmark("Test 1+1") as b: 1+1 print(b.time) => Test 1+1 : 7.05e-07 seconds 7.05233786763e-07 

benchmark.py :

 from timeit import default_timer as timer class benchmark(object): def __init__(self, msg, fmt="%0.3g"): self.msg = msg self.fmt = fmt def __enter__(self): self.start = timer() return self def __exit__(self, *args): t = timer() - self.start print(("%s : " + self.fmt + " seconds") % (self.msg, t)) self.time = t 

Адаптировано из http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

(Только для Ipython) вы можете использовать % timeit для измерения среднего времени обработки:

 def foo(): print "hello" 

а потом:

 %timeit foo() 

в результате чего-то вроде:

 10000 loops, best of 3: 27 µs per loop 

Я предпочитаю это. Timeit doc слишком запутан.

 from datetime import datetime startTime= datetime.now() # INSERT YOUR CODE timeElapsed=datetime.now()-startTime print('Time elpased (hh:mm:ss.ms) {}'.format(timeElapsed)) промежуток from datetime import datetime startTime= datetime.now() # INSERT YOUR CODE timeElapsed=datetime.now()-startTime print('Time elpased (hh:mm:ss.ms) {}'.format(timeElapsed)) 

Обратите внимание, что здесь нет никакого форматирования, я просто написал hh: mm: ss в распечатке, чтобы можно было интерпретировать timeElapsed

на python3:

 from time import sleep, perf_counter as pc t0 = pc() sleep(1) print(pc()-t0) 

элегантный и короткий.

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

 import time def timed(fun, *args): s = time.time() r = fun(*args) print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s)) return(r) timed(print, "Hello") 

Имейте в виду, что «print» – это функция в Python 3, а не Python 2.7. Однако он работает с любой другой функцией. Ура!

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

 from pythonbenchmark import compare, measure import time a,b,c,d,e = 10,10,10,10,10 something = [a,b,c,d,e] @measure def myFunction(something): time.sleep(0.4) @measure def myOptimizedFunction(something): time.sleep(0.2) myFunction(input) myOptimizedFunction(input) 

https://github.com/Karlheinzniebuhr/pythonbenchmark

Мы также можем преобразовать время в человеко-читаемое время.

 import time, datetime start = time.clock() def num_multi1(max): result = 0 for num in range(0, 1000): if (num % 3 == 0 or num % 5 == 0): result += num print "Sum is %d " % result num_multi1(1000) end = time.clock() value = end - start timestamp = datetime.datetime.fromtimestamp(value) print timestamp.strftime('%Y-%m-%d %H:%M:%S') 

Используйте модуль профилировщика. Он дает очень подробный профиль.

 import profile profile.run('main()') 

он выводит что-то вроде:

  5 function calls in 0.047 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.000 0.000 :0(exec) 1 0.047 0.047 0.047 0.047 :0(setprofile) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 0 0.000 0.000 profile:0(profiler) 1 0.000 0.000 0.047 0.047 profile:0(main()) 1 0.000 0.000 0.000 0.000 two_sum.py:2(twoSum) 

Я нашел его очень информативным.

Еще один способ использования timeit :

 from timeit import timeit def func(): return 1 + 1 time = timeit(func, number=1) print(time) 

Вы можете использовать timeit.

Вот пример того, как тестировать naive_func, который принимает параметр с помощью Python REPL:

 >>> import timeit >>> def naive_func(x): ... a = 0 ... for i in range(a): ... a += i ... return a >>> def wrapper(func, *args, **kwargs): ... def wrapper(): ... return func(*args, **kwargs) ... return wrapper >>> wrapped = wrapper(naive_func, 1_000) >>> timeit.timeit(wrapped, number=1_000_000) 0.4458435332577161 

Вам не нужна функция обертки, если функция не имеет параметров.

  • Python Boto Dynamodb очень медленная производительность для поиска небольших наборов записей на клавишах диапазона
  • Оптимизация SqlAlchemy для объектных моделей только для чтения
  • Почему 2 ** 100 намного быстрее, чем математика (2100)?
  • Получите второе по величине число в списке в линейном времени
  • Как повысить производительность этой счетной программы?
  • Комбинации Python из 2 списков
  • Любые реальные примеры, чтобы показать неэффективность python?
  • Насколько эффективна максимальная функция Python
  • Более быстрый способ каталогов, идущий вместо os.listdir?
  • Каков эффективный способ преобразования float в int в python?
  • Ускорьте петли Python / Cython.
  • Python - лучший язык программирования в мире.