Тайминг в Python OTUS

Python – язык программирования, который можно отнести к общему назначению. С его помощью пишут как бизнес-софт, так и развлекательный (игровой) контент. Это отличное решение для новичков в разработке. Относится к объектно-ориентированному типу.

В данной статье будет рассказано о том, что собой представляет задержка в Python, как использовать time (таймер), для чего все это нужно. Информация пригодится даже опытным разработчикам, которые планируют работу со временем в будущей утилите.

Ключевые термины

Пытаясь освоить Python, программеру потребуется выучить немало теории. Вот базовые термины, без которых время и остальные компоненты кодификаций применять на деле не получится:

  1. Ключевое слово – зарезервированное системой слово или фраза. Обозначает действие, операцию, функцию. Ключевики не могут выступать в виде имен переменных.
  2. Переменная – именованная ячейка памяти, которую можно изменять, сохранять и считывать.
  3. Алгоритм – последовательность действий, набор правил, помогающих решать те или иные задачи.
  4. Класс – набор связанных между собой объектов, которые имеют общие свойства.
  5. Объект – комбинация переменных, констант и иных структурных единиц. Они выбираются совместно и аналогичным образом проходят обработку.
  6. Константа – значение, которое не будет меняться на протяжении всего выполнения утилиты.
  7. Тип данных – классификация информации определенного вида.
  8. Массив – множество данных. Они предварительно группируются.

Огромную роль в Python играют ключевые слова. Их необходимо либо запоминать, либо заучивать, либо держать где-то поблизости справочник с соответствующими данными. Иначе при объявлении переменных не исключены проблемы.

Задержка – это…

Задержка – термин, который применим ко времени. Он встречается и в обыденной жизни. Это – ситуация, когда что-то происходит или должно осуществиться не сразу. Пример – после наступления каких-то обстоятельств.

В программировании задержка «откладывает» выполнение кода на определенное время. Часто такая потребность возникает тогда, когда нужно дождаться завершения иного процесса, чтобы задействовать далее полученный результат.

При рассмотрении многопоточных утилит, использовать таймер (timer) и время (time) нужно, чтобы дождаться завершения операции и функций из других потоков.

Класс Timer

Класс Timer () в Python отвечает за время и работу с ним «от начала по конца». Модуль, метод, используемый для задержки и всего, что с ней связано. Перед использованием оного требуется произвести импорт компонента.

Для этого подойдет запись типа import time в Python. Класс относится к модулю threading. Он создает таймер, который запускает функцию с аргументами и ключевыми значениями (kwargs). Происходит это за счет time, установленного как interval. Этот параметр указывается в секундах.

Программеру предстоит запомнить следующее:

  • Запись функции с классом, отвечающего за таймаут (timeout) –
  • Если args равен None (этот показатель устанавливается изначально), Python использует пустой список.
  • Когда ключевое слово kwargs равен None, применяется пустой словарь.
  • Класс «Таймер» представлен действием, которое нужно запускать только по прошествии конкретного промежутка времени.
  • Таймер выступает в виде подкласса threading.Thread().

Все это требуется запомнить. А еще – учесть, что в процессе коддинга предстоит использовать суперкласс (super class), а также мета данные.

Функции

Рассматривая methods time, программисту требуется изучить разнообразные функции, связанные со временем. Это поможет лучше разобраться в потоках и задержках. Не стоит забывать, что при тестинге важно использовать print. Эта операция выводит результат на экран.

Time.Time

Функция Time() будет возвращать число секунд, которые прошли с начала эпохи. Для Unix-систем это – 1.01.1970. Отсчет с 12 часов ночи ровно.

Ctime()

Компонент, который будет в виде аргумента в Python принимать количество секунд, прошедших с самого начала эпохи. Результат – возврат строки по местному time.

Sleep

Отвечает за непосредственную задержку. Откладывает исполнение нынешнего потока на заданное количество секунд.

Класс struct_time

Изучая, какой метод подойдет для работы с таймерами и super class, стоит обратить внимание на struct_time. Этот объект может быть принят некоторыми функциями в упомянутом ранее модуле. При обработке оного происходит возврат.

Выше – наглядный пример.

Реализация Sleep

Когда нужный метод для работы с задержкой изучен, можно рассмотреть то, как сделать таймаут. Для этого используют super class, а также sleep. Он проходит реализацию несколькими способами:

  • Через time.sleep(). Это – встроенная возможность Python. Отвечает за таймаут через модуль time. Откладывает выполнение потока на установленное количество секунд.
  • Вызов с декораторами. Активируют, когда одно неудачно выполненное действие требуется запустить снова.
  • В потоках. Такие ситуации требуют, чтобы приложение избегало простоя. Для этого применяют или time.sleep(), или Event.wait() из модуля threading.
  • Из Async IO. Асинхронные возможности появились в Питоне, начиная с 3.4 версии. Это – тип параллельного программирования.
  • В Tkinter и wxPython. Отсрочки возможны при создании пользовательских интерфейсов. При применении sleep() внутри GUI кода блокируется цикл обработки событий.
  • After(). Это – метод, который погружает в сон для Tkinter. Часть стандартной библиотеки.
  • CallLater. Метод для wxPython. Имеет больше виджетов и хорошо годится для нативной разработки.

А вот видео, где можно наглядно увидеть работу с таймером в Python. Лучше разобраться с этой темой, как и с языком программирования, помогут дистанционные компьютерные курсы. Программы рассчитаны на срок до года. В конце будет выдан электронный сертификат. В процессе пользователи получат не только хорошо поданный учебный материал, но и новые полезные связи. А еще – соберут портфолио для трудоустройства.

python — Асинхронный таймер на питоне

Вопрос задан

Изменён 10 месяцев назад

Просмотрен 335 раз

Короче, хочу сделать таймер, который при клике или вводе текста в консоль пишет сколько осталось, и при этом основной процесс не сворачивается. Сколько не пытался, получается только последовательно запускать -проверку консоли и таймер.

