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

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

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

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

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

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

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

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

В Python есть встроенная поддержка для погружения программы в сон. У модуля time

> Есть вопросы по 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 будет запускать код миллион раз. Если бы вы запустили вышеуказанный код, оставив значение -n по умолчанию, тогда при 3 секундах на итерацию код завис бы примерно на 34 дня! У модуля 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

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

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

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

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

Для добавления системного вызова sleep() в 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()  для использования нового декоратора:

@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(). В основе следующего кода лежит данный пример:

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. Затем начинаются оба потока и инициируется цикл для каждого входа из главного потока. Для фиксирования пользователя используется KeyboardInterrupt при нажатии ^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():

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(). Вспомните, что в предыдущем примере вместо этого передавался словарь.

Затем устанавливаются циклы для проверки, настроено ли событие event. Если это не так, тогда код выведет сообщение и немного подождет перед повторной проверкой. Для установки события можно воспользоваться комбинацией ^Ctrl+C. Как только событие установлено, worker() вернется, и цикл оборвется, завершив программу.

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

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

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

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

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

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

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

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

Вот более подробный пример из раздела о Сопрограммах и задачах документации 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. После этого используется ключевое слово Python await для ожидания запуска кода 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())

Теперь вы используете концепт задач, что можно создать через 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:

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():

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():

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 в сон.

Модуль time | Python 3 для начинающих и чайников

Time — модуль для работы со временем в Python.

time.altzone — смещение DST часового пояса в секундах к западу от нулевого меридиана. Если часовой пояс находится восточнее, смещение отрицательно.

time.asctime([t]) — преобразовывает кортеж или struct_time в строку вида «Thu Sep 27 16:42:37 2012». Если аргумент не указан, используется текущее время.

time.clock() — в Unix, возвращает текущее время. В Windows, возвращает время, прошедшее с момента первого вызова данной функции.

time.ctime([сек]) — преобразует время, выраженное в секундах с начала эпохи в строку вида «Thu Sep 27 16:42:37 2012».

time.daylight — не 0, если определено, зимнее время или летнее (DST).

time.gmtime([сек]) — преобразует время, выраженное в секундах с начала эпохи в struct_time, где DST флаг всегда равен нулю.

time.localtime([сек]) — как gmtime, но с DST флагом.

time.mktime(t) — преобразует кортеж или struct_time в число секунд с начала эпохи. Обратна функции time.localtime.

time.sleep(сек) — приостановить выполнение программы на заданное количество секунд.

time.strftime(формат, [t]) — преобразует кортеж или struct_time в строку по формату:

time.strptime(строка [, формат]) — разбор строки, представляющей время в соответствии с форматом. Возвращаемое значение struct_time. Формат по умолчанию: «%a %b %d %H:%M:%S %Y».

Класс time.struct_time — тип последовательности значения времени. Имеет интерфейс кортежа. Можно обращаться по индексу или по имени.

0. tm_year
1. tm_mon
2. tm_mday
3. tm_hour
4. tm_min
5. tm_sec
6. tm_wday
7. tm_yday
8. tm_isdst

time.time() — время, выраженное в секундах с начала эпохи.

time.timezone — смещение местного часового пояса в секундах к западу от нулевого меридиана. Если часовой пояс находится восточнее, смещение отрицательно.

time.tzname — кортеж из двух строк: первая — имя DST часового пояса, второй — имя местного часового пояса.

Модуль time в Python 3 — получение текущего времени

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

Текущее время в Python

Работа методов из модуля time основывается на общепринятой системе описания времени, которая справедлива для Unix, а также для POSIX-совместимых ОС. Согласно ее концепции, текущее время представляется в виде обыкновенного вещественного значения в секундах, прошедших с момента начала эпохи и до сегодняшнего дня. Отправной точкой для времени считается 1 января 1970 года, когда счетчик секунд имел полностью нулевое значение.

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

import time
print(time.time())

1540289822.637441

Как можно увидеть из данного примера, функция print получает в качестве единственного параметра число, возвращенное из метода time(), после чего выводит его на экран. Таким образом, с 1 января 1970 года прошло уже более полтора миллиарда секунд. Но подобное представление времени совсем неудобно для пользователя программы. Чтобы отобразить текущую дату в более комфортном виде, стоит передать функции print результат работы метода ctime(), не забыв произвести импорт соответствующей ему библиотеки time.

