Time sleep python 3: Python 3 — time sleep() Method

sleep() задержка программы в Python

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

Содержание статьи

• Вызов sleep() через time.sleep()
• Вызов sleep() с декораторами
• Вызов sleep() в потоках
• Использование time.sleep() в threading
• Использование Event.wait() в многопоточности Python
• Вызов sleep() в Async IO
• Вызов sleep() в Tkinter и wxPython
• Метод after() — Погружение в сон для Tkinter
• Метод CallLater() — Погружение в сон для wxPython Python

В Python есть возможность вызвать функцию sleep() для симуляции задержки в выполнении программы. Быть может, вам нужно дождаться загрузки, скачивания или появления графического объекта на экране. Также может потребоваться сделать паузу между вызовами к веб API или запросами к базе данных. В таких случаях поможет добавление вызова функции sleep() в программу.

Главные аспекты данного руководства по вызову sleep() в Python:

• time.sleep();
• Декораторы;
• Потоки;
• Async IO;
• Графический пользовательский интерфейс GUI.

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

Вызов sleep() через time.sleep()

В Python есть встроенная поддержка для погружения программы в сон. У модуля time есть функция sleep(), что позволяет отсрочить выполнение вызываемого потока на указанное количество секунд.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Python Форум Помощи

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

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

Подписаться

Далее дан пример использования time.sleep():

import time time.sleep(3) # Сон в 3 секунды

При запуске кода из консоли, задержку нужно проводить перед вводом нового оператора в REPL.

На заметку: В Python 3.5 разработчики слегка изменили поведение time.sleep(). Благодаря новой системе вызова sleep() эффект отсрочки будет длиться как минимум на продолжении указанного количества секунд, даже в том случае, если сон прерывается сигналом. Однако, это не касается случаев, если сигнал является признаком вызова исключения.

Вы можете протестировать, как долго продлиться сон с помощью модуля Python timeit:

$ python3 -m timeit -n 3 «import time; time.sleep(3)» 3 loops, best of 3: 3 sec per loop

Здесь модуль timeit запускается с параметром -n, что указывает timeit, сколько раз выполнять последующий оператор. Можно заметить, что timeit выполнил оператор 3 раза, а лучшее время длилось 3 секунды, чего и следовало ожидать.

По умолчанию timeit

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

Python

import time import urllib.request import urllib.error def uptime_bot(url): while True: try: conn = urllib.request.urlopen(url) except urllib.error.HTTPError as e: # Отправка admin / log print(f’HTTPError: {e.code} для {url}’) except urllib.error.URLError as e: # Отправка admin / log print(f’URLError: {e.code} для {url}’) else: # Сайт поднят print(f'{url} поднят’) time.sleep(60) if __name__ == ‘__main__’: url = ‘http://www.google.com/py’ uptime_bot(url)

Здесь создается uptime_bot(), что принимает URL в качестве аргумента. Затем функция пытается открыть данный URL c urllib. При возникновении HTTPError или URLError программа перехватывает ошибку и выводит на экран. На практике вам, скорее всего, придется

Если ошибок нет, код спокойно выполняется. Вне зависимости от того, что произойдет, программа уходит в сон на 60 секунд. Это значит, что доступ к сайту будет раз за минуту. URL, используемый в примере, содержит ошибки. Ежеминутный вывод на консоли выглядит следующим образом:

HTTPError: 404 для http://www.google.com/py

Попробуйте обновить код, используя проверенный хороший URL, к примеру https://www.google.com/. После этого вы можете перезапустить программу и проверить, что изменилось. Также можно попробовать обновить код для отправки сообщения или записи об ошибке. Для получения более подробной информации можете ознакомиться со статьями отправка писем smtp и логирование.

Вызов sleep() с декораторами

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

Другим возможным случаем использования sleep() является необходимость проверки состояния пользовательского интерфейса во время автоматического теста. В зависимости от компьютера, на котором запускается тест, пользовательский интерфейс может грузиться быстрее или медленнее обычного. Это может изменить отображаемое на экране во время проверки программой чего-то.

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

Для добавления системного вызова sleep() в Python можно использовать

Python

import time import urllib.request import urllib. error def sleep(timeout, retry=3): def the_real_decorator(function): def wrapper(*args, **kwargs): retries = 0 while retries < retry: try: value = function(*args, **kwargs) if value is None: return except: print(f’Сон на {timeout} секунд’) time.sleep(timeout) retries += 1 return wrapper return the_real_decorator

sleep() является вашим декоратором. Он принимает значение timeout и количество раз для повтора retry, что по умолчанию равняется 3. Внутри sleep() есть другая функция, the_real_decorator()

В конечном итоге самая внутренняя функция wrapper() принимает аргументы и ключевые слова, которые вы передаете декорируемой функции. Здесь все и происходит! Используется цикл while, чтобы повторить вызов функции. Если возникла ошибка, вызывается time.sleep(), увеличивается счетчик попыток retries и повторяется попытка запуска функции.

Теперь переписывается uptime_bot()  для использования нового декоратора:

Python

@sleep(3) def uptime_bot(url): try: conn = urllib. request.urlopen(url) except urllib.error.HTTPError as e: # Отправка admin / log print(f’HTTPError: {e.code} для {url}’) # Повторное поднятие ошибки исключения для декоратора raise urllib.error.HTTPError except urllib.error.URLError as e: # Отправка admin / log print(f’URLError: {e.code} для {url}’) # Повторное поднятие ошибки исключения для декоратора raise urllib.error.URLError else: # Сайт поднят print(f'{url} поднят’) if __name__ == ‘__main__’: url = ‘http://www.google.com/py’ uptime_bot(url)

Здесь вы декорируете uptime_bot() с помощью sleep() в 3 секунды. Вы также удалили оригинальный цикл while и старый вызов sleep(60). Декоратор теперь позаботится об этом.

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

На заметку: При желании более подробно узнать о том, как справляться с исключениями в Python, можете ознакомиться со статьей: Обработка исключений в Python

Декоратору можно добавить несколько улучшений. Если число попыток заканчивается, и он по-прежнему проваливается, тогда можно сделать так, чтобы он повторно вызвал последнюю ошибку. Декоратор подождет 3 секунды после последней неудачи, что не всегда нужно. Можете попробовать поэкспериментировать самостоятельно.

Вызов sleep() в потоках

Могут возникнуть ситуации, когда в Python требуется добавить вызов sleep() для потока. К примеру, запуск скрипта миграции для базы данных с миллионами записей. Здесь важно избежать простоя, а также не ждать дольше необходимого для завершения миграции, поэтому можно использовать потоки.

На заметку: Потоки являются одним из методов использования конкурентности в Python. Можно запустить несколько потоков одновременно, чтобы увеличить производительность приложения. Если потоки в Python являются для вас новой темой, ознакомьтесь со статьей модуль threading.

Чтобы клиенты не замечали какого-либо замедления, каждый поток должен работать в течение короткого периода времени, а затем уходить в сон. Есть два способа сделать это:

1. Использовать time.sleep() как ранее;
2. Использовать Event.wait() из модуля threading;

Начнем с разбора time.sleep().

Использование time.sleep() в threading

Python Logging Cookbook является хорошим примером использования time.sleep(). Модуль логирования logging является потоко-безопасным, поэтому в данном примере он будет полезнее, чем операторы print(). В основе следующего кода лежит данный пример:

Python

import logging import threading import time def worker(arg): while not arg[«stop»]: logging.debug(«рабочий поток вносится») time.sleep(1) def main(): logging.basicConfig( level=logging.DEBUG, format=»%(relativeCreated)6d %(threadName)s %(message)s» ) info = {«stop»: False} thread = threading.Thread(target=worker, args=(info,)) thread_two = threading.Thread(target=worker, args=(info,)) thread.start() thread_two.start() while True: try: logging.debug(«Добавление из главного потока») time.sleep(0.75) except KeyboardInterrupt: info[«stop»] = True logging.debug(‘Остановка’) break thread.join() thread_two.join() if __name__ == «__main__»: main()

Здесь для создания двух потоков используется модуль Python threading. Также создается объект входа, что будет вводить threadName в stdout. Ctrl+C.

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

2 Thread-1 рабочий поток вносится 4 Thread-2 рабочий поток вносится 4 MainThread Добавление из главного потока 755 MainThread Добавление из главного потока 1004 Thread-1 рабочий поток вносится 1006 Thread-2 рабочий поток вносится 1506 MainThread Добавление из главного потока 2005 Thread-1 рабочий поток вносится 2007 Thread-2 рабочий поток вносится 2257 MainThread Добавление из главного потока 3007 Thread-1 рабочий поток вносится 3008 MainThread Добавление из главного потока

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

Использование Event.wait() в многопоточности Python

Модуль threading предоставляет Event(), которого можно использовать как time.sleep(). Однако преимущество Event() в том, что он более отзывчив. Причина в том, что когда событие установлено, программа сразу выходит из цикла. В Python с time.sleep() коду надо будет подождать завершения вызова sleep() до выхода из потока.

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

Далее показан пример добавления в Python вызова sleep() с Event.wait():

Python

import logging import threading def worker(event): while not event.isSet(): logging.debug(«рабочий поток вносится») event.wait(1) def main(): logging.basicConfig( level=logging.DEBUG, format=»%(relativeCreated)6d %(threadName)s %(message)s» ) event = threading.Event() thread = threading.Thread(target=worker, args=(event,)) thread_two = threading.Thread(target=worker, args=(event,)) thread.start() thread_two.start() while not event.isSet(): try: logging.debug(«Добавление из главного потока») event.wait(0.75) except KeyboardInterrupt: event.set() break if __name__ == «__main__»: main()

В данном примере создается threading.Event() и передается к worker(). Вспомните, что в предыдущем примере вместо этого передавался словарь. Ctrl+C. Как только событие установлено, worker() вернется, и цикл оборвется, завершив программу.

На заметку: При желании подробнее узнать о словарях в Python можете ознакомиться со статьей по работе со словарями в Python на примерах.

Рассмотрите подробнее код выше. Как бы вы передали разное время сна каждому работающему потоку? Справитесь с задачей? Не бойтесь экспериментировать!

Вызов sleep() с Async IO на примерах

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

Модуль asyncio позволяет добавлять в Python вызов sleep() асинхронно.

Вот пример, данный в официальной документации Python:

Python

import asyncio async def main(): print(‘Hello . ..’) await asyncio.sleep(1) print(‘… World!’) # Python 3.7+ asyncio.run(main())

В данном примере запускается main(), что погружается в сон на секунду между двумя вызовами print().

Вот более подробный пример из раздела о Сопрограммах и задачах документации asyncio:

Python

import asyncio import time async def output(sleep, text): await asyncio.sleep(sleep) print(text) async def main(): print(f»Started: {time.strftime(‘%X’)}») await output(1, ‘First’) await output(2, ‘Second’) await output(3, ‘Third’) print(f»Ended: {time.strftime(‘%X’)}») # Python 3. 7+ asyncio.run(main())

В данном коде создается рабочий поток output(), что принимает количество секунд для sleep и выводит text. После этого используется ключевое слово Python await для ожидания запуска кода output(). Здесь требуется await, так как output() был отмечен как функция async, и теперь не может вызываться как обычная функция.

При запуске кода программа выполнит await 3 раза. Код будет ждать 1, 2 и 3 секунды, общее время ожидания равно 6 секундам. Можно также переписать код таким образом, чтобы задачи выполнялись параллельно:

Python