import datetime
from time import sleep
# введите время таймера
timer=int(input("How minutes it would take? "))*60
timerFinish=int(datetime.datetime.now().timestamp())+timer
def WhatLeft(timerFinish):
    if tellSth != None:
        left=timerFinish-int(datetime.datetime.now().timestamp())
        print("Left %s min, %s sec " % (left//60,left%60))
        tellSth=input('Whrite sth to see how much left: ')
def Pomodorro(timer):
    sleep(timer)
    print(f'You timer for {timer/60} has ended')
    
Pomodorro(timer)

Есть идеи как это сделать? Обратите внимание, таймер должен дотикать САМ, без командной строки

  • python
  • async
  • timer

4

Думаю такая реализация подойдет вам. Она не приостанавливает работу программы в отличии от sleep(). И можно создавать много таймеров одновеменно.

import time
class MyTimer:
    def __init__(self, time_to_wait):
        self.time_to_wait = time_to_wait
        self.time_to_stop = 0
    
    def start(self):
        self.time_to_stop = round(time.time()) + self.time_to_wait
    def left(self):
        left = self.time_to_stop - round(time.time())
        return left if left > 0 else 0
def main():
    seconds_to_wait = int(input('How long it would take(in minutes)? ')) * 60
    timer = MyTimer(seconds_to_wait)
    timer.start()
    while 1:
        cmd = input('Command: ')
        if cmd == 'left':
            print(timer.left(), 'seconds')
        else:
            # do something else
            pass
if __name__ == '__main__':
    main()

5

Написал рабочую версию этого таймера.

import datetime
from time import sleep
from threading import Timer
# введите время таймера
timer=int(input("Скоолько минут это займет? "))*60
timerFinish=int(datetime. datetime.now().timestamp())+timer
left=timerFinish-int(datetime.datetime.now().timestamp())
def timeLeft(left):
    answer = input("Если хотите узнать оставшееся время, пишите :")
    if answer:
        print (f"У вас осталось {left} секунд")
def Pomodorro(timer):
    
    left=timerFinish-int(datetime.datetime.now().timestamp())
    
    
    while left>0:
        
        
        
        left=timerFinish-int(datetime.datetime.now().timestamp())
        t = Timer(left, timeLeft(left))
        t.start()
        
        t.cancel()
            
        left=timerFinish-int(datetime.datetime.now().timestamp())
        
    print(f'You timer for {int(timer/60)} has ended')
    
Pomodorro(timer)

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки

Измерение прошедшего времени с помощью ПРИМЕРОВ

Python предоставляет библиотеку, которая помогает понимать и читать информацию о времени разными способами.

В Python эта библиотека называется модулем времени, и этот модуль предоставляет объекты времени и даты для выполнения любых операций, связанных со временем. Такие операции не манипулируют отметками времени или строками; вместо этого они манипулируют объектами.

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

В этом учебнике по таймеру Python вы узнаете:

  • Как использовать временную структуру Python?
  • Как использовать эпоху времени Python?
  • Как использовать Python time.time() для таймера?
  • Как использовать Python time.ctime()?
  • Как использовать Python time.sleep() для таймера?
  • Как использовать время Python. Python time.gmtime()?
  • Как использовать функцию time.clock() в Python?
  • Как использовать функцию time.Thread_time в Python?
  • Как использовать функцию time.Process_time() в Python?
  • Как использовать функцию time.Perf_counter() в Python?
  • Как проверить часовой пояс в Python?
  • Как разработать базовый таймер Python?

Как использовать временную структуру Python?

Структура времени в Python представлена ​​объектом time.struct_time. Синтаксис временной структуры Python представлен следующим образом: 4,tm_yday=200,tm_isdst=1)

Ниже приведена структура или порядок time.struct_time, как указано ниже:

Индекс Атрибут Значения
0 тм_год 0000, 2020, …,9999
1 тм_мон 1,2, 3,…12
2 тм_мдай 1,2,3,4, 5,…. 31
3 тм_час 0,1,2,3, 4,…23
4 тм_мин 0,1,2,3….,59
5 тм_сек 0,1,2,3…,61
6 tm_wday 0,1,2,3,4,5,6
7 tm_yday 1,2,3,4,…366
8 tm_isdist -1,0,1

В аргументе tm_wday понедельник представлен как 0,

Объект значений time.struct_time может быть представлен с использованием как атрибутов, так и индексов.

Функция time.asctime помогает в преобразовании времени. struct_time в формат, удобочитаемый в текстовой форме.

Как использовать эпоху времени Python?

Эпоха в Python определяется как экземпляр времени, выбранный в качестве начала определенной эры. Чтобы получить информацию об эпохе Python, вам нужно передать ноль в качестве аргумента времени. функция gmtime. Эпоха представлена ​​как время

00:00:00 UTC по состоянию на 1970 год, 1 st январь , а также представлен как 1970-01-01T00:00:00ZISO8601.

Следующий код Python демонстрирует применение эпохи времени Python, как показано ниже: –

Код Python: 

 время импорта
EpochExampleGuru99=time.gmtime(0)
print("Эпоха Python наступила",EpochExampleGuru99)
print("Год эпохи Python равен ",EpochExampleGuru99.tm_year)
print("Месяц эпохи Python равен ",EpochExampleGuru99.tm_mon)
print("День эпохи Python ", EpochExampleGuru99.tm_mday)

Вывод: 

 Эпоха Python: time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst= 0)
Год эпохи Python — 1970.
Месяц эпохи Python равен 1.
День эпохи Python — 1

Как использовать Python time.time() для таймера?

Функция времени в модуле времени Python возвращает количество секунд, прошедших с момента последней определенной эпохи. Он возвращает секунды в виде данных с плавающей запятой.

Синтаксис функции time.time() Python представлен ниже: –

Синтаксис: 

 time.time()

Следующий код показывает, как использовать функцию времени в Python: –

Код Python: 

 время импорта
print("В примере показаны секунды с использованием функции времени: ", time.time())

Вывод: 

 Пример показывает секунды с использованием функции времени: 1643044348.60835

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

Программа для прошедшего времени настенных часов показана ниже:

Код Python: 

 время импорта
start_time_Guru99 = время.время()
print("Время истекло после ожидания некоторого уровня...")
print("Время начала", start_time_Guru99)
время сна(1)
end_time_Guru99 = время. время()
print("Время окончания", end_time_Guru99)
print("Прошло время в этом примере кода: ", end_time_Guru99 - start_time_Guru99)

Вывод: 

 Прошло время после некоторого уровня ожидания...
Время начала 1643044897.5446985.
Время окончания 1643044898.545785.
Истекшее время в этом примере кода:  1,0010864734649658.

Как использовать Python time.ctime()?

Функция ctime в модуле времени Python принимает аргумент в виде секунд, которые передаются как эпоха, а в качестве выходных данных она предоставляет локальное время в строковом типе данных.

Секунды, прошедшие с момента последней эпохи, становятся входными данными для функции ctime.

Функция времени также может использоваться в качестве входных данных или аргументов в функции ctime. Цель функции — предоставить вывод в понятном формате или в формате, понятном человеку.

Синтаксис функции ctime() модуля времени Python показан ниже:

Синтаксис: 

 time. ctime()

Следующий код Python помогает проиллюстрировать пример функции ctime() в модуле Python.

Код Python: 

 время импорта
start_time_Guru99 = время.время()
print("Время истекло после ожидания некоторого уровня...")
print("Время начала", start_time_Guru99)
print("Время начала в человеческом обличии",time.ctime(start_time_Guru99))
время сна(1)
end_time_Guru99 = время.время()
печать (время.ctime (время. время ()))
print("Время окончания", end_time_Guru99)
print("Время начала в человеческом обличии",time.ctime(end_time_Guru99))
print("Прошло время в этом примере кода: ",end_time_Guru99 - start_time_Guru99)

Вывод: 

 Прошло время после некоторого уровня ожидания...
Время начала 1643045765.633842.
Время начала в человеческом облике Пн 24 января 17:36:05 2022
Пн Янв 24 17:36:06 2022
Время окончания 1643045766.634578.
Время начала в человеческом обличье Пн 24 января 17:36:06 2022
Истекшее время в этом примере кода:  1. 0007359981536865.

Приведенный выше код начинается с импорта модуля времени. Переменная start_time_guru99 инициализируется методом time, и аналогично переменная end_time_guru99 инициализируется.

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

Как использовать Python time.sleep() для таймера?

Функция сна, доступная в модуле времени Python, помогает замедлить выполнение программы. Он останавливает выполнение программы на несколько секунд, что передается в качестве аргумента функции сна.

Он также принимает число с плавающей запятой в качестве входных данных, чтобы иметь более точное время ожидания или остановки в текущем потоке выполнения.

Синтаксис функции сна в модуле времени Python представлен следующим образом: –

Синтаксис: 

 Time. sleep(10)

Применение функции сна распространяется на несколько ситуаций программирования. Одной ситуацией может быть фиксация базы данных, а другой ситуацией может быть ожидание завершения файла.

Следующий код отображает функцию сна модуля времени, как показано ниже: –

Код Python: 

 время импорта
start_time_Guru99 = время.время()
print("Время истекло после ожидания некоторого уровня...")
print("Время начала", start_time_Guru99)
print("Время начала в человеческом обличье", time.ctime(start_time_Guru99))
print("Перед вызовом метода")
время сна(1)
время сна (10,5)
print("после вызова метода сна")
end_time_Guru99 = время.время()
печать (время.ctime (время. время ()))
print("Время окончания", end_time_Guru99)
print("Время начала в человеческом обличии", time.ctime(end_time_Guru99))
print("Прошло время в этом примере кода: ", end_time_Guru99 - start_time_Guru99)