import time
print(time.ctime())

Tue Oct 23 10:18:23 2018

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

Методы

Для работы с временем в стандартной библиотеке языка Python имеется множество самых разных методов. Наиболее популярные функции, реализованные в модуле time, описаны в следующей таблице. Здесь можно найти их название, а также краткую характеристику.

Форматированный вывод

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

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

import time
print(time.strftime("Today is %B %d, %Y.", time.localtime()))

Today is October 23, 2018.

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

Применение метода sleep

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

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

import time
pause = 10
print("Program started...")
time.sleep(pause)
print(str(pause) + " seconds passed.")

Program started...
10 seconds passed.

Как можно увидеть из результатов выполнения кода, вначале на экран выводится стартовое сообщение, после чего программа прекращает свою работу ровно на 10 секунд, поскольку метод sleep получает переменную pause в качестве аргумента. Затем отображается последняя запись, информирующая пользователя о том, какое количество секунд длилась задержка.

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

Таким образом, чтобы сделать задержку в 100 миллисекунд, надо написать time.sleep(0.1).

Время выполнения программы

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

import time
start = time.time()
time.sleep(5)
finish = time.time()
result = finish - start
print("Program time: " + str(result) + " seconds.")

Program time: 5.005090236663818 seconds.

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

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

monotonic

По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.

import time
start = time.monotonic()
time.sleep(15)
result = time.monotonic() - start
print("Program time: {:>.3f}".format(result) + " seconds.")

Program time: 15.012 seconds.

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

Заключение

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

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

Работа с датой и временем в Python

Python содержит несколько инструментов, которые разработчик может использовать для работы с датой и временем. В данном разделе статье мы рассмотрим модули datetime и time. Мы изучим принципы их работы и способы их применения. Начнем с модуля datetime.

Модуль datetime

Мы изучим следующие классы модуля:

• datetime.date
• datetime.timedelta
• datetime.datetime

Благодаря этим классам мы в будущем сможем работать с большей частью случаев, в которых нам понадобятся объекты date и datetime. Также существует класс tzinfo, который применяется для работы с часовыми поясами. Для дополнительной информации об этом классе вы можете обратиться к документации Python.

datetime.date

Python может представлять даты различными способами. Для начала, рассмотрим формат datetime.date, так как это один из самых простых объектов date.

print( datetime.date(2012, 13, 14) ) Traceback (most recent call last): File «<string>», line 1, in <fragment> builtins.ValueError: month must be in 1..12

print(datetime.date(2012, 12, 14)) # datetime.date(2012, 12, 14)

В данном коде показано, как создать простой объект даты. Класс date принимает три аргумента: год, месяц и день. Если вы укажите неправильное значение, вы увидите ошибку ValueError, как в случае выше. В противном случае вы увидите, что объект datetime.date вернулся. Давайте взглянем на еще один пример:

import datetime d = datetime.date(2012, 12, 14) print(d.year) # 2012 print(d.day) # 14 print(d.month) # 12

Здесь мы присваиваем объекту date переменную d. Теперь мы можем получить доступ к различным компонентам даты по названиям, таким как d.year или d.month. Давайте посмотрим, какой сейчас день:

import datetime print(datetime.date.today()) # datetime.date(2017, 4, 5)

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

datetime.datetime

Объект datetime.datetime содержит всю информацию объектов datetime.date плюс datetime.time. Давайте приведем несколько примеров, для лучшего понимания разницы между этим объектом, и объектом datetime.date.

import datetime a = datetime.datetime(2017, 3, 5) print(a) # datetime.datetime(2017, 3, 5, 0, 0) b = datetime.datetime(2017, 3, 5, 12, 30, 10) print(b) # datetime.datetime(2017, 3, 5, 12, 30, 10) d = datetime.datetime(2017, 3, 5, 12, 30, 10) print(d.year) # 2017 print(d.second) # 10 print(d.hour) # 12