import asyncio import time async def output(text, sleep): while sleep > 0: await asyncio.sleep(1) print(f'{text} counter: {sleep} seconds’) sleep -= 1 async def main(): task_1 = asyncio.create_task(output(‘First’, 1)) task_2 = asyncio.create_task(output(‘Second’, 2)) task_3 = asyncio.create_task(output(‘Third’, 3)) print(f»Started: {time.strftime(‘%X’)}») await task_1 await task_2 await task_3 print(f»Ended: {time.strftime(‘%X’)}») if __name__ == ‘__main__’: asyncio.run(main())

Теперь вы используете концепт задач, что можно создать через create_task(). При использовании задач в asyncio Python будет запускать задачи асинхронно. Таким образом, выполнение программы завершится через 3 секунды вместо 6.

Вызов sleep() в Tkinter и wxPython

Вызовы sleep() в Python можно добавить не только для приложений командной строки. При создании графического пользовательского интерфейса (GUI) периодически нужно добавлять отсрочки. К примеру, при создании приложения FTP для скачивания около миллиона файлов будет разумно добавить вызов sleep() между партиями, чтобы снизить нагрузку на сервер.

GUI код выполнит всю обработку в основном потоке, называемом циклом обработки событий, или event loop. При использовании time.sleep() внутри кода GUI заблокируется цикл обработки событий.

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

К счастью, помимо time.sleep(), можно использовать некоторые другие методы специально для этой задачи. Далее мы рассмотрим, как добавить вызовы sleep() в Tkinter и wxPython.

Метод after() — Погружение в сон для Tkinter

tkinter является частью стандартной библиотеки Python. В случае, если вы используете заранее установленную версию Python на Linux или Mac, он может быть вам недоступен. При получении ошибки ImportError стоит самостоятельно добавить его в систему. В том случае, если вы ранее установили Python сами, tkinter должен быть доступен.

Начнем с разбора примера, где используется time.sleep(). Запустите следующий код и посмотрите, что произойдет при неправильном добавлении вызова sleep() в Python:

Python

import tkinter import time class MyApp: def __init__(self, parent): self.root = parent self.root.geometry(«400×400″) self.frame = tkinter.Frame(parent) self.frame.pack() b = tkinter.Button(text=»click me», command=self.delayed) b.pack() def delayed(self): time. sleep(3) if __name__ == «__main__»: root = tkinter.Tk() app = MyApp(root) root.mainloop()

После запуска кода нажмите кнопку в GUI. Кнопка не будет реагировать три секунды, ожидая завершения sleep(). Если в приложении есть другие кнопки, на них тоже нельзя будет нажать. Закрыть приложение во время сна нельзя, так как оно не будет откликаться на событие закрытия.

Для должного погружения tkinter в сон потребуется использовать after():

Python

import tkinter class MyApp: def __init__(self, parent): self.root = parent self.root.geometry(«400×400») self.frame = tkinter.Frame(parent) self.frame.pack() self.root.after(3000, self.delayed) def delayed(self): print(‘Я задержался’) if __name__ == «__main__»: root = tkinter.Tk() app = MyApp(root) root.mainloop()

Здесь создается приложение, высота которого 400 пикселей, и ширина также 400 пикселей. На нем нет виджетов. Оно только показывает фрейм. Затем вызывается self.root.after(), где self.root является отсылкой к объекту Tk(). after() принимает два аргумента:

1. Количество миллисекунд для сна;
2. Метод который вызовется после завершения сна.

В данном случае приложение выведет строку в стандартный поток вывода (stdout) через 3 секунды. Можно рассматривать after() как Tkinter-версию того же time.sleep(), только он добавляет способность вызова функции после завершения сна.

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

Метод CallLater() — Погружение в сон для wxPython Python

Между wxPython и Tkinter есть два важных различия:

1. В wxPython намного больше виджетов;
2. wxPython стремится выглядеть нативным на любой платформе.

Фреймворк wxPython не поставляется с Python вместе, поэтому его нужно установить wxPython самостоятельно. Если вы не знакомы с wxPython, можете изучить курс из 55 уроков по wxPython.

Для добавления вызова sleep() в wxPython можно использовать wx.CallLater():

Python

import wx class MyFrame(wx.Frame): def __init__(self): super().__init__(parent=None, title=’Привет, мир!’) wx. CallLater(4000, self.delayed) self.Show() def delayed(self): print(‘Я задержался’) if __name__ == ‘__main__’: app = wx.App() frame = MyFrame() app.MainLoop()

Здесь напрямую создается подкласс wx.Frame и затем вызывается wx.CallLater(). Данная функция принимает такие же параметры, что и after() в Tkinter:

1. Количество миллисекунд для сна;
2. Метод который вызовется сразу после завершения сна.

При запуске данного кода появится небольшое пустое окно без виджетов. Через 4 секунды в стандартном потоке вывода (stdout) появится строка 'Я задержался'.

Одним из преимуществ wx.CallLater() является его поточная безопасность. Данный метод можно использовать внутри потока для вызова функции, что в основном приложении wxPython.

Заключение

В данном руководстве вы познакомились с новой полезной техникой для работы в Python. Теперь вы знаете, как добавить задержку для ускорения работы приложений и предотвращения использование ими системных ресурсов. Вы также можете использовать вызовы Python sleep(), чтобы помочь графическому интерфейсу GUI работать более эффективно. Все это может усовершенствовать опыт пользователя при работе в приложении.

Подведем итоги. Основные, рассмотренные в статье инструменты, для добавления вызовов sleep() в Python:

• time.sleep();
• Декораторы;
• Потоки;
• asyncio;
• Tkinter;
• wxPython;

Теперь вы можете использовать полученные знания и погружать ваш код на Python в сон.

Vasile Buldumac

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

• 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
• 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Использование метода Python time.sleep() — pythobyte.com

Автор оригинала: Pankaj Kumar.

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

Метод Python time.sleep() используется для остановки выполнения текущей программы/потока на заданное время.

Текущая программа/поток по существу ничего не делает в этот период времени, поэтому он “спит” в течение этого периода времени, прежде чем вернуться из своего текущего состояния.

Давайте посмотрим, как мы можем использовать эту функцию.

Использование Python time.sleep()

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

import time

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

import time
num_seconds = 5
print('Going to sleep for', str(num_seconds), 'seconds') 
time.sleep(num_seconds)
print('Woke up after', str(num_seconds), 'seconds')

Выход

Going to sleep for 5 seconds
Woke up after 5 seconds

Если вы попробуете это на своем компьютере, ваша программа остановится на 5 секунд между двумя выходами, так как она спит в течение этого времени.

Мы также можем указать количество секунд в качестве числа с плавающей запятой, чтобы мы могли спать в течение 0.001 секунды (1 миллисекунда) или даже 0.0000001 секунды (1 микросекунда).

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

import time
num_millis = 2
print('Going to sleep for', str(num_millis), 'milliseconds') 
time.sleep(num_millis / 1000)
print('Woke up after', str(num_millis), 'milliseconds')

Выход

Going to sleep for 2 milliseconds
Woke up after 2 milliseconds

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

Давайте проверим ваше фактическое время сна в приведенной выше программе.

import time
num_millis = 2
print('Going to sleep for', str(num_millis), 'milliseconds')
# Start timer
start_time = time.time() 
time.sleep(num_millis / 1000)
# End timer
end_time = time.time()
print('Woke up after', str(end_time - start_time), 'seconds')

Выход

Going to sleep for 2 milliseconds
Woke up after 0. 0020711421966552734 seconds

Здесь время не составляет ровно 2 миллисекунды, как вы можете видеть. Речь идет о 2.071 миллисекунды, что немного больше, чем это.

Это связано с некоторыми задержками в выделении ресурсов, планировании процессов и т. Д. Из операционной системы, Что может вызвать небольшую задержку.

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

Переменная временная задержка для time.sleep()

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

import time
delays = [1, 1. 5, 2]
for delay in delays:
    print('Sleeping for', delay, 'seconds')
    time.sleep(delay)

Выход

Sleeping for 1 seconds
Sleeping for 1.5 seconds
Sleeping for 2 seconds

Теперь, когда мы рассмотрели использование time.sleep() для нашей программы, мы можем сделать то же самое и для потоков.

Использование Python time.sleep() в потоке

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

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

import time
from threading import Thread
class Worker(Thread):
    # Entry point after thread.start() is invoked
    def run(self):
        for i in range(4):
            print('Worker Thread', i)
            time.sleep(i + 1)
class Waiter(Thread):
    def run(self):
        for i in range(10, 15):
            print('Waiter thread', i)
            time.sleep(i - 9)
print('Starting Worker Thread....')
Worker().start()
print('Starting Waiter Thread....')
Waiter().start()
print('Main thread finished!')

Выход

Starting Worker Thread. ...
Worker Thread 0
Starting Waiter Thread....
Waiter thread 10
Main thread finished!
Worker Thread 1
Waiter thread 11
Worker Thread 2
Waiter thread 12
Worker Thread 3
Waiter thread 13
Waiter thread 14

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

Вывод

В этой статье мы узнали об использовании функции Python time.sleep() различными способами.

Рекомендации

• Статья JournalDev вовремя.сон()
• Документация по Python

Изучаем модуль time в Python 3

2022-03-16

Модуль time в Python 3 обеспечивает доступ к нескольким различным типам, каждые из которых применяются для разных целей. Функция monotonic() может использоваться для измерения прошедшего времени в длительном процессе. Она никогда не уменьшает значение времени, даже если изменяется системное время.

Для тестирования производительности perf_counter() обеспечивает доступ к таймерам с самым высоким дроблением единиц времени для более точного измерения. Время CPU доступно через clock(), а process_time() возвращает комбинированное значение времени процессора и системы.

• Обратите внимание
• Сравнение часов
• Основной таймер в Python
• Таймер относительного времени
• Таймер процессора
  • Примечание
• Счетчик производительности
• Компоненты времени
• Работа с часовыми поясами
• Обработка и форматирование времени

В реализациях представлены функции библиотеки C для управления датами и временем. Поскольку они связаны с базовой реализацией языка C, некоторые элементы (такие как начало эпохи и максимальное значение даты) зависят от платформы. Подробную информацию смотрите в документации к библиотеке.

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

time_get_clock_info.py
import textwrap
import time
available_clocks = [
    ('clock', time.clock),
    ('monotonic', time.monotonic),
    ('perf_counter', time.perf_counter),
    ('process_time', time.process_time),
    ('time', time.time),
]
for clock_name, func in available_clocks:
    print(textwrap.dedent('''
    {name}:
        adjustable    : {info.adjustable}
        implementation: {info.implementation}
        monotonic     : {info.monotonic}
        resolution    : {info.resolution}
        current       : {current}
    ''').format(
        name=clock_name,
        info=time.get_clock_info(clock_name),
        current=func())
    )

Этот вывод для Mac OS X показывает, что Python time таймеры monotonic и perf_counter реализованы с использованием одного и того же базового системного вызова:

$ python3 time_get_clock_info. py
clock:
    adjustable    : False
    implementation: clock()
    monotonic     : True
    resolution    : 1e-06
    current       : 0.028399
monotonic:
    adjustable    : False
    implementation: mach_absolute_time()
    monotonic     : True
    resolution    : 1e-09
    current       : 172336.002232467
perf_counter:
    adjustable    : False
    implementation: mach_absolute_time()
    monotonic     : True
    resolution    : 1e-09
    current       : 172336.002280763
process_time:
    adjustable    : False
    implementation: getrusage(RUSAGE_SELF)
    monotonic     : True
    resolution    : 1e-06
    current       : 0.028593
time:
    adjustable    : True
    implementation: gettimeofday()
    monotonic     : False
    resolution    : 1e-06
    current       : 1471198232.045526

Одной из функций, которую предоставляет модуль time Python  является функция time(), которая возвращает количество секунд с момента начала «эпохи» в виде значения с плавающей запятой:

time_time. py
import time
print('The time is:', time.time())

Эпоха — это начало измерения времени, которым для систем Unix является 0:00 1 января 1970 года. Хотя значение всегда является числом с плавающей запятой, фактическая точность зависит от платформы:

$ python3 time_time.py
The time is: 1471198232.091589

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

$ python3 time_ctime.py
The time is      : Sun Aug 14 14:10:32 2016
15 secs from now : Sun Aug 14 14:10:47 2016

Второй вызов print() в этом примере иллюстрирует, как использовать ctime() для форматирования значения времени, которое отличается от текущего:

$ python3 time_ctime.py
The time is      : Sun Aug 14 14:10:32 2016
15 secs from now : Sun Aug 14 14:10:47 2016

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

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

time_monotonic.py
import time
start = time.monotonic()
time.sleep(0.1)
end = time.monotonic()
print('start : {:>9.2f}'.format(start))
print('end   : {:>9.2f}'.format(end))
print('span  : {:>9.2f}'.format(end - start))

Начальная точка для относительных таймеров не определена, поэтому возвращаемые значения могут использоваться только для расчетов с другими значениями времени. В этом примере продолжительность спящего режима измеряется с помощью monotonic():

$ python3 time_monotonic.py
start : 172336.14
end   : 172336.24
span  :      0.10

В то время как time() возвращает время основных часов, clock() возвращает время процессора. Для этого можно использовать Python get time.

Значения, возвращаемые функцией clock(), отражают фактическое время, используемое программой при ее запуске:

time_clock.py
import hashlib
import time
# Данные, используемые для вычисления контрольной суммы md5
data = open(__file__, 'rb').read()
for i in range(5):
    h = hashlib.sha1()
    print(time.ctime(), ': {:0.3f} {:0.3f}'.format(
        time.time(), time.clock()))
    for i in range(300000):
        h.update(data)
    cksum = h.digest()

В этом примере отформатированная ctime() выводится вместе со значениями с плавающей запятой из time() и clock() через цикл для каждой итерации.

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

$ python3 time_clock.py
Sun Aug 14 14:10:32 2016 : 1471198232.327 0.033
Sun Aug 14 14:10:32 2016 : 1471198232. 705 0.409
Sun Aug 14 14:10:33 2016 : 1471198233.086 0.787
Sun Aug 14 14:10:33 2016 : 1471198233.466 1.166
Sun Aug 14 14:10:33 2016 : 1471198233.842 1.540

Как правило, часы процессора ничего не засекают, если программа ничего не делает:

time_clock_sleep.py
import time
template = '{} - {:0.2f} - {:0.2f}'
print(template.format(
    time.ctime(), time.time(), time.clock())
)
for i in range(3, 0, -1):
    print('Sleeping', i)
    time.sleep(i)
    print(template.format(
        time.ctime(), time.time(), time.clock())
    )

В этом примере  time sleep python цикл выполняет мало действий, переходя в спящий режим после каждой итерации. Значение time() увеличивается даже тогда, когда приложение находится в спящем режиме, но значение clock() отсутствует:

$ python3 -u time_clock_sleep.py
Sun Aug 14 14:10:34 2016 - 1471198234.28 - 0.03
Sleeping 3
Sun Aug 14 14:10:37 2016 - 1471198237.28 - 0.03
Sleeping 2
Sun Aug 14 14:10:39 2016 - 1471198239.29 - 0.03
Sleeping 1
Sun Aug 14 14:10:40 2016 - 1471198240. 29 - 0.03

Вызов sleep() передает управление из текущего потока и указывает ожидать, пока система активирует его. Если программа имеет только один поток, это эффективно блокирует приложение, и оно не работает.

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

time_perf_counter.py
import hashlib
import time
# Data to use to calculate md5 checksums
data = open(__file__, 'rb').read()
loop_start = time.perf_counter()
for i in range(5):
    iter_start = time.perf_counter()
    h = hashlib.sha1()
    for i in range(300000):
        h.update(data)
    cksum = h.digest()
    now = time.perf_counter()
    loop_elapsed = now - loop_start
    iter_elapsed = now - iter_start
    print(time.ctime(), ': {:0.3f} {:0.3f}'.format(
        iter_elapsed, loop_elapsed))

Как и в случае с функцией Python time monotonic(), эпоха для perf_counter() не определяется. Значения предназначены для сравнения и вычисления, а не в качестве абсолютных значений:

$ python3 time_perf_counter.py
Sun Aug 14 14:10:40 2016 : 0.487 0.487
Sun Aug 14 14:10:41 2016 : 0.485 0.973
Sun Aug 14 14:10:41 2016 : 0.494 1.466
Sun Aug 14 14:10:42 2016 : 0.487 1.953
Sun Aug 14 14:10:42 2016 : 0.480 2.434

Хранимое в виде прошедших секунд время используется в некоторых ситуациях. Но иногда программа должна иметь доступ к отдельным полям даты (год, месяц и т. д.). Модуль времени определяет struct_time для хранения значений даты и времени с разбитыми компонентами, поэтому они легко доступны. Существует несколько функций, которые работают со значениями struct_time вместо float:

time_struct.py
import time
def show_struct(s):
    print('  tm_year :', s.tm_year)
    print('  tm_mon  :', s.tm_mon)
    print('  tm_mday :', s.tm_mday)
    print('  tm_hour :', s.tm_hour)
    print('  tm_min  :', s.tm_min)
    print('  tm_sec  :', s.tm_sec)
    print('  tm_wday :', s. tm_wday)
    print('  tm_yday :', s.tm_yday)
    print('  tm_isdst:', s.tm_isdst)
print('gmtime:')
show_struct(time.gmtime())
print('nlocaltime:')
show_struct(time.localtime())
print('nmktime:', time.mktime(time.localtime()))

Функция gmtime(), которую предоставляет модуль time Python  возвращает текущее время в UTC. Localtime() возвращает текущее время с использованием текущего часового пояса. Mktime() принимает struct_time и преобразует его в формат с плавающей запятой:

$ python3 time_struct.py
gmtime:
  tm_year : 2016
  tm_mon  : 8
  tm_mday : 14
  tm_hour : 18
  tm_min  : 10
  tm_sec  : 42
  tm_wday : 6
  tm_yday : 227
  tm_isdst: 0
localtime:
  tm_year : 2016
  tm_mon  : 8
  tm_mday : 14
  tm_hour : 14
  tm_min  : 10
  tm_sec  : 42
  tm_wday : 6
  tm_yday : 227
  tm_isdst: 1
mktime: 1471198242.0

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

Чтобы изменить часовой пояс, установите переменную среды TZ, затем вызовите tzset(). Часовой пояс можно указать с различными данными, вплоть до времени начала и завершения периода так называемого «летнего» времени. Проще всего использовать название часового пояса, но базовые библиотеки получают и другую информацию.

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

time_timezone.py
import time
import os
def show_zone_info():
    print('  TZ    :', os.environ.get('TZ', '(not set)'))
    print('  tzname:', time.tzname)
    print('  Zone  : {} ({})'.format(
        time.timezone, (time.timezone / 3600)))
    print('  DST   :', time.daylight)
    print('  Time  :', time.ctime())
    print()
print('Default :')
show_zone_info()
ZONES = [
    'GMT',
    'Europe/Amsterdam',
]
for zone in ZONES:
    os.environ['TZ'] = zone
    time.tzset()
    print(zone, ':')
    show_zone_info()

Часовой пояс по умолчанию для системы, используемой в примерах — US / Eastern. Другие зоны в примере, который позволяет реализовать  модуль time Python изменяют значение tzname, продолжительности светового дня и значение смещения часового пояса:

$ python3 time_timezone.py
Default :
  TZ    : (not set)
  tzname: ('EST', 'EDT')
  Zone  : 18000 (5.0)
  DST   : 1
  Time  : Sun Aug 14 14:10:42 2016
GMT :
  TZ    : GMT
  tzname: ('GMT', 'GMT')
  Zone  : 0 (0.0)
  DST   : 0
  Time  : Sun Aug 14 18:10:42 2016
Europe/Amsterdam :
  TZ    : Europe/Amsterdam
  tzname: ('CET', 'CEST')
  Zone  : -3600 (-1.0)
  DST   : 1
  Time  : Sun Aug 14 20:10:42 2016

Функции strptime() и strftime() преобразуют struct_time в строковые представления значений времени и наоборот. Существует длинный список инструкций по форматированию для поддержки ввода и вывода в разных форматах. Полный список указан в документации библиотеки для модуля time.

В приведенном ниже примере использования модуля time Python текущее время преобразуется из строки в экземпляр struct_time и обратно в строку:

time_strptime. py
import time
def show_struct(s):
    print('  tm_year :', s.tm_year)
    print('  tm_mon  :', s.tm_mon)
    print('  tm_mday :', s.tm_mday)
    print('  tm_hour :', s.tm_hour)
    print('  tm_min  :', s.tm_min)
    print('  tm_sec  :', s.tm_sec)
    print('  tm_wday :', s.tm_wday)
    print('  tm_yday :', s.tm_yday)
    print('  tm_isdst:', s.tm_isdst)
now = time.ctime(1483391847.433716)
print('Now:', now)
parsed = time.strptime(now)
print('nParsed:')
show_struct(parsed)
print('nFormatted:',
      time.strftime("%a %b %d %H:%M:%S %Y", parsed))

В примере с time strftime Python строка вывода не такая же, как и входная, так как день месяца имеет префикс с нулем:

$ python3 time_strptime.py
Now: Mon Jan  2 16:17:27 2017
Parsed:
  tm_year : 2017
  tm_mon  : 1
  tm_mday : 2
  tm_hour : 16
  tm_min  : 17
  tm_sec  : 27
  tm_wday : 0
  tm_yday : 2
  tm_isdst: -1
Formatted: Mon Jan 02 16:17:27 2017

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

Вадим Дворниковавтор-переводчик статьи «time — Clock Time»

как добавить задержки в ваш код

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

Например, вы можете использовать вызов Pythonsleep() для имитации задержки в вашей программе. Возможно, вам нужно подождать, пока файл будет загружен или загружен, или изображение будет загружено или выведено на экран. Возможно, вам даже понадобится сделать паузу между вызовами веб-API или между запросами к базе данных. Добавление вызовов Pythonsleep() в вашу программу может помочь в каждом из этих и многих других случаев!

В этом руководстве вы узнаете, как добавить вызовы Pythonsleep() с помощью:

Эта статья предназначена для разработчиков среднего уровня, которые хотят расширить свои знания Python. Если это звучит как вы, тогда давайте начнем!

Free Bonus:Get our free «The Power of Python Decorators» guide, который показывает вам 3 продвинутых шаблона декоратора и техники, которые вы можете использовать для написания более чистых и дополнительных программ Pythonic.

Добавление вызова Python

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

Вот пример использованияtime.sleep():

>>>

>>> import time
>>> time.sleep(3) # Sleep for 3 seconds

Если вы запустите этот код в своей консоли, то у вас должна возникнуть задержка, прежде чем вы сможете ввести новый оператор в REPL.

Note: В Python 3.5 разработчики ядра немного изменили поведениеtime.sleep(). Новый системный вызов Pythonsleep() будет длиться по крайней мере указанное вами количество секунд, даже если сон прерывается сигналом. Однако это не применяется, если сам сигнал вызывает исключение.

Вы можете проверить, как долго длится сон, используя модуль Pythontimeit:

$ python3 -m timeit -n 3 "import time; time. sleep(3)"
3 loops, best of 3: 3 sec per loop

Здесь вы запускаете модульtimeit с параметром-n, который сообщаетtimeit, сколько раз выполнять следующий оператор. Вы можете видеть, чтоtimeit выполнил оператор 3 раза и что лучшее время выполнения было 3 секунды, что и ожидалось.

По умолчаниюtimeit запускает ваш код один миллион раз. Если бы вы запускали приведенный выше код со значением по умолчанию-n, то через 3 секунды на итерацию ваш терминал зависал бы примерно на 34 дня! Модульtimeit имеет несколько других параметров командной строки, которые вы можете проверить в егоdocumentation.

Давайте создадим что-то более реалистичное. Системный администратор должен знать, когда один из их веб-сайтов выходит из строя. Вы хотите регулярно проверять код состояния веб-сайта, но не можете постоянно запрашивать веб-сервер, иначе это повлияет на производительность. Один из способов выполнить эту проверку — использовать системный вызов Pythonsleep():

import time
import urllib. request
import urllib.error
def uptime_bot(url):
    while True:
        try:
            conn = urllib.request.urlopen(url)
        except urllib.error.HTTPError as e:
            # Email admin / log
            print(f'HTTPError: {e.code} for {url}')
        except urllib.error.URLError as e:
            # Email admin / log
            print(f'URLError: {e.code} for {url}')
        else:
            # Website is up
            print(f'{url} is up')
        time.sleep(60)
if __name__ == '__main__':
    url = 'http://www.google.com/py'
    uptime_bot(url)

Здесь вы создаетеuptime_bot(), который принимает URL-адрес в качестве аргумента. Затем функция пытается открыть этот URL с помощьюurllib. Если естьHTTPError илиURLError, то программа улавливает их и выводит ошибку. (В реальной среде вы могли бы зарегистрировать ошибку и, возможно, отправить электронное письмо веб-мастеру или системному администратору.)

Если ошибок не возникает, то ваш код распечатывает, что все хорошо. Независимо от того, что произойдет, ваша программа будет спать 60 секунд. Это означает, что вы заходите на сайт только раз в минуту. URL, используемый в этом примере, неверен, поэтому он будет выводить на вашу консоль каждую минуту:

HTTPError: 404 for http://www.google.com/py

Идите вперед и обновите код, чтобы использовать заведомо исправный URL, напримерhttp://www.google.com. Затем вы можете повторно запустить его, чтобы увидеть, как он работает успешно. Вы также можете попробовать обновить код, чтобы отправить электронное письмо или зарегистрировать ошибки. Для получения дополнительной информации о том, как это сделать, ознакомьтесь сSending Emails With Python иLogging in Python.

Добавление вызова Python

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

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

В этом случае я могу попросить программу немного поспать, а затем перепроверить через секунду или две. Это может означать разницу между прохождением и провалом теста.

Вы можете использоватьdecorator для добавления системного вызова Pythonsleep() в любом из этих случаев. Если вы не знакомы с декораторами или хотите освежить их в памяти, попробуйтеPrimer on Python Decorators. Давайте посмотрим на пример:

import time
import urllib. request
import urllib.error
def sleep(timeout, retry=3):
    def the_real_decorator(function):
        def wrapper(*args, **kwargs):
            retries = 0
            while retries 

sleep() — ваш декоратор. Он принимает значениеtimeout и количество раз, которое должно бытьretry, которое по умолчанию равно 3. Внутриsleep() находится другая функция,the_real_decorator(), которая принимает декорированную функцию.

Наконец, самая внутренняя функцияwrapper() принимает аргументы и аргументы ключевого слова, которые вы передаете декорированной функции. Здесь происходит волшебство! Вы используете циклwhile, чтобы повторить попытку вызова функции. Если есть исключение, вы вызываетеtime.sleep(), увеличиваете счетчикretries и снова пытаетесь запустить функцию.

Теперь перепишитеuptime_bot(), чтобы использовать новый декоратор:

@sleep(3)
def uptime_bot(url):
    try:
        conn = urllib. request.urlopen(url)
    except urllib.error.HTTPError as e:
        # Email admin / log
        print(f'HTTPError: {e.code} for {url}')
        # Re-raise the exception for the decorator
        raise urllib.error.HTTPError
    except urllib.error.URLError as e:
        # Email admin / log
        print(f'URLError: {e.code} for {url}')
        # Re-raise the exception for the decorator
        raise urllib.error.URLError
    else:
        # Website is up
        print(f'{url} is up')
if __name__ == '__main__':
    url = 'http://www.google.com/py'
    uptime_bot(url)

Здесь вы украшаетеuptime_bot() 3-секунднымsleep(). Вы также удалили исходный циклwhile, а также старый вызовsleep(60). Декоратор теперь позаботится об этом.

Еще одно изменение, которое вы сделали, — это добавлениеraise внутри блоков обработки исключений. Это так, что декоратор будет работать правильно. Вы можете написать декоратор для обработки этих ошибок, но поскольку эти исключения применяются только кurllib, возможно, вам лучше оставить декоратор таким, какой он есть. Таким образом, он будет работать с более широким спектром функций.

Note: Если вы хотите освежить в памяти обработку исключений в Python, посмотритеPython Exceptions: An Introduction.

Есть несколько улучшений, которые вы можете сделать в своем декораторе. Если у него заканчиваются повторные попытки и все равно происходит сбой, вы можете повторно вызвать последнюю ошибку. Декоратор также будет ждать 3 секунды после последнего сбоя, что может и не происходить. Не стесняйтесь попробовать их в качестве упражнения!

Добавление вызова Python

Также бывают случаи, когда вы можете захотеть добавить вызов Pythonsleep() кthread. Возможно, вы запускаете сценарий миграции для базы данных с миллионами записей в производстве. Вы не хотите вызывать простои, но также не хотите ждать дольше, чем необходимо, чтобы завершить миграцию, поэтому вы решили использовать потоки.

Note: Потоки — это метод выполненияconcurrency в Python. Вы можете запустить несколько потоков одновременно, чтобы увеличить производительность вашего приложения. Если вы не знакомы с потоками в Python, попробуйтеAn Intro to Threading in Python.

Чтобы клиенты не замечали какого-либо замедления, каждый поток должен работать в течение короткого периода времени, а затем находиться в спящем режиме. Есть два способа сделать это:

1. Используйтеtime.sleep(), как и раньше.

2. ИспользуйтеEvent.wait() из модуляthreading.

Начнем сtime.sleep().

Используя

PythonLogging Cookbook показывает хороший пример, который используетtime.sleep(). Модуль Pythonlogging является потокобезопасным, поэтому для этого упражнения он немного полезнее, чем операторыprint(). Следующий код основан на этом примере:

import logging
import threading
import time
def worker(arg):
    while not arg["stop"]:
        logging. debug("worker thread checking in")
        time.sleep(1)
def main():
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(relativeCreated)6d %(threadName)s %(message)s"
    )
    info = {"stop": False}
    thread = threading.Thread(target=worker, args=(info,))
    thread_two = threading.Thread(target=worker, args=(info,))
    thread.start()
    thread_two.start()
    while True:
        try:
            logging.debug("Checking in from main thread")
            time.sleep(0.75)
        except KeyboardInterrupt:
            info["stop"] = True
            logging.debug('Stopping')
            break
    thread.join()
    thread_two.join()
