В этом руководстве вы узнаете, как использовать функцию sleep() из встроенного модуля синхронизации Python для добавления временных задержек в ваш код.
Когда вы запускаете простую программу на Python, выполнение кода происходит последовательно — одно выражение за другим — без каких-либо задержек. Однако в некоторых случаях может потребоваться отложить выполнение кода. В этом вам поможет функция sleep() из встроенного модуля синхронизации Python.
В этом руководстве вы изучите синтаксис использования функции sleep() в Python и несколько примеров, которые помогут вам понять, как она работает. Давайте начнем!
Содержание
Синтаксис Python time.sleep()
Модуль time, встроенный в стандартную библиотеку Python, предоставляет несколько полезных функций, связанных со временем. В качестве первого шага импортируйте модуль времени в рабочую среду:
import time
Поскольку функция sleep() является частью модуля time, теперь вы можете получить к ней доступ и использовать ее со следующим общим синтаксисом:
time.sleep(n)
Здесь n — количество секунд до сна. Это может быть целое число или число с плавающей запятой.
Иногда необходимая задержка может составлять несколько миллисекунд. В этих случаях вы можете преобразовать продолжительность в миллисекундах в секунды и использовать ее в вызове функции сна. Например, если вы хотите ввести задержку в 100 миллисекунд, вы можете указать ее как 0,1 секунды: time.sleep(0,1).
▶ Вы также можете импортировать только функцию сна из модуля времени:
from time import sleep
Если вы используете описанный выше метод импорта, вы можете вызвать функцию sleep() напрямую, без использования time.sleep().
Теперь, когда вы изучили синтаксис функции Python sleep(), давайте напишем несколько примеров кода, чтобы увидеть функцию в действии. Вы можете загрузить сценарии Python, используемые в этом руководстве, из папки python-sleep в этом репозитории GitHub. ???
Задержка выполнения кода с помощью sleep()
В качестве первого примера воспользуемся функцией сна, чтобы отложить выполнение простой программы на Python.
В следующем фрагменте кода:
- Первый оператор print() выполняется без задержки.
- Затем мы вводим 5-секундную задержку, используя функцию sleep().
- Второй оператор print() будет выполнен только после завершения операции бездействия.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Теперь запустите файл simple_ekample.pi и посмотрите на результат:
$ python3 simple_example.py
Добавьте разные задержки в кодовый блок
В предыдущем примере мы ввели фиксированную задержку в 5 секунд между выполнением двух операторов print(). Затем давайте напишем еще один пример, чтобы ввести разные времена задержки при циклическом выполнении итераций.
В этом примере мы хотим сделать следующее:
- Пройдите предложение, откройте каждое слово и распечатайте его.
- После печати каждого слова мы хотели бы подождать определенное время — прежде чем напечатать следующее слово в предложении.
Он перебирает массив строк
Рассмотрим строку, предложение. Это строка, где каждое слово является строкой само по себе.
Если мы перебираем строку, мы получаем каждый символ, как показано ниже:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Но это не то, чего мы хотим. Мы хотели бы пройтись по предложению и получить доступ к каждому слову. Для этого мы можем вызвать метод split() для строки предложения. Это вернет список строк, полученных путем деления строки предложений, при всех вхождениях пробелов.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Перебирать итерации с разными задержками
Вернемся к примеру:
- предложение — это строка, которую мы хотим пройти, чтобы получить доступ к каждому слову.
- delay_times — это список времен задержки, которые мы будем использовать в качестве аргумента функции sleep() во время каждого прохождения цикла.
Здесь мы хотим пройтись по двум спискам одновременно: список delay_times и список строк, полученных путем деления последовательности предложений. Вы можете использовать функцию zip() для выполнения этой параллельной итерации.
Функция Python zip(): zip(list1, list2) возвращает итератор кортежей, где каждый кортеж содержит элемент с индексом как в списке1, так и в списке2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)
Без функции сна управление сразу переходило бы к следующей итерации. Поскольку мы ввели задержку, следующий проход по циклу происходит только после завершения операции бездействия.
Теперь запустите delay_times.pi и посмотрите на вывод:
$ python3 delay_times.py
Следующие слова в строке будут напечатаны после задержки. Задержка после печати слова с индексом i в массиве равна числу с индексом i в списке delay_times.
Таймер обратного отсчета в Python
В качестве следующего примера давайте напишем простой таймер обратного отсчета на Python.
Давайте определим функцию countDown():
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)
Далее разберем определение функции countDown():
- Функция принимает число n в качестве аргумента и ведет обратный отсчет до нуля, начиная с этого числа n.
- Мы используем time.sleep(1) для достижения задержки в одну секунду между отсчетами.
- Когда число достигает 0, функция печатает «Готово к запуску!».
? Чтобы реализовать операцию обратного отсчета, мы использовали функцию range() с отрицательным значением шага, равным -1. range(n, -1, -1) поможет нам перебрать диапазон чисел в n, n – 1, n – 2 и так далее до нуля. Напомним, что конечная точка по умолчанию отключена при использовании функции range().
Далее добавим вызов функции countDown() с 5 в качестве аргумента.
countDown(5)
Теперь запустите скрипт countdown.pi и посмотрите, как работает функция countDown!
$ python3 countdown.py
Функция сна в многопоточности
Модуль потоков Python предлагает готовые возможности многопоточности. В Python глобальная блокировка интерпретатора или GIL гарантирует, что в любой момент времени существует только один активный поток.
Однако во время операций ввода-вывода и операций ожидания, таких как сон, процессор может приостановить выполнение текущего потока и переключиться на другой ожидающий поток.
Чтобы понять, как это работает, давайте рассмотрим пример.
Создание и запуск потоков в Python
Рассмотрим следующие функции: func1(), func2() и func3(). Они пробегают строку чисел и распечатывают их. За этим следует операция сна — в течение заданного количества секунд — во время каждого прохода по циклу. Мы использовали разное время задержки для каждой из функций, чтобы лучше понять, как выполнение переключается между потоками одновременно.
import time
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
В Python вы можете использовать конструктор Thread() для создания экземпляра объекта Thread. Использование синтаксиса threading.Thread(target = …, args = …) создает поток, который запускает целевую функцию с аргументом, указанным в кортеже args.
В этом примере функции func1, func2 и func3 не принимают аргументов. Так что достаточно указать только имя функции в качестве цели. Затем мы определяем объекты потока, t1, t2 и t3 с func1, func2 и func3 в качестве целей соответственно.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Вот полный код для примера потока:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Наблюдайте за выходом. Выполнение чередуется между тремя потоками. Поток t3 имеет наименьшее время ожидания, поэтому он приостанавливается на наименьшее количество времени. Поток t1 имеет наибольшую продолжительность простоя, составляющую две секунды, поэтому он является последним потоком, завершившим выполнение.
Чтобы узнать больше, прочитайте учебник по основам многопоточности Python.
Заключение
В этом руководстве вы узнали, как использовать функцию Python sleep() для добавления временных задержек в ваш код.
Вы можете получить доступ к функции sleep() из встроенного модуля time, time.sleep(). Чтобы отложить выполнение на n секунд, используйте time.sleep(n). Кроме того, вы видели примеры задержки последующих итераций в цикле для разных значений, обратного отсчета и многопоточности.
Теперь вы можете изучить более продвинутые возможности модуля погоды. Хотите работать с датами и временем в Python? В дополнение к модулю времени вы можете воспользоваться функциональностью модулей даты и календаря.
Тогда научитесь рассчитывать разницу во времени в Python.⏰
