Python. Как сделать задержку, не заморозив программу?
При использовании time.sleep(x), вся программа останавливается. Я же делаю бота, в котором после каждого действия нужно ждать. Ты же не можешь работать весь день без остановки? Нет, не можешь. После каждой работы нужно будет отдохнуть 1 реальный час. Но time.sleep(x) останавливает ВСЮ программу, и после каждой работы никто не может пользоватся ботом. Как сделать задержку, без заморозки программы?
Отслеживать
задан 23 сен 2020 в 14:04
TheNick — Ник TheNick — Ник
158 1 1 серебряный знак 17 17 бронзовых знаков
Запоминать время последнего запроса от каждого пользователя и проверять его, например.
23 сен 2020 в 14:13
Объясни понятнее. Если бот должен не работать, а его-то ждать, то какая разница, могут им пользоваться или нет, если пользоваться им все равно нельзя. Ведь нужно отдохнуть реальный час.
23 сен 2020 в 14:14
Надо же, первый раз вижу такую трогательную заботу о том, чтобы бот не переутомился.
23 сен 2020 в 14:21
@strawdog к сожалению, это не для бота 🙁 Мой бот игровой, так сказать «симулятор жизни», и чтобы человек не злоупотреблял и не спамил командой чтобы получить много денег, надо сделать отдых
23 сен 2020 в 14:26
По идее у Вас для каждой команды есть обработчик. В нем можно получить время запроса и при повторе команды вычитать его из текущего. Если итог меньше часа то программа должна дать отказ.
Как создать задержку в Python: простой способ
Временная задержка – это очень полезный инструмент в программировании. Она позволяет нам приостановить выполнение программы на некоторое время. В Python существуют различные способы создания задержки, но один из самых простых – использование функции time.sleep().
Импорт модуля time
Перед использованием функции time.sleep(), нам нужно импортировать модуль time в нашу программу.
import timeИспользование функции time.sleep()
Функция time.sleep() принимает один аргумент – количество секунд, на которое нужно приостановить выполнение программы. Можно указать как целое число, так и число с плавающей запятой.
time.sleep(1) # Приостановить выполнение программы на 1 секунду time.sleep(0.5) # Приостановить выполнение программы на 0.5 секунды
Чем больше значение аргумента, тем дольше будет задержка.
Пример использования
Давайте рассмотрим простой пример, который показывает, как использовать функцию time.sleep(). В этом примере мы используем функцию для создания задержки в выполнении программы на 2 секунды.
import time print("Начало программы")
time.sleep(2)
print("Конец программы")
При запуске этой программы мы увидим, что текст “Начало программы” будет выведен сразу же, а текст “Конец программы” появится только через 2 секунды.
Заключение
Использование функции time.sleep() позволяет нам создавать задержку в выполнении программы. Это может быть полезно, когда требуется приостановить программу на некоторое время, например, чтобы сделать паузу между действиями или добавить задержку ввода данных пользователем. Помните, что функция time.sleep() приостанавливает выполнение всей программы, поэтому следует быть осторожным при использовании ее в многопоточных программах.
Использование функции sleep
Функция sleep в Python представляет собой простой способ создания задержки в программе. Она позволяет приостановить выполнение программы на заданное количество секунд.
Для использования функции sleep необходимо импортировать модуль time в свою программу. Затем можно вызвать функцию sleep, указав в качестве аргумента количество секунд, на которое нужно приостановить программу.
import timeprint("Начало программы")
time.sleep(2)
print("Прошло 2 секунды")
В этом примере программа будет приостановлена на 2 секунды после вывода строки “Начало программы”. Затем будет выведена строка “Прошло 2 секунды”.
Функция sleep может быть полезна в различных ситуациях. Например, она может использоваться для создания паузы между выполнением определенных операций, для симуляции ожидания пользователя или для управления скоростью выполнения программы.
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Python: сделать временную задержку (спящий режим) для выполнения кода
Введение Задержка кода (также известная как «спящий») — это именно то, что подразумевает название, задержка выполнения кода на некоторое время. Наиболее частая потребность в отложении кода — это когда мы ждем завершения какого-либо другого процесса, чтобы мы могли работать с результатом этого процесса. В многопоточных системах потоку может потребоваться дождаться, пока другой поток закончит операцию, чтобы продолжить работу с этим результатом. Другой пример — уменьшение нагрузки на сервер, над которым мы работаем.
Время чтения: 8 мин.
Вступление
Задержка кода (также известная как « спящий» ) — это именно то, что подразумевает название, задержка выполнения кода на некоторое время. Наиболее частая потребность в отложении кода — это когда мы ждем завершения какого-либо другого процесса, чтобы мы могли работать с результатом этого процесса. В многопоточных системах потоку может потребоваться дождаться, пока другой поток закончит операцию, чтобы продолжить работу с этим результатом.
Другой пример — снижение нагрузки на сервер, с которым мы работаем. Например, при парсинге веб-страниц (этически) и соблюдении ToS рассматриваемого веб-сайта с соблюдением robots.txt — вы вполне можете отложить выполнение каждого запроса, чтобы не перегружать ресурсы сервера.
Многие запросы, отправляемые в быстрой последовательности, могут, в зависимости от рассматриваемого сервера, быстро задействовать все свободные соединения и фактически превратиться в DoS-атаку . Чтобы дать передышку, а также чтобы убедиться, что мы не оказываем негативного воздействия ни на пользователей веб-сайта, ни на сам веб-сайт — мы ограничили количество отправляемых запросов, задерживая каждый из них.
Студент, ожидающий результатов экзамена, может яростно обновлять сайт своей школы в ожидании новостей. В качестве альтернативы они могут написать сценарий, который проверяет, есть ли на веб-сайте что-нибудь новое. В некотором смысле, задержка кода технически может стать планированием кода с допустимым циклом и условием завершения — при условии, что действующий механизм задержки не блокирует .
В этой статье мы рассмотрим, как отложить выполнение кода в Python — также известное как спящий режим . Это можно сделать несколькими способами:
- Код задержки с time.sleep ()
- Код задержки с asyncio.sleep ()
- Код задержки с таймером потоковой передачи
- Код задержки с событием
Код задержки с time.sleep ()
Одним из наиболее распространенных решений проблемы является функция sleep() встроенного модуля time Он принимает количество секунд, в течение которых процесс должен засыпать — в отличие от многих других языков, которые основаны на миллисекундах :
import datetime import time print(datetime.datetime.now().time()) time.sleep(5) print(datetime.datetime.now().time())
14:33:55.282626 14:34:00.287661
Совершенно ясно, что мы можем видеть задержку в 5 секунд между двумя print() с довольно высокой точностью — вплоть до второго десятичного знака. Если вы хотите спать менее 1 секунды, вы также можете легко передать нецелые числа:
print(datetime.datetime.now().time()) time.sleep(0.25) print(datetime.datetime.now().time()) 14:46:16.198404 14:46:16.448840 print(datetime.datetime.now().time()) time.sleep(1.28) print(datetime.datetime.now().time()) 14:46:16.448911 14:46:17.730291
Однако имейте в виду, что с двумя десятичными знаками продолжительность сна может быть не совсем точной , особенно из-за того, что ее трудно проверить, учитывая тот факт, что print() требуют некоторого (переменного) времени для выполнения.
time.sleep() есть один серьезный недостаток, очень заметный в многопоточных средах.
Он захватывает поток, в котором находится, и блокирует его на время сна . Это делает его непригодным для более длительного ожидания, так как в течение этого периода он забивает поток процессора. Кроме того, это делает его непригодным для асинхронных и реактивных приложений , которым часто требуются данные и обратная связь в реальном времени.
Еще одно замечание о time.sleep() — это то, что вы не можете его остановить. После запуска вы не можете отменить его извне, не завершив всю программу или sleep() генерировать исключение, которое остановило бы его.
Асинхронное и реактивное программирование
Асинхронное программирование вращается вокруг параллельного выполнения, когда задача может выполняться и завершаться независимо от основного потока.
В синхронном программировании — если функция A вызывает функцию B , она останавливает выполнение до тех пор, пока функция B не завершит выполнение, после чего функция A может возобновиться.
В асинхронном программировании — если функция A вызывает функцию B , независимо от ее зависимости результата от функции B , обе могут выполняться одновременно, и, если необходимо, дождаться завершения другой, чтобы использовать результаты друг друга.
Реактивное программирование — это подмножество асинхронного программирования , которое запускает выполнение кода реактивно , когда данные представлены, независимо от того, занята ли функция, которая должна их обрабатывать. Реактивное программирование в значительной степени опирается на архитектуры, управляемые сообщениями (где сообщение обычно является событием или командой ).
И асинхронные, и реактивные приложения сильно страдают от блокировки кода, поэтому использование чего-то вроде time.sleep() для них не подходит. Давайте посмотрим на некоторые варианты задержки неблокирующего кода.
Код задержки с asyncio.sleep ()
Asyncio — это библиотека Python, предназначенная для написания параллельного кода и использующая async / await , который может быть знаком разработчикам, которые использовали его на других языках.
Установим модуль через pip :
$ pip install asyncio
После установки мы можем import его в наш скрипт и переписать нашу функцию:
import asyncio async def main(): print(datetime.datetime.now().time()) await asyncio.sleep(5) print(datetime.datetime.now().time()) asyncio.run(main())
При работе с asyncio мы помечаем функции, которые выполняются асинхронно, как async , и await результатов таких операций, как asyncio.sleep() которые будут завершены в какой-то момент в будущем.
Как и в предыдущем примере, это будет напечатано два раза с интервалом в 5 секунд:
17:23:33.708372 17:23:38.716501
Хотя на самом деле это не иллюстрирует преимущества использования asyncio.sleep() . Давайте перепишем пример для параллельного выполнения нескольких задач, где это различие гораздо более ясно:
import asyncio import datetime async def intense_task(id): await asyncio.sleep(5) print(id, 'Running some labor-intensive task at ', datetime.datetime.now().time()) async def main(): await asyncio.gather( asyncio.create_task(intense_task(1)), asyncio.create_task(intense_task(2)), asyncio.create_task(intense_task(3)) ) asyncio.run(main())
Здесь у нас есть async функция, которая имитирует трудоемкую задачу, выполнение которой занимает 5 секунд. Затем, используя asyncio , мы создаем несколько задач . Однако каждая задача может выполняться асинхронно, только если мы вызываем их асинхронно. Если бы мы запускали их последовательно, они также выполнялись бы последовательно.
Для их параллельного вызова мы используем gather() , которая собирает задачи и выполняет их:
1 Running some labor-intensive task at 17:35:21.068469 2 Running some labor-intensive task at 17:35:21.068469 3 Running some labor-intensive task at 17:35:21.068469
Все они выполняются одновременно, и время ожидания для трех из них не 15 секунд, а 5.
С другой стороны, если бы мы настроили этот код, чтобы вместо time.sleep()
import asyncio import datetime import time async def intense_task(id): time.sleep(5) print(id, 'Running some labor-intensive task at ', datetime.datetime.now().time()) async def main(): await asyncio.gather( asyncio.create_task(intense_task(1)), asyncio.create_task(intense_task(2)), asyncio.create_task(intense_task(3)) ) asyncio.run(main())
Мы будем ждать 5 секунд между каждым оператором print()
1 Running some labor-intensive task at 17:39:00.766275 2 Running some labor-intensive task at 17:39:05.773471 3 Running some labor-intensive task at 17:39:10.784743
Код задержки с таймером
Класс Timer — это Thread , который может запускать и выполнять операции только по прошествии определенного периода времени. Это именно то, что мы ищем, хотя использование Thread s для задержки кода является излишним, если вы еще не работаете с многопоточной системой.
Класс Timer должен быть start() , и его можно остановить с помощью cancel() . Его конструктор принимает целое число, обозначающее количество секунд ожидания перед выполнением второго параметра — функции.
Создадим функцию и выполним ее через Timer :
from threading import Timer import datetime def f(): print("Code to be executed after a delay at:", datetime.datetime.now().time()) print("Code to be executed immediately at:", datetime.datetime.now().time()) timer = Timer(3, f) timer.start()
Code to be executed immediately at: 19:47:20.032525 Code to be executed after a delay at: 19:47:23.036206
Метод cancel() очень удобен, если у нас работает несколько функций, и мы хотели бы отменить выполнение функции на основе результатов другой или другого условия.
Напишем функцию f() , которая вызывает как f2() и f3() . f2() вызывается как есть — и возвращает случайное целое число от 1 до 10, имитируя время, необходимое для запуска этой функции.
f3() вызывается через Timer и если результат f2() больше 5 , f3() отменяется, тогда как если f2() выполняется в «ожидаемое» время меньше 5 — f3() запускается после таймер заканчивается:
from threading import Timer import datetime import random def f(): print("Executing f1 at", datetime.datetime.now().time()) result = f2() timer = Timer(5, f3) timer.start() if(result > 5): print("Cancelling f3 since f2 resulted in", result) timer.cancel() def f2(): print("Executing f2 at", datetime.datetime.now().time()) return random.randint(1, 10) def f3(): print("Executing f3 at", datetime.datetime.now().time()) f()
Выполнение этого кода несколько раз будет выглядеть примерно так:
Executing f1 at 20:29:10.709578 Executing f2 at 20:29:10.709578 Cancelling f3 since f2 resulted in 9 Executing f1 at 20:29:14.178362 Executing f2 at 20:29:14.178362 Executing f3 at 20:29:19.182505
Код задержки с событием
Класс Event можно использовать для генерации событий. Одно событие может быть «прослушано» несколькими потоками. Функция Event.wait() блокирует поток, в котором она находится, за исключением Event.isSet() . После того, как вы set() событие, все ожидающие потоки пробуждаются, и Event.wait() становится неблокирующим .
Это можно использовать для синхронизации потоков — все они накапливаются и wait() пока не будет установлено определенное событие, после чего они могут определять свой поток.
Давайте создадим waiter и запустим его несколько раз в разных потоках. Каждый официант начинает работать в определенное время и каждую секунду проверяет, работают ли они еще час, прямо перед тем, как принять заказ, на выполнение которого уходит секунда. Они будут работать, пока не будет назначено Событие, а точнее, их рабочее время не истечет.
У каждого официанта будет свой собственный поток, в то время как управление находится в основном потоке и звонит, когда каждый может позвонить домой. Поскольку сегодня они чувствуют себя очень щедрыми, они сократят рабочее время и отпустят официантов домой через 4 секунды работы:
import threading import time import datetime def waiter(event, id): print(id, "Waiter started working at", datetime.datetime.now().time()) event_flag = end_of_work.wait(1) while not end_of_work.isSet(): print(id, "Waiter is taking order at", datetime.datetime.now().time()) event.wait(1) if event_flag: print(id, "Waiter is going home at", datetime.datetime.now().time()) end_of_work = threading.Event() for id in range(1, 3): thread = threading.Thread(target=waiter, args=(end_of_work, id)) thread.start() end_of_work.wait(4) end_of_work.set() print("Some time passes, management was nice and cut the working hours short. It is now", datetime.datetime.now().time())
Выполнение этого кода приводит к:
1 Waiter started working at 23:20:34.294844 2 Waiter started working at 23:20:34.295844 1 Waiter is taking order at 23:20:35.307072 2 Waiter is taking order at 23:20:35.307072 1 Waiter is taking order at 23:20:36.320314 2 Waiter is taking order at 23:20:36.320314 1 Waiter is taking order at 23:20:37.327528 2 Waiter is taking order at 23:20:37.327528 Some time passes, management was nice and cut the working hours short. It is now 23:20:38.310763
end_of_work здесь использовалось для синхронизации двух потоков и управления, когда они работают, а когда нет, задерживая выполнение кода на установленное время между проверками.
Заключение
В этом руководстве мы рассмотрели несколько способов задержки выполнения кода в Python, каждый из которых применим к разному контексту и требованиям.
time.sleep() очень полезен для большинства приложений, хотя он не совсем оптимален для длительного времени ожидания, обычно не используется для простого планирования и блокирует.
Используя asyncio , у нас есть асинхронная версия time.sleep() которую мы можем await .
Класс Timer задерживает выполнение кода и при необходимости может быть отменен.
Класс Event генерирует события, которые несколько потоков могут прослушивать и соответственно реагировать, задерживая выполнение кода до тех пор, пока не будет установлено определенное событие.
Licensed under CC BY-NC-SA 4.0
Как добавить задержку в Python?
В этой статье мы собираемся обсудить, как мы вводим или добавляем временную задержку в наш программный код.
- Чтобы добавить задержку времени в наш программный код, мы используем функцию sleep () из модуля time. Это встроенный модуль в Python, который нам не нужно устанавливать извне.
- Временная задержка означает, что мы добавляем задержку во время выполнения в наш программный код. Он должен быть между двумя операторами или между любой частью программного кода, по вашему мнению.
time.sleep (значение)
- Импортировать модуль времени
- Для добавления временной задержки во время выполнения мы используем функцию sleep () между двумя операторами, между которыми нам нужна задержка. В функции sleep () параметр передается как целое число или значение с плавающей запятой.
- Запустите программу.
- Обратите внимание на задержку времени выполнения.
Python3
# importing module
time import
# running loop from 0 to 4
for i in range ( 0 , 5 ):
# printing numbers
# adding 2 seconds time delay
time.sleep( 2 )
Выход: Пример 2: Эффектная печать с использованием sleep () для каждого символа.
Python3
# importing time module
time import
def message(string):
for i in string:
# printing each character of the message
print (i, end = «»)
# adding time delay of half second
time.sleep( 0.5 )
# main function
if __name__ = = ‘__main__’ :
msg = «Its looks like auto typing»
# calling the function for printing the
# characters with delay
message(msg)
Выход: Пример 3: Печать шаблона, взяв диапазон от пользователя и добавив временную задержку. Выход: Пример 4: Многопоточность с использованием sleep ()
Python3
time import
from threading import Thread
# making first thread of Geeks
class Geeks(Thread):
def run( self ):
for x in range ( 4 ):
print ( «Geeks» )
# adding delay of 2.2 seconds
time.sleep( 2.2 )
# making second thread of For
class For(Thread):
def run( self ):
for x in range ( 3 ):
print ( ‘For’ )
# adding delay of 2.3 seconds
time.sleep( 2.3 )
print ( «Hello» )
# making the object for both the
# threads separately
# starting the first thread
# starting the second thread
# waiting for the both thread to join
# after completing their job
# when threads complete their jobs
# message will be printed
print ( «All Done!!» )
Выход: Внимание компьютерщик! Укрепите свои основы с помощью базового курса программирования Python и изучите основы. Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS. А чтобы начать свое путешествие по машинному обучению, присоединяйтесь к курсу Машинное обучение — базовый уровень.