if __name__ == "__main__":
    main()

Здесь вы используете модуль Pythonthreading для создания двух потоков. Вы также создаете объект регистрации, который будет регистрироватьthreadName в stdout. Затем вы запускаете оба потока и запускаете цикл для регистрации в основном потоке. Вы используетеKeyboardInterrupt, чтобы поймать пользователя, нажимающегоCtrl+[. kbd .key-c]#C #.

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

 0 Thread-1 worker thread checking in
 1 Thread-2 worker thread checking in
 1 MainThread Checking in from main thread
752 MainThread Checking in from main thread
1001 Thread-1 worker thread checking in
1001 Thread-2 worker thread checking in
1502 MainThread Checking in from main thread
2003 Thread-1 worker thread checking in
2003 Thread-2 worker thread checking in
2253 MainThread Checking in from main thread
3005 Thread-1 worker thread checking in
3005 MainThread Checking in from main thread
3005 Thread-2 worker thread checking in

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

Используя

Модульthreading предоставляетEvent(), который вы можете использовать какtime. sleep(). Однако уEvent() есть дополнительное преимущество — он более отзывчивый. Причина этого заключается в том, что когда событие установлено, программа немедленно выходит из цикла. Сtime.sleep() ваш код должен будет дождаться завершения вызова Pythonsleep(), прежде чем поток сможет выйти.