Вывод: 

 Прошло время после некоторого уровня ожидания. ..
Время начала 1643046760.163671.
Время начала в человеческом облике Пн 24 января 17:52:40 2022
Перед вызовом метода
после вызова метода сна
Пн Янв 24 17:52:51 2022
Время окончания 1643046771.6733172.
Время начала в человеческом обличии Пн 24 января 17:52:51 2022
Прошедшее время в этом примере кода: 11,509.64617729187

Как использовать время Python. Python time.gmtime()?

Функция gmtime() в модуле времени Python принимает аргумент в виде количества секунд, прошедших после завершения эпохи. Функция возвращает выходные данные в формате struct_time или UTC. Здесь UTC означает всемирное координированное время.

Синтаксис функции gmtime() следующий: –

Синтаксис 

 time.gmtime(аргумент)

Следующий код является примером использования функции gmtime() Python, как показано ниже: –

Код Python: 

 время импорта
результат = время.гмвремя(время.время())
print("Структурный формат времени следующий")
печать (результат)
print("Год в структурированном формате представлен как", result. tm_year)
print("Час в структурированном формате представлен как", result.tm_hour)

Вывод: 

 Структура формата времени следующая
time.struct_time(tm_year=2022, tm_mon=1, tm_mday=25, tm_hour=5, tm_min=48, tm_sec=27, tm_wday=1, tm_yday=25, tm_isdst=0)
 • Год в структурированном формате представлен как 2022.
 • Час в структурированном формате представлен как 5

В приведенном выше коде функция времени модуля времени Python передается в качестве аргумента в функцию gmtime, которая предоставляет конечному пользователю структурированный формат времени в качестве вывода.

Как использовать функцию time.clock() в Python?

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

Синтаксис функции часов представлен ниже: –

Синтаксис: 

 time.clock()

Поскольку функция часов устарела в Python версии 3, программист может использовать функции time.perf_counter() и time.process_time() для оценки производительности разработанного ими кода.

Как использовать функцию time.Thread_time в Python?

Функция thread_time модуля времени Python дает сумму системного времени и времени ЦП для активного выполняющегося потока. Функция возвращает значение с плавающей запятой, и оно не включает время, которое код тратит или занимает, когда вызывается функция сна. Эта функция используется только для определенных потоков и может использоваться для записи разницы во времени между двумя контрольными точками.

В следующем примере показано применение функции времени потока.

Код Python: 

 время импорта
импорт потоков
start_time1 = Нет
end_time1 = Нет
пример потока1():
    глобальное start_time1, end_time1
start_time1 = время. thread_time()
Цикл выполнения = 0
в то время как ExecutionLoop & lt;
10000000:
    проходить
Цикл выполнения += 1
end_time1 = время.thread_time()
threadTarget = threading.Thread (цель = threadexample1, args = ())
threadTarget.start()
threadTarget.присоединиться()
print("Время, проведенное в потоке, равно {}".format(end_time1 - start_time1))

Вывод: 

 Время, проведенное в потоке, равно 1,029076937.

Приведенный выше код возвращает разницу во времени между временем начала и окончания, затраченным в потоке, названном в качестве примера потока, и возвращает разницу в 1,029 соответственно.

Как использовать функцию time.Process_time() в Python?

Функция времени обработки в модуле времени Python возвращает ссылку на время в виде долей секунды и значения с плавающей запятой. Функция дает сумму системного времени и текущего прогресса процессорного времени.

Эта функция отображает атрибут, аналогичный присутствующему в функции thread_time, но не включает время, затраченное в функции time. sleep(). Он также создает ссылку, основанную на конкретном процессе. Благодаря этому атрибуту определяется разница во времени между двумя последовательными ссылками.

Следующий код помогает описать использование функции времени процесса, как показано ниже: –

Код Python: 

 from time
импортировать время_процесса, спать
г = 20
start_time = process_time() & NBSP;
для я в диапазоне (г):
    печать (я)