Мы видим, что datetime.datetime принимает несколько дополнительных аргументов: год, месяц, день, час, минута и секунда. Это также позволяет вам указывать информацию о микросекундах и часовом поясе. При работе с базами данных, данные типы объектов будут использоваться достаточно часто. Большую часть вашей работы, вам нужно будет конвертировать форматы date или datetime Python в форматы SQL datetime или timestamp. Обратите внимание на то, что today совместно с datetime.datetime использует два разных метода:

import datetime a = datetime.datetime.today() print(a) # datetime.datetime(2017, 4, 5, 0, 16, 54, 989663) b = datetime.datetime.now() print(b) # datetime.datetime(2017, 4, 5, 0, 17, 8, 24239)

Модуль datetime содержит другой метод, под названием strftime. Этот метод позволяет разработчику создавать строку, отображающую время в более понятной для человека форме. Существует целая таблица параметров форматирования, с которой рекомендуется ознакомиться в документации Python, в секции 8.1.7. Давайте взглянем на несколько примеров, показывающих всю полезность данного метода:

import datetime a = datetime.datetime.today().strftime(«%Y%m%d») print(a) # ‘20170405’ today = datetime.datetime.today() print( today.strftime(«%m/%d/%Y») ) # ’04/05/2017’ print( today.strftime(«%Y-%m-%d-%H.%M.%S») ) # 2017-04-05-00.18.00

Первый пример – это скорее хитрость. В нем показано, как конвертировать сегодняшний объект datetime в строку, следующую за форматом YYYYMMDD (ГГГГММДД). Второй пример более наглядный.

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

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

> Чат и Паблик Программистов

Присоединяйтесь к нашему чату в Телеграм и подпишитесь на наш паблик в ВК.

В нем мы присваиваем объект datetime переменной под названием today и применяем два разных параметра форматирования строки. Первый параметр добавляет косые черточки между элементами datetime, а также перегруппировывает datetime, теперь он делится на месяц, день и год. В последнем примере мы создаем временную отметку, которая следует типичному формату: YYYY-MM-DD.HH.MM.SS. Если вам нужно указать год как двухзначный (“YY”), вы можете заменить %Y на %y.

datetime.timedelta

Объект datetime.timedelta отображает длительность времени. Другими словами, это разница между двумя датами или временными отметками. Давайте взглянем на наглядный пример:

import datetime # Значение: datetime.datetime(2017, 4, 5, 0, 18, 51, 980187) now = datetime.datetime.now() then = datetime.datetime(2017, 2, 26) # Кол-во времени между датами. delta = now — then print(delta.days) # 38 print(delta.seconds) # 1131

Мы создали два объекта datetime. Один указывает на сегодняшний день, второй – на прошедшую неделю. После этого, мы берем разницу между ними. Это возвращает объект timedelta, который мы можем далее использовать, чтобы выяснить, сколько прошло дней или секунд, между этими двумя датами. Если вам нужно узнать количество часов или минут между двумя датами, вам понадобится немножко математики, чтобы выяснить это. Давайте взглянем на проверенный способ:

seconds = delta.total_seconds() hours = seconds // 3600 print(hours) # 186.0 minutes = (seconds % 3600) // 60 print(minutes) # 13.0

Отсюда мы узнаем, что в неделе 186 часов и 13 минут. Обратите внимание на то, что мы используем двойную косую черту в качестве нашего оператора деления, также известного как floor division. Теперь мы готовы к тому, чтобы узнать больше о модуле time Python.

Модуль time

Модуль time открывает разработчику Python доступ к нескольким связанным со временем функциям. Модуль основан на «эпохе», точке, с которой начинается время. Для систем Unix, эпоха началась в 1970 году. Чтобы узнать, какая эпоха в вашей системе, попробуйте запустить следующий код:

import time print(time.gmtime(0))

Результат

time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=\ 0, tm_wday=3, tm_yday=1, tm_isdst=0)

Я запустил его на Windows 7, которая также уверена в том, что начало времен датируется 1970м годом. В любом случае, в данном разделе мы ознакомимся со следующими функциями:

• time.ctime
• time.sleep
• time.strftime
• time.time

Приступим!

time.ctime

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

import time print(time.ctime()) # ‘Wed Apr 5 00:02:49 2017’ print(time.ctime(1384112639)) # ‘Sun Nov 10 13:43:59 2013’

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