Причина, по которой вы хотите использовать здесьwait(), заключается в том, чтоwait() — этоnon-blocking, аtime.sleep() — этоblocking. Это означает, что когда вы используетеtime.sleep(), вы блокируете продолжение работы основного потока, пока он ожидает завершения вызоваsleep(). wait() решает эту проблему. Вы можете узнать больше о том, как все это работает, вthreading documentation Python.

Вот как добавить вызов Pythonsleep() сEvent.wait():

import logging
import threading
def worker(event):
    while not event. isSet():
        logging.debug("worker thread checking in")
        event.wait(1)
def main():
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(relativeCreated)6d %(threadName)s %(message)s"
    )
    event = threading.Event()
    thread = threading.Thread(target=worker, args=(event,))
    thread_two = threading.Thread(target=worker, args=(event,))
    thread.start()
    thread_two.start()
    while not event.isSet():
        try:
            logging.debug("Checking in from main thread")
            event.wait(0.75)
        except KeyboardInterrupt:
            event.set()
            break
if __name__ == "__main__":
    main()

В этом примере вы создаетеthreading.Event() и передаете егоworker(). (Вспомните, что в предыдущем примере вы вместо этого передали словарь.) Затем вы настраиваете свои циклы, чтобы проверить, установлен лиevent. Если это не так, то ваш код печатает сообщение и немного ждет, прежде чем проверять снова. Чтобы установить событие, вы можете нажать [.keys] #Ctrl [.kbd .key-c] # C ##. Как только событие установлено, `+ worker ()` вернется, и цикл прервется, завершив программу.

Note: Если вы хотите узнать больше о словарях, посмотритеDictionaries in Python.

Присмотритесь к блоку кода выше. Как бы вы передавали разное время сна каждому рабочему потоку? Вы можете понять это? Не стесняйтесь решать это упражнение самостоятельно!

Добавление вызова Python

Асинхронные возможности были добавлены в Python в версии 3.4, и с тех пор этот набор функций активно расширяется. Asynchronous programming — это тип параллельного программирования, позволяющий запускать несколько задач одновременно. Когда задача заканчивается, она уведомляет основной поток.

asyncio — это модуль, который позволяет вам асинхронно добавлять вызов Pythonsleep(). Если вы не знакомы с реализацией асинхронного программирования в Python, обратите внимание наAsync IO in Python: A Complete Walkthrough иPython Concurrency & Parallel Programming.

Вот пример изdocumentation Python:

import asyncio
async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')
# Python 3.7+
asyncio.run(main())

В этом примере вы запускаетеmain(), и он находится в спящем режиме на одну секунду между двумя вызовамиprint().

Вот более убедительный пример из разделаCoroutines and Tasks документацииasyncio:

import asyncio
import time
async def output(sleep, text):
    await asyncio.sleep(sleep)
    print(text)
async def main():
    print(f"Started: {time.strftime('%X')}")
    await output(1, 'First')
    await output(2, 'Second')
    await output(3, 'Third')
    print(f"Ended: {time.strftime('%X')}")
# Python 3.7+
asyncio.run(main())

В этом коде вы создаете воркера с именемoutput(), которому требуется количество секунд доsleep иtext для печати. Затем вы используете ключевое слово Pythonawait, чтобы дождаться запуска кодаoutput(). Здесь требуетсяawait, потому чтоoutput() отмечен как функцияasync, поэтому вы не можете вызывать ее, как обычную функцию.

Когда вы запустите этот код, ваша программа выполнитawait 3 раза. Код будет ждать 1, 2 и 3 секунды, а общее время ожидания составит 6 секунд. Вы также можете переписать код так, чтобы задачи выполнялись параллельно:

import asyncio
import time
async def output(text, sleep):
    while sleep > 0:
        await asyncio.sleep(1)
        print(f'{text} counter: {sleep} seconds')
        sleep -= 1
async def main():
    task_1 = asyncio.create_task(output('First', 1))
    task_2 = asyncio.create_task(output('Second', 2))
    task_3 = asyncio.create_task(output('Third', 3))
    print(f"Started: {time.strftime('%X')}")
    await task_1
    await task_2
    await task_3
    print(f"Ended: {time.strftime('%X')}")
if __name__ == '__main__':
    asyncio.run(main())

Теперь вы используете концепциюtasks, которую можно создать с помощьюcreate_task(). Когда вы используете задачи вasyncio, Python будет запускать задачи асинхронно. Таким образом, когда вы запускаете приведенный выше код, он должен завершиться всего за 3 секунды вместо 6.

Добавление вызова Python

Приложения командной строки — не единственное место, где вам может потребоваться добавить вызовы Pythonsleep(). Когда вы создаетеGraphical User Interface (GUI), вам иногда нужно добавлять задержки. Например, вы можете создать приложение FTP для загрузки миллионов файлов, но вам нужно добавить вызовsleep() между пакетами, чтобы не перегружать сервер.

Код GUI будет выполнять всю свою обработку и рисование в основном потоке, называемомevent loop. Если вы используетеtime.sleep() внутри кода графического интерфейса пользователя, вы заблокируете его цикл обработки событий. С точки зрения пользователя, приложение может зависнуть. Пользователь не сможет взаимодействовать с вашим приложением, пока оно спит с этим методом. (В Windows вы можете даже получить предупреждение о том, что ваше приложение теперь не отвечает.)

К счастью, помимоtime.sleep() вы можете использовать и другие методы. В следующих нескольких разделах вы узнаете, как добавлять вызовы Pythonsleep() как в Tkinter, так и в wxPython.

Спать в Ткинтере

tkinter является частью стандартной библиотеки Python. Он может быть недоступен, если вы используете предустановленную версию Python для Linux или Mac. Если вы получилиImportError, вам нужно будет подумать, как добавить его в свою систему. Но если выinstall Python yourself, тоtkinter уже должен быть доступен.

Вы начнете с рассмотрения примера, в котором используетсяtime.sleep(). Запустите этот код, чтобы увидеть, что произойдет, если вы неправильно добавите вызов Pythonsleep():

import tkinter
import time
class MyApp:
    def __init__(self, parent):
        self. root = parent
        self.root.geometry("400x400")
        self.frame = tkinter.Frame(parent)
        self.frame.pack()
        b = tkinter.Button(text="click me", command=self.delayed)
        b.pack()
    def delayed(self):
        time.sleep(3)
if __name__ == "__main__":
    root = tkinter.Tk()
    app = MyApp(root)
    root.mainloop()

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

Чтобыtkinter нормально засыпал, вам нужно использоватьafter():

import tkinter
class MyApp:
    def __init__(self, parent):
        self.root = parent
        self.root.geometry("400x400")
        self.frame = tkinter.Frame(parent)
        self.frame.pack()
        self.root. after(3000, self.delayed)
    def delayed(self):
        print('I was delayed')
if __name__ == "__main__":
    root = tkinter.Tk()
    app = MyApp(root)
    root.mainloop()

Здесь вы создаете приложение шириной 400 пикселей и высотой 400 пикселей. На нем нет виджетов. Все, что он будет делать, это показать кадр. Затем вы вызываетеself.root.after(), гдеself.root — ссылка на объектTk(). after() принимает два аргумента:

1. Количество миллисекунд для сна

2. Метод для вызова, когда сон закончен

В этом случае ваше приложение напечатает строку в стандартный вывод через 3 секунды. Вы можете думать оafter() как о версииtkinter дляtime.sleep(), но она также добавляет возможность вызова функции после завершения сна.

Вы можете использовать эту функцию для улучшения пользовательского опыта. Добавив вызов Pythonsleep(), вы можете заставить приложение загружаться быстрее, а затем запустить какой-то более длительный процесс после его запуска. Таким образом, пользователю не нужно ждать открытия приложения.

Спать в wxPython

Есть два основных различия между wxPython и Tkinter:

1. У wxPython есть много других виджетов.

2. wxPython стремится выглядеть и чувствовать себя родным на всех платформах.

Инфраструктура wxPython не входит в состав Python, поэтому вам необходимо установить ее самостоятельно. Если вы не знакомы с wxPython, попробуйтеHow to Build a Python GUI Application With wxPython.

В wxPython вы можете использоватьwx.CallLater() для добавления вызова Pythonsleep():

import wx
class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Hello World')
        wx.CallLater(4000, self.delayed)
        self.Show()
    def delayed(self):
        print('I was delayed')
if __name__ == '__main__':
    app = wx.App()
    frame = MyFrame()
    app.MainLoop()

Здесь вы создаете подклассwx. Frame напрямую, а затем вызываетеwx.CallLater(). Эта функция принимает те же параметры, что иafter() Tkinter:

1. Количество миллисекунд для сна

2. Метод для вызова, когда сон закончен

Когда вы запустите этот код, вы увидите маленькое пустое окно без каких-либо виджетов. Через 4 секунды вы увидите строку'I was delayed', выведенную на стандартный вывод.

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

Заключение

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

Напомним, вы узнали, как добавлять вызовы Pythonsleep() с помощью следующих инструментов:

• time.sleep()

• Декораторы

• Потоки

• asyncio

• Tkinter

• WxPython

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

Модуль time в Python 3. Главные методы, шаблоны, примеры

Автор Амина С. На чтение 8 мин Опубликовано 26.05.2021

Почти любая программа использует время. В Python для этого разработана отдельная библиотека – time, применяемая с целью выполнения самых различных действий с ним. Чтобы сделать его работу возможной, его надо сперва объявить в начале кода. Для этого используется такая строчка:

import time

Рассмотрим разные варианты, как правильно использовать этот модуль на практике.  

Содержание

1. Определение количества секунд со старта эпохи
2. Возвращение даты, времени в привычном формате
3. Класс time.struct_time
4. Возвращение конкретного формата
5. Отложить поток на определенное количество секунд
6. Получить локальное время
7. Возврат struct_time в UTC на основе количества секунд со старта эпохи
8. Возврат количества секунд со старта эпохи с автоматической конвертацией в локальное время
9. Вывод даты из 9 чисел, которые относятся к struct_time
10. Получение времени и даты на основе строки Python

Определение количества секунд со старта эпохи

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

Что касается Windows, то дата такая же самая, но могут быть проблемы с отрицательными значениями, которые были до этого числа.  

Используемый часовой пояс – UTC.

import time

seconds = time.time()

print(«Секунды с начала эпохи =», seconds)

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

Возвращение даты, времени в привычном формате

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

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

Вот фрагмент кода, который это демонстрирует.

import time

print(time.ctime())

Tue Oct 23 10:18:23 2018

Последняя строчка – это то, что выводится в консоль, где запущен интерпретатор Python. Метод автоматически форматирует полученное количество секунд в привычный для пользователя вид. Правда, редко используются все элементы, описанные выше. Как правило, нужно получить или только времени, или исключительно сегодняшнее число. Для этого используется отдельная функция – strftime(). Но перед тем, как мы ее рассмотрим, необходимо разобрать класс time.struct_time.

Класс time.struct_time

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

Он состоит из следующих атрибутов.

Внимание! В отличие от ряда других языков программирования, здесь месяц может колебаться в диапазоне от 1 до 12, а не от нуля до 11.

Возвращение конкретного формата

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

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

Вот фрагмент кода, где мы это делаем.

import time

named_tuple = time.localtime() # получить struct_time

time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», named_tuple)

print(time_string)

Если запустить этот код, будет выведена текущая дата и время. Формат и последовательность элементов можно изменять. Они бывают следующими:

1. %Y – год.
2. %m – месяц.
3. %d – день.
4. %H – час.
5. %M – минута.
6. %S – секунда.

Соответственно, можно сделать так, чтобы вывод был исключительно месяца и дня. Для этого просто не надо давать команду выводить год. То есть, записать в приведенной выше формуле в качестве аргумента %m/%d, и все. Или же наоборот, %d/%m. 

На самом деле, количество строковых литералов значительно больше. Приведем таблицу, где они детально описаны.

Отложить поток на определенное количество секунд

Для этого используется функция sleep(). С течением времени связан довольно большой блок программерских задач. Иногда приходится откладывать следующий шаг на определенное время. Например, если требуется взаимодействовать с базой данных, обработка которых занимает определенное время.

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

Например, в этом фрагменте задержка составляет 10 сек.

import time

pause = 10

print(«Program started…»)

time.sleep(pause)

print(str(pause) + » seconds passed.»)

В результате мы получим такое:

Program started…

10 seconds passed.

Как мы видим по выводу, сначала программа отчитывается о том, что она стартовала. А по прошествии десяти секунд написала, что это время прошло.

Функция позволяет указать длительность паузы в миллисекундах. Для этого используем дробные значения аргумента функции sleep. Например, 0,1. Это означает, что задержка составит 100 миллисекунд.

Получить локальное время

С помощью функции localtime() программа получает число секунд со старта эпохи в определенном часовом поясе. 

Приведем пример кода для наглядности.

import time

result = time.localtime(1575721830)

print(«результат:», result)

print(«\nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

Возврат struct_time в UTC на основе количества секунд со старта эпохи

Эта задача достигается с помощью метода time.gmtime().. Нагляднее будет, если привести пример.

import time

result = time. gmtime(1575721830)

print(«результат:», result)

print(«\nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

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

Возврат количества секунд со старта эпохи с автоматической конвертацией в локальное время

Если стоит перед вами такая задача, она реализуется с помощью метода mktime(), который принимает struct_time. После этого она выполняет обратное действие функции localtime(). То есть, превращает время по локальному часовому поясу в число секунд, которые прошли со старта эпохи с поправкой на часовой пояс.

Функции mktime() и localtime() тесно переплетены между собой. Этот фрагмент кода наглядно демонстрирует это. Давайте рассмотрим его, чтобы более глубоко понимать, как это работает. 

import time

seconds = 1575721830

# возвращает struct_time

t = time. localtime(seconds)

print(«t1: «, t)

# возвращает секунды из struct_time

s = time.mktime(t)

print(«\ns:», seconds)

Видим, что переменной seconds было присвоено 1575721830 секунд с начала эпохи. Сначала программа получает точную дату, время и другие параметры, основываясь на этом значении, поместила его в переменную t, после чего конвертирует ее содержимое в переменную s.

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

Вывод даты из 9 чисел, которые относятся к struct_time

Предположим, у нас есть 9 чисел, которые обозначают год, месяц, число, день недели и ряд других значений, и нам необходимо их объединить в одну строку. Для этого используется функция asctime(). Она принимает или готовый struct_time, или любой другой кортеж из 9 значений, который обозначает то же самое. После этого возвращается строка, которая являет собой дату, время и ряд других параметров. 

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

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

Получение времени и даты на основе строки Python

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

Она принимает переменную, в которой указано это значение, а возвращает уже знакомый нам struct_time.

Для наглядности напишем такую программу.

import time

time_string = «15 June, 2019»

result = time.strptime(time_string, «%d %B, %Y»)

print(result)

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

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

Одним словом, работать с датой и временем в Python вовсе несложно. Достаточно следовать этим инструкциям, и все будет получаться. С помощью библиотеки time пользователь получает огромное количество возможностей по работе со временем, таких как:

1. Приостанавливать выполнение программы на определенное время.
2. Показывать время, которое прошло с начала эпохи, в секундах. Эта информация может использоваться для суммирования времени или выполнения других математических операций с ним.
3. Осуществлять конвертацию до удобного формата. Причем программист может сам задавать, какие элементы будут отображаться и в какой последовательности. 

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

Оцените качество статьи. Нам важно ваше мнение:

Главные методы модуля time в python 3, шаблоны и примеры ~ PythonRu

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

import time

Дальше перечислены самые распространенные функции, связанные со временем.

Python time.time()

Функция time() возвращает число секунд, прошедших с начала эпохи. Для операционных систем Unix 1 января 1970, 00:00:00 (UTC) — начало эпохи (момент, с которого время пошло).

import time
seconds = time.time()
print("Секунды с начала эпохи =", seconds)

Python time.

Функция time.ctime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает строку, представляющую собой местное время.

import time
# секунды прошли с эпох
seconds = 1575721830.711298
local_time = time.ctime(seconds)
print("Местное время:", local_time)

Если запустить программу, то вывод будет выглядеть так:

Местное время: Sat Dec  7 14:31:36 2019

Python time.sleep()

Функция sleep() откладывает исполнение текущего потока на данное количество секунд.

import time
print("Сейчас.")
time.sleep(2.4)
print("Через 2.4 секунды.")

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

Класс time.struct_time

Некоторые функции в модуле time, такие как gmtime(), asctime() и другие, принимают объект time.struct_time в качестве аргумента или возвращают его.

Вот пример объекта time.struct_time.

К значениям (элементам) объекта time.struct_time доступ можно получить как с помощью индексов, так и через атрибуты.

Python time.localtime()

Функция localtime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает stuct_time в локальном времени.

import time
result = time.localtime(1575721830)
print("результат:", result)
print("\nгод:", result.tm_year)
print("tm_hour:", result.tm_hour)

Вывод этой программы будет следующим:

result: time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=14, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)
year: 2019
tm_hour: 14

Если localtime() передан аргумент None, то вернется значение из time().

Python time.gmtime()

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

import time
result = time.gmtime(1575721830)
print("результат:", result)
print("\nгод:", result.tm_year)
print("tm_hour:", result.tm_hour)

Вывод этой программы будет следующим:

result: time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=12, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)
year: 2019
tm_hour: 12

Если gmtime() передан аргумент None, то вернется значение time().

Python time.mktime()

Функция mktime() принимает struct_time (или кортеж, содержащий 9 значений, относящихся к struct_time) в качестве аргумента и возвращает количество секунд, прошедших с начала эпохи, в местном времени. Это функция, обратная localtime().

import time
t = (2019, 12, 7, 14, 30, 30, 5, 341, 0)
local_time = time.mktime(t)
print("Местное время:", local_time)

Следующий пример показывает, как связаны mktime() и localtime().

import time
seconds = 1575721830
# возвращает struct_time
t = time.localtime(seconds)
print("t1: ", t)
# возвращает секунды из struct_time
s = time.mktime(t)
print("\ns:", seconds)

Вывод будет следующий:

t1:  time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=14, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)
s: 1575721830

Python time.asctime()

Функция asctime() принимает struct_time (или кортеж, содержащий 9 значений, относящихся к struct_time) в качестве аргумента и возвращает строку, представляющую собой дату.

Например:

import time
t = (2019, 12, 7, 14, 30, 30, 5, 341, 0)
result = time.asctime(t)
print("Результат:", result)

Вывод:

Результат: Sat Dec  7 14:30:30 2019

Python time.strftime()

Функция strftime принимает stuct_time (или соответствующий кортеж) в качестве аргумента и возвращает строку с датой в зависимости от использованного формата. Например:

import time
named_tuple = time.localtime() # получить struct_time
time_string = time.strftime("%m/%d/%Y, %H:%M:%S", named_tuple)
print(time_string)

Вывод будет следующий:

12/07/2019, 15:01:09

Здесь %Y, %m, %d, %H и другие — элементы форматирования.

• %Y — год [0001,…, 2019, 2020,…, 9999]
• %m — месяц [01, 02, …, 11, 12]
• %d — день [01, 02, …, 30, 31]
• %H — час [00, 01, …, 22, 23
• %M — минута [00, 01, …, 58, 59]
• %S — секунда [00, 01, …, 58, 61]

Python time.

Функция strptime() делает разбор строки python, в которой упоминается время и возвращает struct_time.

import time
time_string = "15 June, 2019"
result = time.strptime(time_string, "%d %B, %Y")
print(result)

Вывод:

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

time — Доступ к времени и преобразование — Документация по Python 3.10.7

Этот модуль предоставляет различные функции, связанные со временем. Для связанных см. также модули datetime и calendar .

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

Необходимо пояснение некоторых терминов и соглашений.

• Эпоха — точка начала времени и платформа зависимый. Для Unix эпоха — 1 января 1970 года, 00:00:00 (UTC). Чтобы узнать, какая эпоха на данной платформе, посмотрите на время.gmtime(0) .

• Термин секунд с эпохи относится к общему числу прошедших секунд с начала эпохи, обычно исключая високосные секунды. Високосные секунды исключаются из этого общего количества на всех POSIX-совместимые платформы.

• Функция strptime() может анализировать 2-значные годы, если задан формат %y код. Когда анализируются двузначные годы, они преобразуются в соответствии с POSIX. и стандарты ISO C: значения 69–99 сопоставлены с 1969–1999 гг., а значения 0–68 привязаны к 2000–2068 гг.

• Летнее время — переход на летнее время, корректировка часового пояса (обычно) на единицу час в течение части года. Правила перехода на летнее время являются магическими (определяются местным законодательством) и может меняться из года в год. В библиотеке C есть таблица, содержащая локальные правил (часто читается из системного файла для гибкости) и является единственным источник Истинной Мудрости в этом отношении.

• Точность различных функций реального времени может быть меньше, чем предлагается единицы, в которых выражается их значение или аргумент. Например. на большинстве Unix систем часы «тикают» только 50 или 100 раз в секунду.

• С другой стороны, точность time() и sleep() лучше чем их эквиваленты в Unix: время выражается числами с плавающей запятой, time() возвращает наиболее точное доступное время (используя Unix gettimeofday() , если доступно), и sleep() примет время с ненулевой дробью (для реализации этого используется Unix select() , где доступный).

• Значение времени, возвращаемое gmtime() , localtime() , и strptime() и принимается asctime() , mktime() и strftime() — это последовательность из 9 целых чисел. Возвращаемые значения гмтайм() , местное время() и strptime() также предлагают атрибут имена для отдельных полей.

  См. struct_time для описания этих объектов.

  Изменено в версии 3.3: Тип struct_time был расширен для предоставления tm_gmtoff . и атрибутов tm_zone , если платформа поддерживает соответствующие структура тм членов.

  Изменено в версии 3.6: struct_time атрибуты tm_gmtoff и тм_зона теперь доступны на всех платформах.

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

  Из	До	Применение
  секунды с начала эпохи	struct_time в UTC	гмвремя()
  секунды с начала эпохи	struct_time в местное время	местное время()
  struct_time в UTC	секунды с начала эпохи	календарь. timegm()
  struct_time в местное время	секунды с начала эпохи	мктайм()

Функции

раз. asctime ([ т ])

Преобразовать кортеж или struct_time , представляющий время, возвращаемое gmtime() или localtime() в строку из следующего форма: 'Вс, 20 июня 23:21:05 1993' . Поле дня состоит из двух символов. и дополняется пробелом, если день представляет собой одну цифру, например: 'Ср, 9 июня 04:26:40 1993' .

Если t не указан, текущее время возвращается функцией localtime() используется. Информация о локали не используется asctime() .

Примечание

В отличие от одноименной функции C, asctime() не добавляет завершающая новая строка.

раз. pthread_getcpuclockid ( thread_id )

Вернуть clk_id часов ЦП для конкретного потока для указанного thread_id .

Использовать threading.get_ident() или идентификатор атрибут threading.Thread объектов, чтобы получить подходящее значение для thread_id .

Предупреждение

Передача недопустимого или просроченного thread_id может привести к неопределенное поведение, такое как ошибка сегментации.

Доступность: Unix (см. справочную страницу для pthread_getcpuclockid(3) для дальнейшая информация).

Новое в версии 3.7.

раз. clock_getres ( clk_id )

Возвращает разрешение (точность) указанных часов clk_id . Ссылаться на Константы идентификатора часов для списка допустимых значений для clk_id .

Доступность: Unix.

Новое в версии 3.3.

раз. часы_gettime ( clk_id ) → число с плавающей запятой

Возвращает время указанных часов clk_id . Ссылаться на Константы идентификатора часов для списка допустимых значений для clk_id .

Используйте clock_gettime_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Доступность: Unix.

Новое в версии 3.3.

раз. clock_gettime_ns ( clk_id ) → целое число

Аналогично clock_gettime() , но возвращает время в наносекундах.

Доступность: Unix.

Новое в версии 3.7.

раз. clock_settime ( clk_id , время: float )

Установить время указанных часов clk_id . В настоящее время, CLOCK_REALTIME — единственное приемлемое значение для clk_id .

Использовать clock_settime_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Доступность: Unix.

Новое в версии 3.3.

раз. clock_settime_ns ( clk_id , время: int )

Аналогично clock_settime() , но устанавливает время в наносекундах.

Доступность: Unix.

Новое в версии 3.7.

раз. время ([ сек ])

Преобразование времени, выраженного в секундах, начиная с эпохи, в строку вида: 'Sun Jun 20 23:21:05 1993' представляет местное время. Поле дня состоит из двух символов и дополняется пробелом, если день представляет собой одну цифру, например: 'Среда 9 июня 04:26:40 1993' .

Если секунд не указано или Нет , текущее время как возвращается time() используется. ctime(secs) эквивалентно asctime(местное время(сек)) . Информация о локали не используется ctime() .

раз. get_clock_info ( имя )

Получить информацию об указанных часах как объект пространства имен. Поддерживаемые имена часов и соответствующие функции для чтения их значения являются:

• 'монотонный' : time.monotonic()

• 'perf_counter' : time.perf_counter()

• 'время_процесса' : время.время_процесса()

• 'thread_time' : time.thread_time()

• 'время' : время.время()

Результат имеет следующие атрибуты:

• регулируемый : True , если часы могут быть изменены автоматически (например, демон NTP) или вручную системным администратором, Ложь иначе

• реализация : Имя базовой функции C, используемой для получения значение часов. Возможные значения см. в разделе Константы идентификатора часов.

• монотонный : Истинно , если часы не могут идти назад, Ложь иначе

• разрешение : Разрешение часов в секундах ( float )

Новое в версии 3.3.

раз. гмвремя ([ сек ])

Преобразование времени, выраженного в секундах, начиная с эпохи, в struct_time в UTC, в котором флаг dst всегда равен нулю. Если секунд не указано или Нет , используется текущее время, возвращенное функцией time() . Фракции секунды игнорируются. См. выше описание struct_time объект. См. calendar.timegm() для инверсии этого функция.

раз. местное время ([ сек ])

Аналогично gmtime() , но преобразуется в местное время. Если секунд не указано или Нет , используется текущее время, возвращенное функцией time() . летнее время флаг устанавливается на 1 , когда летнее время применяется к данному времени.

localtime() может вызвать OverflowError , если отметка времени вне диапазона значений, поддерживаемых платформой C местное время() или gmtime() функций и OSError на localtime() или gmtime() сбой. Обычно это ограничивается годами между 1970 и 2038 годами.

раз. мктайм ( т )

Это обратная функция localtime() . Его аргументом является struct_time или полная 9-кортежность (поскольку требуется флаг dst; используйте -1 как флаг dst, если он неизвестен), который выражает время в формате местного времени , а не УНИВЕРСАЛЬНОЕ ГЛОБАЛЬНОЕ ВРЕМЯ. Он возвращает число с плавающей запятой для совместимости с time() . Если входное значение не может быть представлено как допустимое время, либо OverflowError или ValueError будет поднято (что зависит от будет ли недопустимое значение перехвачено Python или базовыми библиотеками C). Самая ранняя дата, для которой он может сгенерировать время, зависит от платформы.

раз. монотонный () → плавающий

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

Используйте monotonic_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Новое в версии 3.3.

Изменено в версии 3.5: Функция теперь всегда доступна и всегда общесистемна.

Изменено в версии 3.10: в macOS функция теперь общесистемная.

раз. monotonic_ns () → целое число

Аналогично monotonic() , но время возврата в наносекундах.

Новое в версии 3.7.

раз. perf_counter () → число с плавающей запятой

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

Используйте perf_counter_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Новое в версии 3.3.

Изменено в версии 3.10: В Windows функция теперь общесистемная.

раз. perf_counter_ns () → целое число

Аналогично perf_counter() , но время возврата в наносекундах.

Новое в версии 3.7.

раз. время_процесса () → число с плавающей запятой

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

Используйте process_time_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Новое в версии 3.3.

раз. process_time_ns () → целое число

Аналогично process_time() , но возвращает время в наносекундах.

Новое в версии 3. 7.

раз. сон ( сек )

Приостановить выполнение вызывающего потока на указанное количество секунд. Аргумент может быть числом с плавающей запятой, чтобы указать более точный режим сна. время. Фактическое время приостановки может быть меньше запрошенного, поскольку любой пойманный сигнал прервет sleep() после выполнения этого процедура захвата сигнала. Кроме того, время приостановки может быть больше, чем запрашивается произвольная сумма из-за планирования другой деятельности в системе.

Изменено в версии 3.5: Теперь функция спит не менее секунд , даже если сон прерывается сигналом, за исключением случаев, когда обработчик сигнала вызывает исключение (см. PEP 475 для обоснования).

раз. strftime ( формат [ t ])

Преобразовать кортеж или struct_time , представляющий время, возвращаемое gmtime() или localtime() в строку, указанную в формате аргумент. Если t не указан, текущее время, возвращенное используется localtime() . формат должен быть строкой. ValueError есть поднимается, если какое-либо поле в t находится за пределами допустимого диапазона.

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

Следующие директивы могут быть встроены в строку формата . Они показаны без дополнительной ширины поля и спецификации точности и заменяются указанными символами в strftime() результат:

Директива	Значение	Примечания
%а	Сокращенное название дня недели региона.
%А	Полное название дня недели региона.
%b	Сокращенное название месяца для региона.
%В	Полное название месяца для региона.
%с	Соответствующая дата и время региона представление.
%d	День месяца в виде десятичного числа [01,31].
%H	Час (24-часовой формат) в виде десятичного числа [00,23].
%I	Час (12-часовой формат) в виде десятичного числа [01,12].
%j	День года в виде десятичного числа [001,366].
%м	Месяц в виде десятичного числа [01,12].
%М	Минуты в виде десятичного числа [00,59].
%р	Региональный эквивалент AM или PM.	(1)
%S	Секунда в виде десятичного числа [00,61].	(2)
%U	Номер недели в году (воскресенье как первое день недели) в виде десятичного числа [00,53]. Все дни в новом году, предшествующие первому Воскресенье считается неделей 0.	(3)
% вес	День недели в виде десятичного числа [0(воскресенье),6].
%W	Номер недели года (понедельник как первый день недели) в виде десятичного числа [00,53]. Все дни в новом году, предшествующие первому Понедельник считается на неделе 0.	(3)
%х	Соответствующее представление даты локали.
%Х	Соответствующее представление времени локали.
%г	Год без века в виде десятичного числа [00,99].
%Y	Год с веком в виде десятичного числа.
%z	Смещение часового пояса, указывающее положительное или отрицательная разница во времени с UTC/GMT форма +ЧЧММ или -ЧЧММ, где H представляет собой десятичное число цифры часа, а M представляет десятичную минуту цифры [-23:59, +23:59]. 1
%Z	Название часового пояса (без символов, если нет часового пояса) существуют). Устарело. 1
%%	Литерал '%' символов.