конечное_время = время_процесса()
print("Время окончания и время начала следующие:", end_time, start_time)
print("Прошедшее время в секундах:", end_time - start_time)

Вывод: 

 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Время окончания и время начала следующие: 0,0566 0,058789647
Прошедшее время в секундах: 0,00021771899999999816

Приведенный выше код записывает время между временем начала и временем окончания. Между разницей во времени начала и окончания выполнение кода процесса записывается как процесс и становится частью прошедшего времени.

Как использовать функцию time.Perf_counter() в Python?

Функция Perf_counter предоставляет высокоточное или точное значение времени. Функция perf_counter обеспечивает точное или точное время между двумя установленными контрольными точками, которые являются временем начала и окончания.

Следующий код помогает описать счетчик производительности, как показано ниже: –

Код Python: 

 от времени
импортировать perf_counter, спать
г = 6
start_time = perf_counter() & NBSP;
print("таймер запущен в", start_time) & nbsp; & NBSP;
для я в диапазоне (г):
    спать(1)
конечное_время = perf_counter()
print("таймер закончился в", end_time)
print("Прошедшее время в секундах, записанное счетчиком производительности:", end_time - start_time)

Вывод: 

 таймер запущен с 6967694.757714532
таймер закончился на 6967700.803981042
Прошедшее время в секундах, записанное счетчиком производительности: 6,046266509220004.

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

Как проверить часовой пояс в Python?

В Python есть два свойства под функцией времени модуля времени, которые предоставляют конечному пользователю информацию, относящуюся к часовому поясу.

  • Первое — это свойство time.timezone, а второе — time.tzname.
  • Функция time.timezone возвращает смещение не-DST или местного часового пояса в формате UTC.
  • time.tzname возвращает кортеж, который включает летнее и не летнее время или местные часовые пояса.

Синтаксис для time.timezone показан следующим образом: –

Синтаксис: 

 время.часовой пояс

Синтаксис для time.tzname показан следующим образом: –

Синтаксис: 

 time. tzname

Следующий код демонстрирует использование свойств часового пояса в Python: –

Код Python: 

 время импорта
print("Часовой пояс в формате, отличном от DST:",time.timezone)
print("Часовой пояс в формате DST и не DST:",time.tzname)

Вывод: 

 часовой пояс в формате, отличном от DST: 0
часовой пояс в формате DST и не DST: ('UTC', 'UTC')

Как разработать базовый таймер Python?

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

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

Резюме

Другие важные модули таймера Python:

Python предоставляет несколько модулей, которые помогают в управлении временем, а также в анализе кода. Другие модули, которые можно использовать для анализа времени и усилий для кодов, написанных на Python, следующие:

  • Term down: Это расширенный таймер Python, использующий различные символы ASCII. Они используются для создания простых таймеров обратного отсчета.
  • MobTimer: Python: это еще один таймер с графическим интерфейсом в Python, который при запуске предоставляет конечным пользователям полноэкранные таймеры с несколькими параметрами.
  • Ctimer:   Это модуль таймера в Python, обеспечивающий точность до наносекунд. Он использует API языка C для точной записи времени.

Прошедшее время, декораторы и многое другое – LearnDataSci

Автор: Кансин Гулер
Инженер-программист

В этом кратком руководстве мы рассмотрим различные реализации таймеров в Python.

Короче говоря, мы можем сделать простой таймер со встроенной библиотекой Python time следующим образом:

 import time
start_time = время. время()
# Вещь ко времени. На примере сна
время сна(10)
end_time = время.время()
прошедшее_время = время_окончания - время_начала
print(elapsed_time)

Out:

 10.004060745239258

Хотя это очень просто, это не лучший вариант для определения времени производительность вашего кода.

В оставшейся части этой статьи мы будем расширять эту концепцию, вычисляя время выполнения функции и сообщая о нем.

Модуль time оснащен множеством методов для сообщения GMT или местного времени в красивом формате в годах, месяцах, днях, часах, минутах и ​​секундах.

Для целей расчета времени удобно представлять время в виде одного числа. Мы добились этого во вступительном коде, но вот что time() функция фактически выводит:

 current_time = time.time()
print(current_time)

Out:

 1659543906. 2127182

Число, напечатанное на экране, представляет собой время в считанных секундах, прошедшее с некоторой системно-зависимой эпохи (в большинстве систем используется 1 января 1970 года), очищенное от любой другой конструкции.

Поскольку время сведено к числу с плавающей запятой, мы можем просто вычесть один момент времени из другого.

Вернемся к нашему примеру из вступления:

 время_начала = время.время()
время сна(10)
end_time = время.время()
прошедшее_время = время_окончания - время_начала
print(elapsed_time)

Out:

 10.007065773010254

Здесь мы использовали time.sleep(10) для приостановки выполнения на десять секунд. Мы отметили время до и после time.sleep() , вычислили прошедшее время и распечатали его.

Результат составляет немногим более десяти секунд и немного отличается от числа при каждом выполнении. Это связано с тем, что время зависит от других системных действий — система выполняет случайные операции между ними, заставляя нас работать более десяти секунд.

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

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

Если бы мы планировали измерить длительный процесс, мы бы выбрали monotonic() из-за его целостности, но здесь мы будем измерять простые процедуры.

Python предоставляет нам доступ к счетчику производительности для кратковременных измерений, называемому perf_counter() , который использует системные часы с самым высоким разрешением. Двигаясь дальше, мы будем использовать perf_counter() в наших вычислениях.

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

Давайте сначала рассмотрим простой пример диспетчера контекста, чтобы лучше понять его структуру и использование.

 из контекстного менеджера импорта contextlib
@contextmanager
дефдемонстрация_cm():
    print('Все, что предшествует yield, выполняется в самом начале')
    урожай
    print('Все после yield выполняется в самом конце')
с demo_cm():
    для n в диапазоне (10):
      print(n, end="\n")

Out:

 Все до yield выполняется в самом начале
0
1
2
3
4
5
6
7
8
9Все, что следует после yield, выполняется в самом конце

Здесь demo_cm реализовано как диспетчер контекста с помощью декоратора @contextmanager . Ключевое слово yield делит тело функции на две части: 1) Выражения выше yield выполняются непосредственно перед кодом, который управляет 2) Выражения ниже yield выполняются сразу после.

После определения мы присоединяем demo_cm к кодовому блоку, используя с выпиской .

В следующем разделе мы будем использовать ту же структуру для создания таймера.

Менеджер контекста таймера ниже очень похож на диспетчер контекста выше, за исключением того, что теперь мы окружаем yield нашей логикой синхронизации.

 @contextmanager
таймер определения():
    t0 = время.perf_counter()
    пытаться:
        урожай
    окончательно:
        t1 = time.perf_counter()
        прошло = t1 - t0
        print(f'{elapsed:0.4f}')

Давайте быстро рассмотрим этот код.

Во-первых, обратите внимание, что мы поместили yield в блок try-finally , чтобы убедиться, что кадрированный блок кода не повлияет на работу диспетчера контекста. Если управляемый код создает ошибку, таймер все равно будет сообщать о времени, прошедшем до возникновения ошибки.

Над try-finally мы отметили начальную точку: t0 . В пределах наконец мы отметили конечную точку и рассчитали прошедшее время. В итоге мы ограничили представление пропустил до четырех знаков после запятой через f-строку и распечатал ее.

Используем.

 # Использование таймера как обычного контекстного менеджера
с таймером():
  для я в диапазоне (1000000):
    я -= 1
        
# Использование таймера в качестве декоратора
@таймер()
Пример определения (число):
    время сна (число)
     
пример(5)

Исходящий:

 0,0884
5.0148