time.sleep

Функция time.sleep дает разработчику возможность приостановить выполнение его скрипта на определенное количество секунд. Это можно сравнить с добавлением функции «Пауза» в вашу программу. Я нашел этот класс особенно полезным, когда мне нужно было подождать несколько секунд, пока закроется файл, или база данных закончит выполнять свою задачу. Давайте взглянем на пример. Откройте новое окно в IDLE и сохраните следующий код:

import time for x in range(5): time.sleep(2) print(«Slept for 2 seconds»)

Теперь запустите этот код в IDLE. Сделав это, вы увидите фразу «Slept for 2 seconds» пять раз, с интервалом в 2 секунды между каждым сообщением. Это очень легко в использовании!

time.strftime

Модуль time имеет функцию strftime, которая работает по схожему с версией datetime принципу. Разница заключается, главным образом, в том, что именно она принимает для ввода: кортеж, или объект struct_time, вроде тех, которые возвращаются после вызова time.gmtime() или time.localtime(). Вот небольшой пример:

import time a = time.strftime(«%Y-%m-%d-%H.%M.%S», time.localtime()) print(a) # ‘2017-04-05-00.11.20’

Этот код очень похож на код временной отметки, который мы создавали в разделе datetime. На мой взгляд, метод datetime более интуитивен при создании объекта datetime.datetime а затем при вызове его метода strftime в том формате, который вам более удобен. С модулем time, вам нужно передать формат и кортеж времени. На самом деле выбор за вами, каким именно способом вам будет удобнее решить вашу задачу.

time.time

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

import time x = time.time() print(x) # 1491340367.478385

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

import time a = time.ctime(time.time()) print(a) # Wed Apr 5 00:13:47 2017

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

Подведем итоги

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

Метод time.sleep() в Python

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

import time time.sleep(5) #задержка в течение 5 секунд

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

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

import time time.sleep(1.500)

Когда вы запускаете приведенный выше Пример:, программа ждет завершения 1 секунды и 500 миллисекунд.

time.sleep (1) # sleep в течение 1 секунды time.sleep (60) # сон в течение 1 минуты time.sleep (3600) # сон в течение 1 часа

Задержка времени для бесконечного цикла

Вот еще один пример когда что-то выполняется примерно каждые 5 секунд.

import time while True: print(«Thi smessage prints each 5 seconds») time.sleep(5) # Задержка в течение 5 секунд

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

Сон программы

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

import time wait = 10 while wait > 0: print(wait) time.sleep(1) wait = wait — 1

Thread и Sleep

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

import time from threading import Thread class Main_Thread(Thread): def run(self): for x in range(100, 104): print(x, » — Main Thread») time.sleep(5) class Service_Thread(Thread): def run(self): for x in range(1, 16): print(x) time.sleep(1) Main_Thread().start() Service_Thread().start()

Вывод:

100 — Main Thread 1 2 3 4 5 101 — Main Thread 6 7 8 9 10 102 — Main Thread 11 12 13 14 15 103 — Main Thread

Точность time.sleep()

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

import time sleep_start = time.time() for cnt in range(0,10): print(cnt) time.sleep(1) # 1 sec delay sleep_end = time.time() diff = sleep_end — sleep_start print(«Looping time :»,diff)

Вывод:

Looping time : 10.040287017822266

Источник: net-informations.com

time.sleep () в Python | Портал информатики для гиков

sleep () определяется в модуле time () python 3 и python 2

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

Syntax : sleep(sec)

Parameters :
sec : Number of seconds for which the code is required to be stopped.

Returns : VOID.

Код № 1: Демонстрация сна ()

Выход:

The time of code execution begin is : Mon Apr  9 20:57:10 2018
The time of code execution end is : Mon Apr  9 20:57:16 2018

Заявка :
Есть много приложений, для которых используется sleep (). Будь то выполнение фонового потока, которое повторяется через равные промежутки времени, это можно реализовать с помощью sleep (). Другое популярное приложение использует sleep () для печати слов по буквам для хорошего пользовательского интерфейса. Последний представлен из этого кода ниже.

Код № 2: Демонстрация применения сна ()

Выход:

GeeksforGeeks

Примечание: видимый эффект sleep () можно увидеть в локальном редакторе.

Рекомендуемые посты:

time.sleep () в Python

0.00 (0%) 0 votes

Как выполнить код с задержкой?

Python sleep(): Как выполнить код с задержкой?

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

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

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

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

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

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

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

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

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

На заметку: В 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 будет запускать код миллион раз. Если бы вы запустили вышеуказанный код, оставив значение -n по умолчанию, тогда при 3 секундах на итерацию код завис бы примерно на 34 дня! У модуля timeit есть несколько других настроек для командной строки, с которыми можно ознакомиться в документации.

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

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() является необходимость проверки состояния пользовательского интерфейса во время автоматического теста. В зависимости от компьютера, на котором запускается тест, пользовательский интерфейс может грузиться быстрее или медленнее обычного. Это может изменить отображаемое на экране во время проверки программой чего-то.

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

Для добавления системного вызова sleep() в 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 &lt; 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()  для использования нового декоратора:

@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 более широким ассортиментом функций.

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

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

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

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

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

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

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

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

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

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. Затем начинаются оба потока и инициируется цикл для каждого входа из главного потока. Для фиксирования пользователя используется KeyboardInterrupt при нажатии ^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():

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(). Вспомните, что в предыдущем примере вместо этого передавался словарь.

Затем устанавливаются циклы для проверки, настроено ли событие event. Если это не так, тогда код выведет сообщение и немного подождет перед повторной проверкой. Для установки события можно воспользоваться комбинацией ^Ctrl+C. Как только событие установлено, worker() вернется, и цикл оборвется, завершив программу.

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

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

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

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

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

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

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

Вот более подробный пример из раздела о Сопрограммах и задачах документации 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. После этого используется ключевое слово Python await для ожидания запуска кода output(). Здесь требуется await, так как output() был отмечен как функция async, и теперь не может вызываться как обычная функция.

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

import asyncio import time async def output(text, sleep): while sleep &gt; 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 заблокируется цикл обработки событий.

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

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

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

Начнем с разбора примера, где используется time.sleep(). Запустите следующий код и посмотрите, что произойдет при неправильном добавлении вызова sleep() в 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():

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():

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 в сон.

источник

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

печать («Напечатано немедленно.»)
time.sleep (2.4)
печать («Отпечатано после 2.4 секунды. ")
  

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

пока верно:
  localtime = time.localtime ()
  результат = time.strftime («% I:% M:% S% p», местное время)
  печать (результат)
  time.sleep (1)
  

  2:10:50
02:10:51 вечера
02:10:52 вечера
02:10:53 вечера
02:10:54 вечера
... .. ...  

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

пока верно:
  localtime = time.localtime ()
  результат = time.strftime («% I:% M:% S% p», местное время)
  print (result, end = "", flush = True)
  print ("\ r", end = "", flush = True)
  time.sleep (1)
  

 
импорт потоков
  
def print_hello_three_times ():
  для я в диапазоне (3):
    печать ( "Hello")
  
def print_hi_three_times ():
    для я в диапазоне (3):
      печать ( «Привет»)

t1 = threading.Thread (target = print_hello_three_times)
t2 = threading.Thread (target = print_hi_three_times)

t1.start ()
t2.start ()
  

 
Привет
Привет
Здравствуй
Привет
Здравствуй
Здравствуй
  

  импорт потоков
время импорта
  
def print_hello ():
  для я в диапазоне (4):
    time.sleep (0,5)
    печать ( "Hello")
  
def print_hi ():
    для я в диапазоне (4):
      time.sleep (0.7)
      печать ( «Привет»)

t1 = threading.Thread (target = print_hello)
t2 = threading.Thread (target = print_hi)
t1.start ()
t2.start ()  

  >>> время импорта
>>> Время.сон (3) # спать в течение 3 секунд
  

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

  время импорта
импорт urllib.request
импортировать urllib.error

def uptime_bot (url):
    пока верно:
        пытаться:
            conn = urllib.request.urlopen (url)
        кроме urllib.error.HTTPError как e:
            # Email admin / log
            print (f'HTTPError: {e.код} для {url} ')
        кроме urllib.error.URLError как e:
            # Email admin / log
            печать (ф