1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
import datetime as dt import time def function(): start_time = dt.
datetime.now() # Засекаем начало выполнения функции print(«Выполняется функция. «) time.sleep(5) end_time = dt.datetime.
now() # Засекаем конец выполнения функции print(«Выполнение функции завершилось. «) total_time = end_time — start_time # Вычисляем время выполнения функции print(f»Функция выполнялась total_time>») if __name__ == «__main__»: function() # Вывод : # Выполняется функция. # Выполнение функции завершилось. # Функция выполнялась 0:00:05.006859
Источник: dropcode.ru
ML09: Измерение времени выполнения в Python и R
Временная сложность имеет значение в структуре данных. Точно так же время выполнения имеет значение при реализации любой программы, хотя на практике нас не особо волнует именно большая буква «0» в программе. Мы начинаем с основных концепций и реализации Python до реализации R.
Ты неправильно замеряешь время в Python! Или нет?
Контур
(2) Определения основных терминов
2–1 Гражданское время
2–2 Часы
2–3 Счетчик
2–4 Время процессора
2–5 Время обработки
2–6 Реальное время
2–7 Системное время
2–8 Настенные часы
2–9 Истекшее время / Истекшее реальное время
(3) Измерение времени выполнения в Python
3–1 time.perf_counter() и time.process_time()
3–2 Особый вариант использования
3–3 Другой инструмент в Python: timeit()
3–4 %timeit
3–5 Заключение
(1) Два типа «времени» [1]
1–1 Абсолютное время
Абсолютное время — это реальное время, возвращаемое функцией time.time() в Python. (т. е. так называемое время настенных часов в некоторых особых контекстах.)
Он поддерживается специальным оборудованием на большинстве компьютеров, схема RTC (часы реального времени) обычно питается от батареи, поэтому система отслеживает реальное время между включениями питания. Это «реальное время» также может быть изменено в зависимости от вашего местоположения (часовых поясов) и сезона (переход на летнее время) или выражено как смещение от UTC (также известного как время по Гринвичу или зулусское время).
1–2 Относительное время
Относительное время не имеет определенной связи с реальным временем в том смысле, что эта связь зависит от системы и реализации и возвращается time.perf_counter() и time.process_time() в Python.
Его можно использовать только для измерения временных интервалов, то есть безразмерного значения, которое пропорционально времени, прошедшему между двумя моментами времени. В основном это используется для оценки относительной производительности (например, работает ли эта версия кода быстрее, чем та версия кода).
Простой способ замерить скорость работы кода в python
В современных системах он измеряется с помощью счетчика ЦП, который монотонно увеличивается с частотой, связанной с аппаратными часами ЦП. Разрешение счетчика сильно зависит от аппаратного обеспечения системы, значение не может быть надежно связано с реальным временем или даже сравниваться между системами в большинстве случаев. Кроме того, значение счетчика сбрасывается каждый раз при включении или сбросе ЦП.
(2) Определения основных терминов [2]
Есть несколько сложных терминов, которые мы должны пройти, прежде чем двигаться дальше.
2–1 Гражданское время
Время суток; внешние по отношению к системе. 10:45:13 — гражданское время; 45 секунд нет. Предоставляется существующей функцией time.localtime() и time.gmtime(). Не изменено этим PEP.
2–2 часа
Прибор для измерения времени. Разные часы имеют разные характеристики; например, часы с наносекундной «точностью» могут начать «отклоняться» через несколько минут, в то время как менее точные часы остаются точными в течение нескольких дней. Этот PEP в первую очередь касается часов, которые используют единицы секунд.
2–3 Счетчик
Часы, которые увеличиваются каждый раз, когда происходит определенное событие. Счетчик является строго монотонным, но не монотонными часами. Его можно использовать для генерации уникальной (и упорядоченной) метки времени, но эти метки времени нельзя сопоставлять с ‹гражданским временем›; создание тика вполне может быть скачкообразным, с несколькими продвижениями в одну и ту же миллисекунду, за которыми следует несколько дней без какого-либо продвижения.
2–4 Процессорное время
Согласно Википедии, время ЦП (или время обработки) — это количество времени, в течение которого центральный процессор (ЦП) использовался для обработки инструкций компьютерной программы или операционной системы, в отличие от истекшего времени, которое включает, например, ожидание. для операций ввода-вывода (I/O) или перехода в режим пониженного энергопотребления (ожидания). Время процессора измеряется в тактах или секундах. [3]
Мера того, сколько ресурсов процессора было затрачено на выполнение определенной задачи. Секунды ЦП часто нормализуются (так что переменное число может встречаться в одной и той же фактической секунде). Секунды ЦП могут быть важны при профилировании, но они не сопоставляются напрямую со временем отклика пользователя и не сопоставимы напрямую с секундами (в реальном времени).
2–5 Время обработки
Прошло время с начала процесса. Обычно оно измеряется в ‹процессорном времени›, а не в ‹реальном времени›, и обычно не увеличивается, пока процесс приостановлен.
2–6 в реальном времени
Время в реальном мире. Это отличается от «Гражданского времени» тем, что оно не «регулируется», но в противном случае они должны продвигаться синхронно. Это не связано с «реальным временем» «[Операционных] систем реального времени». Это время иногда называют «настенными часами», чтобы избежать двусмысленности; к сожалению, это вносит различные двусмысленности.
2–7 Системное время
Время, представленное операционной системой.
2–8 настенные часы
Что говорят часы на стене. Обычно это используется как синоним слова «в реальном времени»; к сожалению, время стены само по себе неоднозначно.
2–9 Истекшее время / Истекшее реальное время
Напротив, прошедшее реальное время (или просто реальное время или время настенных часов) — это время, прошедшее с начала компьютерная программа до конца, измеряемая обычными часами. Прошедшее реальное время включает время ввода-вывода, любые задержки многозадачности и все другие типы ожидания, вызванные программой. [3][4]
(3) Измерение времени выполнения в Python
3–1 time.perf_counter() VS. время.процесс_время()
time.perf_counter() → плавающее значение времени в секундах
Возвращает значение (в долях секунды) счетчика производительности, т. е. часы с самым высоким доступным разрешением для измерения небольшой продолжительности. Он учитывает время, прошедшее во время сна, и является общесистемным. Контрольная точка возвращаемого значения не определена, поэтому допустима только разница между результатами последовательных вызовов. [5]
Короче говоря, time.perf_counter() возвращает ‘абсолютное значение счетчика’ (обратите внимание, что это не «абсолютное значение»). [1]
time.process_time() → плавающее значение времени в секундах
Возвращает значение (в долях секунды) суммы системного и пользовательского процессорного времени текущего процесса. Он не включает время, прошедшее во время сна. Это все процессы по определению. [5]
Короче говоря, time.process_time() — это значение, полученное из счетчика ЦП, но обновляемое только тогда, когда данный процесс выполняется на ЦП, и может быть разбито на ‘ время пользователя» — время, когда сам процесс выполняется на ЦП, и «системное время» — время, когда ядро операционной системы работает на ЦП имени в процессе. [1]
import time as t import numpy as np t1 = t.process_time() start = t.perf_counter() for i in np.arange(0, 10**8, 1, dtype=np.int64): k = i * i t2 = t.process_time() end = t.perf_counter() spend_1 = t2 — t1 spend_2 = end — start print(» time.process_time(): <>».format(spend_1)) print(» time.perf_counter(): <>».format(spend_2))
Запустите вариант использования выше. На моем ноутбуке HP это занимает 35–36 с, а на Google Colab — 26–27 с.
Ноутбук HP: time.process_time() = 35,58 › 35,56 = time.perf_counter()
Colab: time.process_time() = 26,59 ‹ 26,64 = time.perf_counter()
Затем давайте изменим «10 ** 8» на «10 ** 8,5» и запустим вариант использования ниже. На моем ноутбуке HP это занимает 112~113 секунд, а на Google Colab — s~s.
Ноутбук HP: time.process_time() = 112,13 ‹ 112,23 = time.perf_counter()
Colab: time.process_time() = 87,98 ‹ 88,42 = time.perf_counter()
3–2 Особый вариант использования
Однако кто-то на GitHub обнаружил, что результаты time.perf_counter и time.process_time совершенно разные. [6] Код выглядит следующим образом:
from time import time, perf_counter, process_time, sleep from datetime import datetime def foo(n=100_000): z = 0 for i in range(n): z+=(i%2)**2 sleep(1.0) return z for f in [time, perf_counter, process_time, datetime.now]: a = f() foo() b = f() diff = b-a if f==datetime.now: diff = diff.seconds + diff.microseconds/10**6 print(f»: «)
Прежде чем сделать вывод о том, какой инструмент для измерения времени лучше, давайте наберемся терпения и рассмотрим еще один вариант инструмента — timeit().
3–3 Другой инструмент в Python: timeit()
Этот модуль предоставляет простой способ синхронизировать небольшие фрагменты кода Python. Он имеет как Интерфейс командной строки, так и вызываемый. Это позволяет избежать ряда распространенных ловушек для измерения времени выполнения. [7]
timeit.default_timer() : таймер по умолчанию, который всегда равен time.perf_counter() .
Изменено в версии 3.3: time.perf_counter() теперь является таймером по умолчанию. [7]
Так что на самом деле это не новый инструмент, а просто более быстрый и удобный способ реализовать time.perf_counter() .
Давайте запустим следующий фрагмент [8]:
def f1(): for n in range(100): pass def f2(): n=0 while nExecution Time of f1 = <>».format(timeit.timeit(f1, number=100000))) print («Execution Time time of f2 = <>».format(timeit.timeit(f2, number=100000))) %timeit f1() %timeit f2()
Для запуска более сложного кода с помощью timeit():
import timeit code=»’ def squaring(): myList=[] for x in range(50): myList.append(sqrt(x))»’ print(«Time = <>».format(timeit.timeit(stmt=code,setup=»from math import sqrt»,number=10000)))
3–4 % раз
%timeit — это магическая функция Ipython, которую можно использовать для определения времени выполнения определенного фрагмента кода (один оператор выполнения или один метод). [9]
%timeit for _ in range(1000): True
Как рассчитать время выполнения скрипта в PyCharm без добавления кода каждый раз?
В настоящее время я просто добавляю следующие строки вокруг моего кода:
import time start_time = time.time() # my code here print «time elapsed: s».format(time.time() — start_time)
Можно ли добиться того же самого, не добавляя код в каждый скрипт, который я хочу использовать? Или добавить что-то в конфигурации запуска или с помощью плагина?
user4915993 26 фев ’16 в 15:57 2016-02-26 15:57
2016-02-26 15:57
5 ответов
Вы можете профилировать свой сценарий, нажав кнопку «профиль» (она находится справа от кнопок «Выполнить», «Отладка» и «Выполнить с покрытием»):
Среди выходных данных вы найдете имя самого скрипта и время, необходимое для его запуска.
Примечание: функция доступна в PyCharm PROFESSIONAL 2017.1 для платформы Linux; другие установки могут не обеспечивать кнопку профилировщика.
user1991051 18 май ’16 в 15:21 2016-05-18 15:21
2016-05-18 15:21
Поскольку не у всех есть PyCharm Pro, который может измерять время работы скрипта, вот простое решение, использующее декоратор. Нам нужно всего лишь добавить одну строку кода для измерения времени работы любой функции следующим образом:
Processing time of func(): 3.00 seconds.
user1159104 15 июл ’20 в 03:31 2020-07-15 03:31
2020-07-15 03:31
Я знаю, что уже поздно, но я хотел того же, и вот что я сделал:
Создайте еще один файл Python в каталоге ваших кодов:
import time st=time.time() import test print(«—-%.2f—-«%(time.time()-st))
где test — это название вашей программы. Поэтому, если вы хотите запустить какую-либо программу, просто запустите ее отсюда, просто изменив тест.
Имейте в виду, что импорт запускает код нормально, если вы не использовали:
if __name__==»__main__»:
user10269207 31 окт ’18 в 11:27 2018-10-31 11:27
2018-10-31 11:27
Просто напишите соответствующий модульный тест (работает с версией сообщества).
from unittest import TestCase from yourscript import yourcode class TestSol(TestCase): def benchmark(self): res = yourcode(‘banana’) self.assertEqual(res, 77)
PyCharm аккуратно отображает время, затраченное на каждый тест.
Другое решение — обернуть интерпретатор time .
Но поскольку это поможет в других отношениях, я рекомендую отправиться в путь юнит-тестов.
user995896 02 окт ’19 в 20:07 2019-10-02 20:07
2019-10-02 20:07
Вы можете использовать эту команду при использовании блокнота IPython/Jupyter.
Команду можно добавить в первую строку ячейки, чтобы получить время ЦП и стены, необходимое для выполнения ячейки.
%%time # code
Альтернативой этому является (timeit — он будет запускать ячейку несколько раз, чтобы получить среднее значение и стандартное отклонение времени вычислений)
%%timeit # code
Источник: stackru.com