Одним из преимуществ использования декоратора @contextmanager для определения нашего таймера является то, что мы можем использовать таймер как с помощью с оператором и декоратором функции , как в последнем примере. Если бы мы хотели запрограммировать время определенной операции один раз, мы могли бы вызвать timer() , используя оператор with . Однако, если мы хотим отслеживать время выполнения функции при каждом выполнении, мы можем декорировать функцию, используя @timer() .

Что, если мы хотим передать аргументы нашему диспетчеру контекста? Мы рассмотрим эту идею в следующем разделе.

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

В следующем блоке кода мы создали параметризованную версию нашего таймера с именем timer2 . Мы удалили жестко закодированные методы доступа и отчета о времени и разрешили параметру сообщения форматировать строку сообщения.

 @contextmanager
def timer2 (time_func, сообщение):
    t0 = time_func()
    пытаться:
        урожай
    окончательно:
        t1 = time_func()
        прошло = t1 - t0
        печать (сообщение.  формат (истекшее))
        
с timer2(time.process_time, "Функция завершена за {:0.2f} секунд"):
  для я в диапазоне (1000000):
    я -= 1

Out:

 Функция завершена за 0,09 секунды

Внутри оператора with мы передали два аргумента: (1) используемую функцию таймера и пользовательское сообщение для функции, которое нужно напечатать. Поскольку мы используем process_time() в качестве нашей временной функции, мы будем измерять время процессора, исключая время, проведенное в спящем режиме.

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

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

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

 по умолчанию timer_wrapper (функция):
    общее_время, запусков = 0, 0
    
    таймер защиты (*args, **kwargs):
        t0 = время.время()
        результат = функция (* аргументы, ** kwargs)
        t1 = время.время()
        прошло = t1 - t0
        
        # добавить переменные в область видимости
        нелокальный total_time, работает
        работает += 1
        total_time += истекло
        
        print(f"@timer: {func.__name__} заняло {прошедшее:0.4f} секунд")
        print(f"Среднее время выполнения: {(total_time/runs):0.4f} секунд\n")
        
        вернуть результат
    таймер возврата

Код таймера почти такой же, как у предыдущих таймеров, но теперь мы добавили две переменные для отслеживания времени: total_time и запускает . Эти значения будут накапливаться и содержать значения, необходимые для расчета среднего значения.

Теперь мы применим этот декоратор к функции, которую хотим задать по времени:

 @timer_wrapper
определение random_fn():
    для я в диапазоне (1000000):
        я -= 1
для я в диапазоне (5):
  random_fn()

Вышло:

 @timer: random_fn заняло 0,0400 секунды
Среднее время выполнения составляет 0,0400 секунды.
@timer: random_fn заняло 0,0436 секунды
Среднее время выполнения составляет 0,0418 секунды.
@timer: random_fn заняло 0,0410 секунды
Среднее время выполнения составляет 0,0415 секунды.
@timer: random_fn занял 0,0409секунды
Среднее время выполнения составляет 0,0414 секунды.
@timer: random_fn заняло 0,0455 секунды
Среднее время выполнения — 0,0422 секунды. декоратор. Обратите внимание, что  timer_wrapper()  запускается только один раз — он заменяет  random_fn()  , и его работа выполнена.
  timer() , который возвращается из  timer_wrapper()  :
  1.  Принимает  *args, **kwargs  — они представляют аргументы  func , которые могут быть или не быть.
  2.  Записывает время как  t0  .
  3.  Выполняет  func  с  *args, **kwargs  и сохраняет результат.
  4.  Измеряет время, прошедшее с  t0  .
  5.  Обращается к родительской области с помощью  nonlocal  для получения переменных  total_time  и  запускает  . Ключевое слово  nonlocal  объявляет, что  timer()  не создает здесь новых значений, а пытается захватить  нелокальных .
  6.  Добавляет единицу к  запусков  , добавляет прошедшее время к  total_time  .
  7.  Печатает прошедшее время -  истекло  .
  8.  Выводит среднее время работы -  (total_time/runs)  .
    No related posts.