У меня есть программа командной строки на Python, которая требует времени, чтобы закончить. Я хочу знать точное время, необходимое для завершения бега.
Я посмотрел на timeit модуль, но, кажется, это только для небольших фрагментов кода. Я хочу, чтобы время всей программы.
user159685 12 окт ’09 в 23:56 2009-10-12 23:56
2009-10-12 23:56
40 ответов
Самый простой способ в Python:
import time start_time = time.time() main() print(«— %s seconds —» % (time.time() — start_time))
Это предполагает, что вашей программе требуется не менее десятой секунды для запуска.
— 0.764891862869 seconds —
user28388 13 окт ’09 в 00:00 2009-10-13 00:00
2009-10-13 00:00
В Linux или UNIX:
time python yourprogram.py
user166949 12 окт ’09 в 23:59 2009-10-12 23:59
2009-10-12 23:59
Я положил это 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
Примечание: версию вышеприведенного кода на Python 3 можно найти здесь или здесь.
user165216 13 окт ’09 в 02:08 2009-10-13 02:08
2009-10-13 02:08
Мне нравится вывод 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
Обновление: как упомянул JF Sebastian, этот подход может столкнуться с некоторыми хитрыми случаями с местным временем, поэтому безопаснее использовать:
import time from datetime import timedelta start_time = time.monotonic() end_time = time.monotonic() print(timedelta(seconds=end_time — start_time))
user544059 29 сен ’14 в 11:55 2014-09-29 11:55
2014-09-29 11:55
import time start_time = time.clock() main() print time.clock() — start_time, «seconds»
time.clock() возвращает время процессора, что позволяет нам рассчитывать только время, используемое этим процессом (в любом случае в Unix). Документация гласит: «В любом случае, эту функцию следует использовать для тестирования Python или алгоритмов синхронизации».
Время выполнения задачи на Python
user86989 13 окт ’09 в 01:25 2009-10-13 01:25
2009-10-13 01:25
Мне очень нравится ответ Пола Макгуайра, но я использую Python3. Так что для тех, кто заинтересован: вот модификация его ответа, которая работает с 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»)
Если вы находите это полезным, вы все равно должны проголосовать вместо его ответа, так как он сделал большую часть работы;).
user278268 10 сен ’12 в 02:03 2012-09-10 02:03
2012-09-10 02:03
Вы можете использовать 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 :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
user2073469 02 янв ’14 в 00:35 2014-01-02 00:35
2014-01-02 00:35
Просто используйте 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
Он возвращается в секундах, и вы можете иметь свое время выполнения. Все просто, но вы должны записать их в Main Function, которая запускает выполнение программы. Если вы хотите получить время выполнения, даже если вы получили ошибку, введите для нее параметр «Пуск» и вычислите его следующим образом
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)
user6570884 18 сен ’17 в 19:08 2017-09-18 19:08
2017-09-18 19:08
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)
user1219598 18 май ’16 в 03:49 2016-05-18 03:49
2016-05-18 03:49
time.clock устарела в Python 3.3 и будет удалена из Python 3.8: используйте time.perf_counter или же time.process_time вместо
import time start_time = time.perf_counter () for x in range(1, 100): print(x) end_time = time.perf_counter () print(end_time — start_time, «seconds»)
user14591824 20 июн ’21 в 12:11 2021-06-20 12:11
2021-06-20 12:11
Еще лучше для 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 ,
user137317 13 окт ’09 в 06:10 2009-10-13 06:10
2009-10-13 06:10
Для данных людей, использующих ноутбуки Jupyter
В клетке вы можете использовать Jupyter’s %%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 с.
user1038034 28 июл ’18 в 16:48 2018-07-28 16:48
2018-07-28 16:48
Следующие фрагменты отпечатков прошедшего времени в хорошем читаемом человеком формат.
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)
user218857 01 июл ’16 в 22:24 2016-07-01 22:24
2016-07-01 22:24
import time start_time = time.time() main() seconds = time.time() — start_time print(‘Time Taken:’, time.strftime(«%H:%M:%S»,time.gmtime(seconds)))
Time Taken: 00:00:08
user923227 12 мар ’20 в 08:27 2020-03-12 08:27
2020-03-12 08:27
Для функций я предлагаю использовать этот простой декоратор, который я создал.
user9631956 29 окт ’20 в 13:24 2020-10-29 13:24
2020-10-29 13:24
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)
user5843890 06 апр ’16 в 07:45 2016-04-06 07:45
2016-04-06 07:45
Решение rogeriopvl работает отлично, но если вам нужна более конкретная информация, вы можете использовать встроенный в Python профилировщик. Проверьте эту страницу:
Профилировщик говорит вам много полезной информации, например, о времени, потраченном на каждую функцию
user87407 13 окт ’09 в 00:07 2009-10-13 00:07
2009-10-13 00:07
У меня была такая же проблема во многих местах, поэтому я создал удобный пакет horology . Вы можете установить его с помощью pip install horology а затем сделайте это элегантно:
from horology import Timing with Timing(name=’Important calculations: ‘): prepare() do_your_stuff() finish_sth()
Important calculations: 12.43 ms
Или еще проще (если у вас одна функция):
main: 7.12 h
Он заботится о единицах и округлении. Он работает с python 3.6 или новее.
user8788960 08 дек ’19 в 01:05 2019-12-08 01:05
2019-12-08 01:05
Я посмотрел на модуль 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 Модуль использует.
user4279 03 мар ’15 в 09:04 2015-03-03 09:04
2015-03-03 09:04
Ipython «timeit» любой скрипт:
def foo(): %run bar.py timeit foo()
user2269826 20 май ’15 в 14:40 2015-05-20 14:40
2015-05-20 14:40
Мне также понравился ответ Пола Макгуайра, и он придумал форму контекстного менеджера, которая больше соответствовала моим потребностям
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))
user3819284 29 янв ’15 в 15:42 2015-01-29 15:42
2015-01-29 15:42
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: 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))]
user1484621 28 мар ’18 в 05:43 2018-03-28 05:43
2018-03-28 05:43
Я использовал очень простую функцию для определения времени выполнения кода:
import time def timing(): start_time = time.time() return lambda x: print(«[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’
Я чувствую себя немного элегантно в этом смысле.
Источник: stackru.com
Функции таймера в Python
- Использование функции time.time() в Python
- Использование функции time.Process_time() в Python
- Использование функции time.Perf_counter в Python
- Использование функции time.monotonic() в Python
Python — очень обширный язык программирования, который очень широко используется во всем мире. Программисты создают множество программ, требующих значительного количества строк кода Python. Чтобы отслеживать и анализировать эти коды в зависимости от времени выполнения, мы можем использовать функции таймера Python.
Модуль time здесь наиболее важен, так как он содержит все функции, которые помогают следить за временем и анализировать его.
Python Syntax — Everything you need.
Please enable JavaScript
В этом руководстве мы обсудим различные функции таймера Python с использованием модуля времени.
Использование функции time.time() в Python
Эта функция возвращает время в секундах. Это секунды, прошедшие после эпохи — 1 января 1970 года, 00:00:00 (UTC). Эта функция использует время, установленное компьютерной системой, чтобы вернуть результат, то есть количество секунд.
import time start = time.time() for r in range(1,20000): pass end = time.time() print(format(end-start))
Между start и end идет основная часть кода. Здесь в качестве примера взят цикл for .
3.252345085144043
Обратите внимание, что output, то есть секунды, является значением с плавающей запятой.
Использование функции time.Process_time() в Python
Эта функция возвращает время в долях секунды. В функции также записывается привязка ко времени всего процесса, а не только время, прошедшее во время процесса.
from time import process_time, sleep start = process_time() for r in range(20): print(r, end=» «) end = process_time() print(end, start) print(end-start)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 10.756645 10.75523 0.0014150000000014984
Время, затраченное в time.sleep() , не измеряется этой функцией, что означает, что она измеряет только разницу во времени между двумя последовательными ссылками на время.
Использование функции time.Perf_counter в Python
Эта функция, также известная как счетчик производительности, помогает более точно подсчитывать время между двумя ссылками. Эту функцию следует применять только к небольшим процессам, поскольку она очень точна.
Модуль time
Модуль time из стандартной библиотеки языка программирования Python содержит массу полезных методов для работы со временем. С его помощью можно получать информацию о текущей дате и времени с точностью до миллисекунд, выводить эти сведения в необходимом формате, а также управлять ходом выполнения программы, добавляя задержки по таймеру.
Текущее время в Python
Работа методов из модуля time основывается на общепринятой системе описания времени, которая справедлива для Unix, а также для POSIX-совместимых ОС. Согласно ее концепции, текущее время представляется в виде обыкновенного вещественного значения в секундах, прошедших с момента начала эпохи и до сегодняшнего дня. Отправной точкой для времени считается 1 января 1970 года, когда счетчик секунд имел полностью нулевое значение.
С тех пор это число постоянно растет, позволяя людям работать с различными видами дат в максимально точном представлении. В случае необходимости секунды переводятся в часы, дни, месяцы и годы, предоставляя пользователю удобный вид отображения времени. Чтобы увидеть количество секунд, прошедших с момента начала эпохи, достаточно вызвать метод time(). Но перед этим необходимо подключить модуль time с помощью операции импорта.
import time print(time.time()) 1540289822.637441
Как можно увидеть из данного примера, функция print получает в качестве единственного параметра число, возвращенное из метода time(), после чего выводит его на экран. Таким образом, с 1 января 1970 года прошло уже более полтора миллиарда секунд. Но подобное представление времени совсем неудобно для пользователя программы. Чтобы отобразить текущую дату в более комфортном виде, стоит передать функции print результат работы метода ctime(), не забыв произвести импорт соответствующей ему библиотеки time.
import time print(time.ctime()) Tue Oct 23 10:18:23 2018
В результате выполнения вышеописанной программы на экране будут отображены точные сведения о текущем времени, которые включают в себя день недели, название месяца, его число, часы, минуты, секунды и год. Кроме того, в качестве параметра методу ctime() можно передать любое значение в секундах, полученное при помощи упомянутого ранее time().
Методы
Для работы с временем в стандартной библиотеке языка Python имеется множество самых разных методов. Наиболее популярные функции, реализованные в модуле time, описаны в следующей таблице. Здесь можно найти их название, а также краткую характеристику.
| Метод | Характеристика |
| time() | возвращает текущее время, прошедшее с начала 1970 года в секундах |
| ctime(s) | возвращает местное время в строке или время, полученное из s секунд |
| clock() | возвращает процессорное время, прошедшее с момента первого вызова этой функции, точность больше 1 микросекунды |
| sleep(s) | останавливает ход выполнения программы ровно на s секунд |
| strftime(s) | преобразует переданное в качестве аргумента время s в строку по формату |
| strptime(s) | разбирает строку s и преобразует в объект времени по формату |
| mktime(s) | преобразует время s в количество секунд с начала 1970 года |
| localtime(s) | возвращает объект, представляющий местное время или время s |
Форматированный вывод
Принцип работы метода ctime() заключается в представлении секундного вещественного значения в более удобном виде, благодаря автоматическому форматированию. Некоторым пользователям предложенный подобным образом вывод данных может показаться чересчур сложным для восприятия либо же недостаточно информативным. Именно поэтому методы модуля time позволяют создавать свои уникальные типы форматирования для дат. В данном случае речь пойдет о функции strftime, принимающей в качестве параметров текущее время и шаблон, который будет использоваться для форматирования полученного объекта.
В следующем примере демонстрируется вывод значения, переданного функцией localtime() в strftime. То есть, мы в Python получим текущее время и выведем его в отформатированном виде. Первым аргументом метода strftime является строка с некоторым набором правил для форматирования, каждое из которых указано при помощи символа %. В результате, на экране выводится информация, включающая название месяца, число и год.
import time print(time.strftime(«Today is %B %d, %Y.», time.localtime())) Today is October 23, 2018.
Существует большое количество символов форматирования, отвечающих за отображение отдельных свойств объекта, представляющего собой дату. Важно запомнить, что каждое новое правило необходимо отделять знаком %. Все доступные типы форматов для вывода данных о времени подробно описаны в следующей таблице. Их можно передавать методу strftime в любом порядке, помещая в строковый литерал, который служит параметром.
| Формат | Свойство |
| %a | короткое название дня недели |
| %A | полное название дня недели |
| %b | короткое название месяца |
| %B | полное название месяца |
| %c | дата и время |
| %d | день месяца |
| %H | количество часов в 24-часовом формате |
| %I | количество часов в 12-часовом 1формате |
| %j | день года |
| %m | номер месяца |
| %M | количество минут |
| %p | до или после полудня для 12-часового формата |
| %S | количество секунд |
| %U | номер недели в году, начиная с воскресенья |
| %w | номер дня недели |
| %W | номер недели в году, начиная с понедельника |
| %x | дата |
| %X | время |
| %y | год без указания века |
| %Y | полное представление года |
| %Z | название часового пояса |
| %% | символ процента |
Применение метода sleep
Выполнение многих задач в программировании так или иначе связано с течением времени. Иногда программа должна прекращать ход своего выполнения на определенное количество секунд, минут или часов. Это вполне может потребоваться в тех случаях, когда компьютер взаимодействует с какой-либо внешней системой, например, базой данных, которая должна завершить выполнение собственных задач, прежде чем перейти к следующему действию.
Перевести программу в ждущий режим, временно заморозив ее работу, можно при помощи метода sleep, доступного в модуле time. Его единственным аргументом является количество секунд, которое следует выждать программе, прежде чем перейти к дальнейшему шагу из прописанного алгоритма. В следующем фрагменте кода функция sleep работает 10 секунд.
import time pause = 10 print(«Program started. «) time.sleep(pause) print(str(pause) + » seconds passed.») Program started. 10 seconds passed.
Как можно увидеть из результатов выполнения кода, вначале на экран выводится стартовое сообщение, после чего программа прекращает свою работу ровно на 10 секунд, поскольку метод sleep получает переменную pause в качестве аргумента. Затем отображается последняя запись, информирующая пользователя о том, какое количество секунд длилась задержка.
Зачастую нам требуется сделать задержку в миллисекундах. Обратите внимание, что параметр функции sleep не обязательно должен быть целым числом.
Таким образом, чтобы сделать задержку в 100 миллисекунд, надо написать time.sleep(0.1) .
Время выполнения программы
Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов time() для получения текущего времени, чтобы в конечном итоге выявить, как долго работал блок кода. Метод sleep() здесь увеличивает время выполнения программы на 5 секунд.
import time start = time.time() time.sleep(5) finish = time.time() result = finish — start print(«Program time: » + str(result) + » seconds.») Program time: 5.005090236663818 seconds.
Несмотря на простоту вышеописанного подхода, использовать его в серьезных целях, где требуется точный и независимый от ОС результат, не рекомендуется. Все дело в том, что числовое значение времени, получаемое таким образом, может иметь погрешности за счет внутренних особенностей работы компьютера, в среде которого выполняется программа. Например, системные часы могут быть подкорректированы вручную пользователем во время выполнения программы. Корректировка может произойти и автоматически, если настроена синхронизация системных часов по NTP.
Таким образом, может случиться такая ситуация, что функция вернет значение меньшее, чем при предыдущем вызове.
monotonic
По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.
import time start = time.monotonic() time.sleep(15) result = time.monotonic() — start print(«Program time: .3f>».format(result) + » seconds.») Program time: 15.012 seconds.
В примере программы, описанном выше, продемонстрирована работа функции monotonic(). Принцип ее применения такой же, как и в предыдущем примере, однако здесь результат обладает гарантированной точностью и независим от внешних условий. Для отображения времени в более комфортной форме используется небольшое форматирование результата.
Заключение
Используя стандартный библиотечный модуль time в Python 3, можно всячески взаимодействовать с информацией о текущем времени. Таким образом, использование библиотеки дает возможность:
- Прерывать выполнение программы на заданное количество секунд.
- Отображать информацию о времени, прошедшем с начала эпохи.
- Преобразовывать значение системного времени к удобному виду.
- Измерять время выполнения программы целиком или ее отдельных модулей.
Источник: all-python.ru