У меня есть программа командной строки в Python, которая требует много времени для завершения работы. Я хочу знать точное время, необходимое для завершения работы.
Я просмотрел модуль timeit
, но, похоже, он подходит только для небольших фрагментов кода. Я хочу засечь время всей программы.
Самый простой способ в Python:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
Это предполагает, что выполнение вашей программы занимает не менее десятой доли секунды.
Печатает:
--- 0.764891862869 seconds ---
Я поставил этот модуль timing.py на сайте-пакеты мои собственные каталог
, и просто вставить время импорт
в верхней части моего модуля:
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")
Я тоже могу называть сроки.журналвнутри моей программы, если существуют значительные этапы в рамках программы я хочу показать. Но только в том числе импорт ГРМ будет печатать начала и окончания, и общее истекшее время. (Да простят меня непонятных
secondsToStr` функция, она просто форматирует число с плавающей запятой секунд в ЧЧ:мм:СС.СНО форме.)
Примечание: в Python 3 версии выше код можно найти здесь или здесь.
В Linux или UNIX:
time python yourprogram.py
В Windows смотрите это обсуждение на Stackoverflow: https://stackoverflow.com/questions/673523/how-to-measure-execution-time-of-command-in-windows-command-line
Мне очень нравится пол Макгир'ы ответ, но я использовать Python 3. Поэтому для тех, кому интересно: здесь'ы изменение его ответ, который работает с 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")
Если вы найдете это полезным, вы должны еще до голосования его ответ вместо этого, как он сделал большую часть работы ;).
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
время.часы()
возвращает процессорное время, которая позволяет вычислить только время, затрачиваемое на этот процесс (в любом случае ОС UNIX). В документации сказано, что "в любом случае, это функция для использования бенчмаркинга Python или алгоритмы синхронизации и"
Вы можете использовать профилировщик питона cProfile для измерения времени ЦП и кроме того, сколько времени провел внутри каждой функции и сколько раз каждая функция вызывается. Это очень полезно, если вы хотите улучшить производительность вашего скрипта, не зная, с чего начать. Этот ответ в другой так вопрос довольно хорошо. Это's всегда хорошо, чтобы взглянуть в документы тоже.
Здесь'ы например, как профиль скрипт через 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}
Мне нравится выход модуля датавремя
предоставляет, где время объекты дельты показывают дни, часы, минуты и т. д. по мере необходимости в удобочитаемое пути.
Например:
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))
Еще лучше для Linux: /usr/Бен/время
$ /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
Обычно, просто "время" - это проще встроенные раковины, что тени более способных /usr/Бен/время
.
Решение solution of rogeriopvl работает нормально, но если вам нужна более конкретная информация, вы можете использовать встроенный профайлер Python. Проверьте эту страницу:
http://docs.python.org/library/profile.html
Профилировщик сообщает вам много полезной информации, например, время, затраченное на выполнение каждой функции.
время.часы()
устаревшей начиная с версии 3.3: поведение этой функции зависит на платформе: использовать perf_counter() или process_time() вместо в зависимости от ваших требований, чтобы иметь хорошо определенное поведение.
время.perf_counter()
возвращает значение (в долях секунды) счетчика производительности Т. е. часы с максимальное разрешение для измерения коротких продолжительность. Это не включают в себя время, прошедшее во время сна и системы.
время.process_time()
возвращает значение (в долях секунды) от суммы системы и пользователь время текущего процесса ЦП. Это не включает время, затраченное во время сна.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Следующий печатает фрагмент прошедшего времени в хорошем удобочитаемом <чч:мм:СС>
формат.
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)
Модуль просто использовать раз все
. Он работает с 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
Он возвращает в секундах, и вы можете иметь свой срок исполнения. Простой, но вы должны написать в основной функцией которого начинается выполнение программы. Если вы хотите получить время выполнения, даже если вы получаете сообщение об ошибке, а затем принимать параметр на "Пуск" на это и расчета нет, как
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)
Я'вэ посмотрел на модуль, помогите другим, но, похоже, это's только для небольших фрагментов кода. Я хочу, чтобы время всей программы.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
Она работает your_module.функция main()
один раз и печатать прошедшее время через времени.время()` функция, как таймер.
Для эмуляции /usr/Бен/время
в Python увидеть на Python подпроцесс с /usr/Бен/время: как собрать информацию времени, но игнорировать всех остальных выходных?.
Для измерения времени процессора (например, Дон'т включать в себя время в течение времени.сон()) для каждой функции, вы можете использовать
профиль- модуль (
cProfile` на Python 2):
$ python3 -mprofile your_module.py
Вы могли пройти -п
в команду `Раз все выше если вы хотите использовать тот же таймер как "профиль" модуль использует.
Смотрите как можно профиль скрипт Python?
Используйте 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))]
Мне нравится пол Макгир'ы ответ тоже и придумали контексте форму менеджер, который больше подходит моим потребностям.
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))
Я использовал очень простую функцию, чтобы передняя часть выполнения кода:
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'
Я чувствую себя немного элегантной таким образом.
В ячейку, вы можете использовать Jupyter'волшебная команда s %%
в настоящее время для измерения времени выполнения:
%%time
[ x**2 for x in range(10000)]
Выход Раз процессор: пользователь 4.54 МС Сыс: 0 НС, итого: 4.54 МС Стены время: 4.12 МС
Это будет только фиксировать время выполнения конкретной ячейки. Если вы'd, как, чтобы захватить время выполнения всей записной книжке (т. е. программу), можно создать новый блокнот в одном каталоге и в новой тетради выполним все ячейки:
Предположим, что вышеуказанный ноутбук называется 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 сек.