Примечания:

1. При использовании с функцией strptime() директива %p влияет только на поле выходного часа, если для анализа часа используется директива %I .

2. Диапазон действительно составляет от 0 до 61 ; значение 60 действительно в метки времени, представляющие високосные секунды и значение 61 поддерживается по историческим причинам.

3. При использовании с функцией strptime() %U и %W используются только в вычисления, когда день недели и год указаны.

Вот пример, формат дат, совместимый с указанным в RFC 2822 Стандарт электронной почты в Интернете. 1

 >>> из времени импортировать gmtime, strftime
>>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
«Чт, 28 июня 2001 г., 14:17:15 +0000»
 

Дополнительные директивы могут поддерживаться на определенных платформах, но только перечисленные здесь имеют значение, стандартизированное ANSI C. Чтобы увидеть полный набор кодов форматов, поддерживаемых вашей платформой, см. в strftime(3) документация.

На некоторых платформах можно указать необязательную ширину поля и точность. сразу после начального '%' директивы в следующем порядке; это тоже не переносимо. Ширина поля обычно равна 2, кроме 9.0004 %j где это 3.

раз. strptime ( строка [ формат ])

Разобрать строку, представляющую время, в соответствии с форматом. Возвращаемое значение является struct_time , возвращенным gmtime() или местное время() .

Параметр формата использует те же директивы, что и strftime() ; по умолчанию "%a %b %d %H:%M:%S %Y" , что соответствует форматирование, возвращаемое ctime() . Если строка не может быть проанализирована в соответствии с в формат , или если он имеет лишние данные после синтаксического анализа, ValueError поднятый. Значения по умолчанию, используемые для заполнения любых отсутствующих данных, когда больше точные значения не могут быть выведены: (1900, 1, 1, 0, 0, 0, 0, 1, -1) . И строка , и формат должны быть строками.

Например:

 >>> время импорта
