Использовать библиотеку time и вывести какое либо сообщение в терминал с задержкой в 5 секунд

Обновлено: 02.07.2024

Другой пример - снижение нагрузки на сервер, с которым мы работаем. Например, при парсинге веб-страниц (этически) и соблюдении ToS рассматриваемого веб-сайта с соблюдением robots.txt - вы вполне можете отложить выполнение каждого запроса, чтобы не перегружать ресурсы сервера.

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

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

В этой статье мы рассмотрим, как отложить выполнение кода в Python - также известное как спящий режим . Это можно сделать несколькими способами:

Код задержки с time.sleep ()

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

Совершенно ясно, что мы можем видеть задержку в 5 секунд между двумя print() с довольно высокой точностью - вплоть до второго десятичного знака. Если вы хотите спать менее 1 секунды, вы также можете легко передать нецелые числа:

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

time.sleep() есть один серьезный недостаток, очень заметный в многопоточных средах.

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

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

Асинхронное и реактивное программирование

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

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

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

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

Код задержки с asyncio.sleep ()

Asyncio - это библиотека Python, предназначенная для написания параллельного кода и использующая async / await , который может быть знаком разработчикам, которые использовали его на других языках.

Установим модуль через pip :

После установки мы можем import его в наш скрипт и переписать нашу функцию:

При работе с asyncio мы помечаем функции, которые выполняются асинхронно, как async , и await результатов таких операций, как asyncio.sleep() которые будут завершены в какой-то момент в будущем.

Как и в предыдущем примере, это будет напечатано два раза с интервалом в 5 секунд:

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

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

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

Все они выполняются одновременно, и время ожидания для трех из них не 15 секунд, а 5.

С другой стороны, если бы мы настроили этот код, чтобы вместо time.sleep()

Мы будем ждать 5 секунд между каждым оператором print()

Код задержки с таймером

Класс Timer - это Thread , который может запускать и выполнять операции только по прошествии определенного периода времени. Это именно то, что мы ищем, хотя использование Thread s для задержки кода является излишним, если вы еще не работаете с многопоточной системой.

Класс Timer должен быть start() , и его можно остановить с помощью cancel() . Его конструктор принимает целое число, обозначающее количество секунд ожидания перед выполнением второго параметра - функции.

Создадим функцию и выполним ее через Timer :

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

Напишем функцию f() , которая вызывает как f2() и f3() . f2() вызывается как есть - и возвращает случайное целое число от 1 до 10, имитируя время, необходимое для запуска этой функции.

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

Код задержки с событием

Класс Event можно использовать для генерации событий. Одно событие может быть "прослушано" несколькими потоками. Функция Event.wait() блокирует поток, в котором она находится, за исключением Event.isSet() . После того, как вы set() событие, все ожидающие потоки пробуждаются, и Event.wait() становится неблокирующим .

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

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

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

Выполнение этого кода приводит к:

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

Заключение

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

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

Используя asyncio , у нас есть асинхронная версия time.sleep() которую мы можем await .

Класс Timer задерживает выполнение кода и при необходимости может быть отменен.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

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

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

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

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

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

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

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

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

Telegram Чат & Канал

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

Паблик VK

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

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

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

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

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

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

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

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

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

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

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

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

Синтаксис:

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

Чтобы прекрасно разбираться в теме. Давайте посмотрим на реализацию на нескольких примерах.

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

Пример 1: Печать чисел с добавлением временной задержки.

Читайте также: