У меня есть программа командной строки на Python, для завершения которой требуется некоторое время. Я хочу знать точное time , которое требуется для завершения работы.
Я просмотрел модуль timeit, но, похоже, это только для небольших фрагментов кода. Я хочу time всю программу.
Самый простой способ в Python:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
Это предполагает, что для выполнения вашей программы требуется не менее десятой секунды.
Печать
--- 0.764891862869 seconds ---
Я помещаю этот модуль 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 будет печатать время начала и окончания, а общая истекшая time. (пропустите мою непонятную secondsToStr функцию, она просто форматирует число с плавающей точкой в секундах до hh: mm: ss.sss form.)
Примечание. Версия Python 3 приведенного выше кода может быть найдена здесь или здесь.
В Linux или UNIX:
time python yourprogram.py
В Windows см. обсуждение в Stackoverflow: Как измерить выполнение команды time команды в командной строке Windows?
Мне очень нравится ответ пола Макгуайра, но я использую 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")
Если вы сочтете это полезным, вам все равно следует проголосовать за этот ответ вместо него, поскольку он проделал большую часть работы;).
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
time.clock() возвращает процессор time,, который позволяет рассчитать только time , используемые этим процессом (в любом случае, Unix). В документации говорится: "В любом случае, это функция, используемая для бенчмаркинга Python или алгоритмов синхронизации"
Вы можете использовать Python Profiler 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 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
Мне нравится вывод, предоставляемый модулем datetime, где time дельта-объекты показывают дни, часы, минуты и т.д., если необходимо, с точки зрения человека.
Например:
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
Обновление: Как отметил Дж. Ф. Себастьян, этот подход может столкнуться с некоторыми сложными случаями с локальным time,, поэтому безопаснее использовать:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Еще лучше для 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.
решение rogeriopvl работает нормально, но если вам нужна более конкретная информация, вы можете использовать встроенный профилировщик Python. Проверьте эту страницу:
http://docs.python.org/library/profile.html
Профилировщик говорит вам много полезной информации, например, о времени, потраченном на каждую функцию
<сильный > time.clock()
Устаревший с версии 3.3: поведение этой функции зависит на платформе: вместо этого используйте perf_counter() или process_time()в зависимости от ваших требований, чтобы иметь четко определенное поведение.
<сильный > time. perf_counter()
Возвращает значение (в дробных секундах) счетчика производительности, то есть часы с наивысшим доступным разрешением для измерения короткого продолжительность. включает time , прошедший во время сна, и в масштабе всей системы.
<сильный > time. process_time()
Возвращает значение (в дробных секундах) суммы системы и пользовательский CPU time текущего процесса. Он не включает time истекший во время сна.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Следующий фрагмент распечатывает прошедшее время в удобном для человека формате <HH:MM:SS>.
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)
Просто используйте timeit модуль. Он работает как с Python 2, так и с Python 3
import timeit
start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time) #It returns time in sec
Он возвращается в секундах, и вы можете выполнить свое выполнение Time. Simple, но вы должны написать их в главной функции, которая запускает выполнение программы. Если вы хотите получить Execution time , даже когда вы получите ошибку, тогда возьмите свой параметр "Начать" и подсчитайте там, как
def sample_function(start,**kwargs):
try:
#your statements
Except:
#Except Statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time)
Я просмотрел модуль timeit , но, похоже, это только для небольших фрагментов кода. Я хочу time всю программу.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
Он запускает your_module.main() функцию one time и печатает прошедший time с помощью функции time.time() в качестве таймера.
Чтобы эмулировать /usr/bin/time в Python, см. подпроцесс Python с /usr/bin/time:, как записывать информацию о времени, но игнорировать все остальные выходные?.
Чтобы измерить CPU time (например, не включать time в течение time.sleep()) для каждой функции, вы можете использовать модуль profile (cProfile на Python 2):
$ python3 -mprofile your_module.py
Вы можете передать команду -p в timeit выше, если вы хотите использовать тот же таймер, что и модуль profile.
Ipython "timeit" любой script:
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)
Существует модуль timeit который можно использовать для определения времени выполнения кодов Python. Он содержит подробную документацию и примеры в документации по python (https://docs.python.org/2/library/timeit.html).
Мне также нравится ответ Пола МакГира и придумал форму менеджера контекста, которая соответствовала моим потребностям.
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))
Используйте line_profiler.
line_profiler профилирует время выполнения отдельных строк кода. Профилировщик реализован в C через Cython, чтобы уменьшить накладные расходы на профилирование.
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()
Результатами будут:
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
В ячейке вы можете использовать магическую команду Jupyter %%time для измерения времени выполнения:
%%time
[ x**2 for x in range(10000)]
Выход
Время процессора: пользовательский 4,54 мс, sys: 0 нс, всего: 4,54 мс
Время стены: 4,12 мс
Это будет захватывать только время выполнения конкретной ячейки. Если вы хотите зафиксировать время выполнения всей записной книжки (т.е. программы), вы можете создать новую записную книжку в том же каталоге и в новой записной книжке выполнить все ячейки:
Предположим, что записная книжка выше называется 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 (по оценкам): Пользователь: 0,00 с.
Система: 0,00 с.
Время стены: 0,00 с.
Я использовал очень простую функцию для определения времени выполнения кода:
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
И чтобы использовать его, просто вызовите его перед кодом для измерения, чтобы получить функцию синхронизации, затем вызовите функцию после кода с комментариями, и перед комментариями появится время, например:
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))
Тогда вывод будет выглядеть так:
[9.35s] Loaded 1458644 rows data from 'train'
Я чувствую себя немного элегантно в этом смысле.
Это ответ Paul 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() из вашей программы после импорта файла.
Timeit - это класс в python, используемый для вычисления выполнения time небольших блоков кода.
Default_timer - это метод в этом классе, который используется для измерения времени настенных часов, а не выполнения ЦП time.. Таким образом, другое выполнение процесса может помешать этому. Таким образом, это полезно для небольших блоков кода.
Образец кода выглядит следующим образом:
from timeit import default_timer as timer
start= timer()
#some logic
end = timer()
print("Time taken:", end-start)
Вы делаете это просто в Python. Нет необходимости усложнять.
import time
start = time.localtime()
end = time.localtime()
"""Total execution time in second$ """
print(end.tm_sec - start.tm_sec)
Чтобы использовать обновленный ответ metakermit для python 2.7, вам потребуется monotonic.
Тогда код будет выглядеть следующим образом:
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
time меры выполнения программы Python может быть непоследовательной в зависимости от:
Это связано с тем, что наиболее эффективным способом является использование "Ордена роста" и изучение записи "Большой буквы", чтобы сделать это правильно, https://en.wikipedia.org/wiki/Big_O_notation
В любом случае вы можете попытаться оценить производительность любой программы Python на определенных этапах машинного счета в секунду, используя этот простой алгоритм: адаптируйте это к программе, которую хотите оценить
import time
now = time.time()
future = now + 10
step = 4 # why 4 steps? because until here already 4 operations executed
while time.time() < future:
step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement
step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
Надеюсь, что это поможет вам.
Если вы хотите измерять время в микросекундах, то вы можете использовать следующую версию, полностью основанную на ответах Пола Макгуайра и Никохо, - это код Python3. Я также добавил немного цвета к нему:
import atexit
from time import time
from datetime import timedelta, datetime
def seconds_to_str(elapsed=None):
if elapsed is None:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
else:
return str(timedelta(seconds=elapsed))
def log(txt, elapsed=None):
colour_cyan = '\033[36m'
colour_reset = '\033[0;0;39m'
colour_red = '\033[31m'
print('\n ' + colour_cyan + ' [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
if elapsed:
print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)
def end_log():
end = time()
elapsed = end-start
log("End Program", seconds_to_str(elapsed))
start = time()
atexit.register(end_log)
log("Start Program")
log() => функция, которая печатает информацию о времени.
txt ==> первый аргумент в логе и строка для отметки времени.
atexit ==> модуль python для регистрации функций, которые вы можете вызывать при выходе из программы.
Это самый простой способ получить истекшее время для программы:
Напишите следующий код в конце вашей программы.
import time
print(time.clock())