>>> time.strptime("30 ноября 00", "%d %b %y")
time.struct_time (tm_year = 2000, tm_mon = 11, tm_mday = 30, tm_hour = 0, tm_min = 0,
                 tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
 

Поддержка директивы %Z основана на значениях, содержащихся в tzname . и правда ли дневной свет . Из-за этого он зависит от платформы. за исключением признания UTC и GMT, которые всегда известны (и считаются быть часовыми поясами без перехода на летнее время).

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

класс время. время_структуры

Тип последовательности значений времени, возвращаемой функцией gmtime() , localtime() и strptime() . Это объект с именем Интерфейс кортежа: доступ к значениям можно получить по индексу и по имени атрибута. присутствуют следующие значения:

Индекс	Атрибут	Значения
0	tm_year	(например, 1993)
1	тм_мон	диапазон [1, 12]
2	tm_mday	диапазон [1, 31]
3	тм_час	диапазон [0, 23]
4	tm_min	диапазон [0, 59]
5	тм_сек	диапазон [0, 61]; см. (2) в strftime() описание
6	tm_wday	диапазон [0, 6], понедельник 0
7	tm_yday	диапазон [1, 366]
8	тм_исдст	0, 1 или -1; см. ниже
Н/Д	тм_зона	сокращение названия часового пояса
Н/Д	тм_гмтофф	смещение к востоку от UTC в секундах

Обратите внимание, что в отличие от структуры C, значение месяца представляет собой диапазон [1, 12], а не [0, 11].

При вызовах mktime() , tm_isdst может быть установлено в 1 при дневном свете действует экономия времени, и 0, когда это не так. Значение -1 указывает, что это неизвестно и обычно приводит к заполнению правильного состояния.

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

раз. время () → число с плавающей запятой

Возвращает время в секундах с начала эпохи в виде числа с плавающей запятой количество. Конкретная дата эпохи и обращение с високосные секунды зависят от платформы. В Windows и большинстве систем Unix это 1 января 19 года.70, 00:00:00 (UTC) и високосные секунды не засчитываются во время в секундах с начала эпохи. Это обычно называют Время Юникс. Чтобы узнать, какая эпоха на данной платформе, посмотрите на гмвремя(0) .

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

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

Используйте time_ns() , чтобы избежать потери точности, вызванной числом с плавающей запятой тип.

раз. time_ns () → целое число

Аналогично time() , но возвращает время как целое число наносекунд с эпохи.

Новое в версии 3.7.

раз. thread_time () → число с плавающей запятой

Возвращает значение (в долях секунды) суммы системы и пользователя Процессорное время текущего потока. Не включает время, прошедшее в течение спать. Он специфичен для потока по определению. Ориентир возвращаемое значение не определено, так что только разница между результатами двух вызовов в одном потоке является допустимым.

Используйте thread_time_ns() , чтобы избежать потери точности, вызванной плавающий тип .

Доступность: системы Windows, Linux, Unix с поддержкой CLOCK_THREAD_CPUTIME_ID .

Новое в версии 3.7.

раз. thread_time_ns () → целое число

Аналогично thread_time() , но возвращает время в наносекундах.

Новое в версии 3.7.

раз. цсет ()

Сбросить правила преобразования времени, используемые подпрограммами библиотеки. Окружение переменная TZ указывает, как это делается. Он также установит переменные tzname (из переменной среды TZ ), часовой пояс (не DST секунды к западу от UTC), альтзона (DST секунды к западу от UTC) и дневной свет (на 0, если в этом часовом поясе нет правил перехода на летнее время, или на ненулевое значение, если есть время, прошлое, настоящее или будущее, когда используется летнее время применяется).

Доступность: Unix.

Примечание

Хотя во многих случаях изменение переменной среды TZ может влияет на вывод функций, таких как localtime() , без вызова tzset() , на это поведение нельзя полагаться.

Переменная среды TZ не должна содержать пробелов.

Стандартный формат переменной среды TZ : (пробелы добавлено для ясности):

 стандартное смещение [dst [смещение [начало[/время], конец[/время]]]]
 

Где компоненты:

std и dst

Три или более буквенно-цифровых символов, обозначающих часовой пояс. Это будет распространено в time.tzname

смещение

Смещение имеет вид: ± чч[:мм[:сс]] . Это указывает на значение добавлено местное время для прибытия в UTC. Если перед ним стоит «-», часовой пояс находится к востоку от нулевого меридиана; в противном случае это запад. Если не следует смещение dst, предполагается, что летнее время на один час опережает стандартное время.

начало[/время], конец[/время]

Указывает, когда переходить на летнее время и обратно. Формат даты начала и окончания являются одним из следующих:

J n

Юлианский день n (1 <= n <= 365). Високосные дни не учитываются, поэтому в все годы 28 февраля — это 59-й день, а 1 марта — 60-й день.

n

Юлианский день с отсчетом от нуля (0 <= н <= 365). Високосные дни считаются, и можно сослаться на 29 февраля.

М м . и . д

д й день (0 <= д <= 6) недели н месяца м года (1 <= n <= 5, 1 <= m <= 12, где неделя 5 означает «последние d дней в месяц м », что может произойти либо в четвертом, либо в пятом неделя). Неделя 1 — это первая неделя, в течение которой d -й день происходит. День ноль — воскресенье.

время имеет тот же формат, что и смещение , за исключением того, что без начального знака (‘-’ или ‘+’) допускается. По умолчанию, если время не указано, 02:00:00.

 >>> os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0'
>>> время.tzset()
>>> time.strftime('%X %x %Z')
'02:07:36 08.05.03 по восточному поясному времени'
>>> os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
>>> время.tzset()
>>> time.strftime('%X %x %Z')
'16:08:12 08.05.03 AEST'
 

Во многих системах Unix (включая *BSD, Linux, Solaris и Darwin) более удобно использовать системную базу данных zoneinfo ( tzfile(5) ) для указать правила часового пояса. Для этого установите среду TZ переменная на путь к требуемому файлу данных часового пояса относительно корня системная база данных часовых поясов «zoneinfo», обычно расположенная по адресу /usr/доля/zoneinfo . Например, "США/Восток" , 'Австралия/Мельбурн' , «Египет» или «Европа/Амстердам» .

 >>> os.environ['TZ'] = 'США/Восток'
>>> время.tzset()
>>> время.tzname
(«EST», «EDT»)
>>> os.environ['TZ'] = 'Египет'
>>> время.tzset()
>>> время.tzname
(«ЕЕТ», «ВОСТОЧНОЕ»)
 

Константы идентификатора часов

Эти константы используются в качестве параметров для clock_getres() и часы_gettime() .

раз. CLOCK_BOOTTIME

Идентичен CLOCK_MONOTONIC , за исключением того, что включает любое время, которое система приостановлена.

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

Доступность: Linux 2.6.39 или более поздней версии.

Новое в версии 3.7.

раз. ЧАСЫ_ВЫСОКОЕ РАЗРЕШЕНИЕ

ОС Solaris имеет таймер CLOCK_HIGHRES , который пытается использовать оптимальную аппаратный источник и может давать разрешение, близкое к наносекундам. CLOCK_HIGHRES — нерегулируемые часы с высоким разрешением.

Наличие: Солярис.

Новое в версии 3.3.

раз. ЧАСЫ_МОНОТОНИК

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

Доступность: Unix.

Новое в версии 3.3.

раз. CLOCK_MONOTONIC_RAW

Аналогичен CLOCK_MONOTONIC , но обеспечивает доступ к аппаратное время, которое не подлежит настройке NTP.

Доступность: Linux 2. 6.28 и новее, macOS 10.12 и новее.

Новое в версии 3.3.

раз. CLOCK_PROCESS_CPUTIME_ID

Таймер высокого разрешения для каждого процесса от ЦП.

Доступность: Unix.

Новое в версии 3.3.

раз. ЧАСЫ_ПРОФ

Таймер высокого разрешения для каждого процесса от ЦП.

Доступность: FreeBSD, NetBSD 7 или выше, OpenBSD.

Новое в версии 3.7.

раз. ЧАСЫ_ТАИ

Международное атомное время

В системе должна быть текущая таблица дополнительных секунд, чтобы это давало правильный ответ. Программное обеспечение PTP или NTP может поддерживать таблицу дополнительных секунд.

Наличие: Linux.

Новое в версии 3.9.

раз. CLOCK_THREAD_CPUTIME_ID

Часы времени ЦП, зависящие от потока.

Доступность: Unix.

Новое в версии 3.3.

раз. CLOCK_UPTIME

Время, абсолютным значением которого является время, в течение которого система работала, а не приостановлено, обеспечивая точное измерение времени безотказной работы, как абсолютное, так и интервал.

Доступность: FreeBSD, OpenBSD 5.5 или выше.

Новое в версии 3.7.

раз. CLOCK_UPTIME_RAW

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

Доступность: macOS 10.12 и новее.

Новое в версии 3.8.

Следующая константа является единственным параметром, который может быть отправлен в часы_settime() .

раз. ЧАСЫ_РЕАЛЬНОЕ ВРЕМЯ

Общесистемные часы реального времени. Установка этих часов требует соответствующего привилегии.

Доступность: Unix.

Новое в версии 3.3.

Константы часового пояса

раз. альтзона

Смещение местного часового пояса летнего времени в секундах к западу от UTC, если оно определено. Это отрицательное значение, если местный часовой пояс DST находится восточнее UTC (как в Западной Европе, включая Великобританию). Используйте это только в том случае, если дневного света не равно нулю. См. примечание ниже.

раз. дневной свет

Ненулевое значение, если определен часовой пояс летнего времени. См. примечание ниже.

раз. часовой пояс

Смещение местного (не летнего) часового пояса в секундах к западу от UTC (отрицательное в большая часть Западной Европы, положительный результат в США, ноль в Великобритании). См. примечание ниже.

раз. имя

Кортеж из двух строк: первая — это имя местного часового пояса, отличного от DST, во-вторых, это название местного часового пояса DST. Если часовой пояс DST не определен, вторую строку использовать не следует. См. примечание ниже.

Примечание

Для вышеуказанных констант часового пояса ( altzone , дневной свет , часовой пояс , и tzname ), значение определяется действующими правилами часового пояса во время загрузки модуля или в последний раз, когда tzset() вызывается и может быть неправильным для времен в прошлом. Рекомендуется использовать tm_gmtoff и tm_zone является результатом localtime() для получения информации о часовом поясе.

См. также

Модуль datetime

Более объектно-ориентированный интерфейс для дат и времени.

Модуль языковой стандарт

Услуги интернационализации. Настройка локали влияет на интерпретацию многих спецификаторов формата в strftime() и strptime() .

Модуль календарь

Общие функции, связанные с календарем. timegm() — это инверсия gmtime() из этого модуля.

Сноски

1(1,2,3)

Использование %Z больше не рекомендуется, но escape-последовательность %z , которая расширяется до предпочтительное смещение час/минута поддерживается не всеми библиотеками ANSI C. Также строгое прочтение исходного стандарта 1982 RFC 822 требует двузначного год ( %y , а не %Y ), но практика перешла на 4-значные годы задолго до 2000 год. После этого RFC 822 устарел, и 4-значный год был сначала рекомендован RFC 1123 , а затем предписан RFC 2822 .

Как добавить временные задержки в ваш код — Real Python

Смотреть сейчас Это руководство содержит соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Использование sleep() для кодирования бота Python Uptime

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

Например, вы можете использовать вызов Python sleep() для имитации задержки в вашей программе. Возможно, вам нужно подождать, пока файл загрузится или скачается, или графика загрузится или отобразится на экране. Вам даже может понадобиться сделать паузу между вызовами веб-API или между запросами к базе данных. Добавление вызовов Python sleep() в вашу программу может помочь в каждом из этих и многих других случаев!

В этом руководстве вы узнаете, как добавить Python sleep() вызовов с:

• time. sleep()
• Декораторы
• Резьба
• Асинхронный ввод-вывод
• Графические интерфейсы пользователя

Эта статья предназначена для разработчиков среднего уровня, которые хотят расширить свои знания о Python. Если это похоже на вас, то давайте начнем!

Бесплатный бонус: Получите наше бесплатное руководство «Сила декораторов Python», в котором показаны три продвинутых шаблона и техники декораторов, которые вы можете использовать для написания более чистых и дополнительных программ Pythonic.

Добавление Python

 >>> время импорта
>>> time. sleep(3) # Сон на 3 секунды
 

 $ python3 -m timeit -n 3 "время импорта; time.sleep(3)"
3 петли, лучшая из 5: 3 сек на петлю
 

 время импорта
импортировать urllib.request
импортировать urllib.error
def uptime_bot (url):
    пока верно:
        пытаться:
            conn = urllib.request.urlopen(url)
        кроме urllib.error. HTTPError как e:
            # Электронная почта администратора / журнал
            print(f'HTTPError: {e.code} для {url}')
        кроме urllib.error.URLError как e:
            # Электронная почта администратора / журнал
            print(f'URLError: {e.code} для {url}')
        еще:
            # Сайт запущен
            print(f'{url} активен')
        время сна(60)
если __name__ == '__main__':
    URL = 'http://www.google.com/py'
    uptime_bot(ссылка)
 

 HTTPError: 404 для http://www.google.com/py
 

 время импорта
импортировать urllib.request
импортировать urllib.error
def sleep (время ожидания, повтор = 3):
    определить the_real_decorator (функция):
        обертка def (*args, **kwargs):
            повторы = 0
            в то время как попытки < повторить попытку:
                пытаться:
                    значение = функция (* аргументы, ** kwargs)
                    если значение равно None:
                        возвращаться
                кроме:
                    print(f'Сон в течение {timeout} секунд')
                    время сна (время ожидания)
                    повторы += 1
        возвратная упаковка
    вернуть the_real_decorator
 

 @сон(3)
def uptime_bot (url):
    пытаться:
        conn = urllib.request.urlopen(url)
    кроме urllib.error.HTTPError как e:
        # Электронная почта администратора / журнал
        print(f'HTTPError: {e.code} для {url}')
        # Повторно вызвать исключение для декоратора
        поднять urllib.error.HTTPError
    кроме urllib.error.URLError как e:
        # Электронная почта администратора / журнал
        print(f'URLError: {e.code} для {url}')
        # Повторно вызвать исключение для декоратора
        поднять urllib. error.URLError
    еще:
        # Сайт запущен
        print(f'{url} активен')
если __name__ == '__main__':
    URL = 'http://www.google.com/py'
    uptime_bot(ссылка)
 

 журнал импорта
импорт потоков
время импорта
деф рабочий (аргумент):
    пока не аргумент ["стоп"]:
        logging.debug("проверка рабочего потока")
        время сна(1)
деф основной():
    ведение журнала.basicConfig(
        уровень = ведение журнала. ОТЛАДКА,
        format="%(relativeCreated)6d %(threadName)s %(сообщение)s"
    )
    информация = {"стоп": ложь}
    thread = threading. Thread (цель = рабочий, аргументы = (информация,))
    thread_two = threading.Thread (цель = рабочий, аргументы = (информация,))
    поток.старт()
    thread_two.start()
    пока верно:
        пытаться:
            logging.debug("Регистрация из основного потока")
            время сна (0,75)
        кроме KeyboardInterrupt:
            информация["стоп"] = Истина
            logging.debug('Остановка')
            ломать
    поток.присоединиться()
    thread_two.join()
если __name__ == "__main__":
    главный()
 

 0 Проверка рабочего потока Thread-1
 1 Проверка рабочего потока Thread-2
 1 MainThread Проверка из основного потока
752 MainThread Регистрация из основного потока
1001 Проверка рабочего потока Thread-1
1001 Проверка рабочего потока Thread-2
1502 MainThread Регистрация из основного потока
2003 Проверка рабочего потока Thread-1
2003 Проверка рабочего потока Thread-2
2253 MainThread Регистрация из основного потока
3005 Проверка рабочего потока Thread-1
3005 MainThread Регистрация из основного потока
3005 Проверка рабочего потока Thread-2
 

 журнал импорта
импорт потоков
деф рабочий(событие):
    пока не event. isSet():
        logging.debug("проверка рабочего потока")
        событие.ожидание(1)
деф основной():
    ведение журнала.basicConfig(
        уровень = ведение журнала. ОТЛАДКА,
        format="%(relativeCreated)6d %(threadName)s %(сообщение)s"
    )
    событие = многопоточность.Событие()
    thread = threading.Thread (цель = рабочий, аргументы = (событие,))
    thread_two = threading.Thread (цель = рабочий, аргументы = (событие,))
    поток.старт()
    thread_two.start()
    пока не event.isSet():
        пытаться:
            logging.debug("Регистрация из основного потока")
            событие.ожидание(0,75)
        кроме KeyboardInterrupt:
            событие.set()
            ломать
если __name__ == "__main__":
    главный()
 

 асинхронный импорт
асинхронная функция main():
    print('Здравствуйте...')
    ждать asyncio.sleep(1)
    print('... Мир!')
# Питон 3.7+
asyncio.run(основной())
 

 асинхронный импорт
время импорта
вывод асинхронного определения (сон, текст):
    ожидание asyncio.sleep(сон)
    печать (текст)
асинхронная функция main():
    print(f"Начало: {time.strftime('%X')}")
    ожидание вывода(1, 'Первый')
    ждать вывода(2, 'Второй')
    ждать вывода(3, 'Третий')
    print(f"Завершено: {time. strftime('%X')}")
# Питон 3.7+
asyncio.run(основной())
 

 асинхронный импорт
время импорта
вывод асинхронного определения (текст, сон):
    во время сна > 0:
        ждать asyncio.sleep(1)
        print(f'{text} counter: {sleep} секунд')
        сон -= 1
асинхронная функция main():
    task_1 = asyncio. create_task(выход('Первый', 1))
    task_2 = asyncio.create_task(выход('Второй', 2))
    task_3 = asyncio.create_task(выход('Третий', 3))
    print(f"Начало: {time.strftime('%X')}")
    жду задачу_1
    жду задачу_2
    жду задачу_3
    print(f"Завершено: {time.strftime('%X')}")
если __name__ == '__main__':
    asyncio.run(основной())
 

 импорт tkinter
время импорта
класс MyApp:
    def __init__(я, родитель):
        self.root = родитель
        self.root.геометрия("400x400")
        self.frame = tkinter.Frame (родительский)
        self.frame.pack()
        b = tkinter.Button(text="нажми на меня", command=self.delayed)
        б.пак()
    Задержка с задержкой (я):
        время сна(3)
если __name__ == "__main__":
    корень = tkinter.Tk()
    приложение = MyApp (корень)
    корень.mainloop()
 

 импорт tkinter
класс MyApp:
    def __init__(я, родитель):
        self.root = родитель
        self.root.геометрия("400x400")
        self.frame = tkinter.Frame (родительский)
        self.frame.pack()
        self.root.after(3000, self.delayed)
    Задержка с задержкой (я):
        print('Я задержался')
если __name__ == "__main__":
    корень = tkinter.Tk()
    приложение = MyApp (корень)
    корень.mainloop()
 

 импорт wx
класс MyFrame(wx.Frame):
    защита __init__(сам):
        super().__init__(parent=None, title='Hello World')
        wx.CallLater(4000, self.delayed)
        самовыражение()
    Задержка с задержкой (я):
        print('Я задержался')
если __name__ == '__main__':
    приложение = wx.App()
    кадр = МойКадр()
    приложение.MainLoop()
 

 Время из кодекса Начало: Начало код: Начало код: Начало: коде. Начало Пн 9 апр 20:57:10 2018
Время окончания выполнения кода: Пн 9 апр 20:57:16 2018 

 ['Java', 'C++', 'Python', 'Javascript', 'C#', 'C', 'Kotlin'] 

 ['Jai', 'Shree', 'RAM', 5, 'August', 2020] 

 («Анил Кумбл», «Сачин Тендулкар», «Сунил Гаваскар», «Рахул Дравид»,
'Mahendra Singh Dhoni', 'Dennis Lillee', 'Muttiah Muralitharan', 'Shane Warne') 

 Анил Камбл.
Сачин Тендулкар
Сунил Гаваскар
Рахул Дравид
Махендра Сингх Дхони
Деннис Лилли
Муттия Муралитаран
Шейн Уорн 

 ['Java', 'C++', 'Python', 'Javascript', 'C#', ' C', 'Kotlin'] 

 Java
С++
питон
Javascript
С#
С
Kotlin 

 время импорта
time.sleep(seconds) 

 время импорта 

 time.sleep(5) 

 время импорта
print("Добро пожаловать в учебники Python guru99")
время сна(5)
print("Это сообщение будет напечатано через 5 секунд ожидания") 

 Добро пожаловать в guru99 Python Tutorials
Это сообщение будет напечатано через 5 секунд ожидания 

 время импорта
print('Начато выполнение кода')
дисплей защиты():
    print('Добро пожаловать в учебники Guru99')
    время сна(5)
отображать()
print('Выполнение функции отложено') 

 Выполнение кода запущено
Добро пожаловать в учебники Guru99
Задержка выполнения функции 

 время импорта
my_message = "Гуру99"
для я в my_message:
   печать (я)
   time. sleep(1) 

 Г
ты
р
ты
9
9 

 асинхронный импорт
print('Начато выполнение кода')
отображение асинхронного определения():
    ждать asyncio. sleep(5)
    print('Добро пожаловать в Гуру99 уроков')
asyncio.run(display()) 

 Выполнение кода запущено
Добро пожаловать в Guru99 Tutorials 

 из события потокового импорта
print('Начато выполнение кода')
дисплей защиты():
    print('Добро пожаловать в учебники Guru99')
Событие (). Подождите (5)
display() 

 Выполнение кода запущено
Добро пожаловать в Guru99 Tutorials 

 из таймера потокового импорта
print('Начато выполнение кода')
дисплей защиты():
    print('Добро пожаловать в учебники Guru99')
t = Таймер (5, дисплей)
t.start() 

 Выполнение кода запущено
Добро пожаловать в Guru99 Tutorials