Как использовать команду ожидания в Python?

[

Как добавить задержку времени в ваш код с помощью функции sleep() в Python

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

В этом руководстве вы узнаете, как добавить задержку времени с помощью функции sleep() в Python с использованием следующих инструментов:

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

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

Бесплатный бонус: Получите наш бесплатный руководство “The Power of Python Decorators” , которое показывает три продвинутых шаблона и техники использования декораторов, которые помогут вам написать более чистый и более Pythonic код.

Добавление задержки времени с помощью `time.sleep()`

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

import time
time.sleep(3) # Задержка выполнения на 3 секунды

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

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

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

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

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

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

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

import requests
import time

def check_website(url):
    while True:
        try:
            response = requests.get(url)
            if response.ok:
                print(f"The website {url} is available")
            else:
                print(f"The website {url} returned a {response.status_code} status code")
            time.sleep(60) # Ожидание 60 секунд перед следующей проверкой
        except requests.ConnectionError:
            print(f"The website {url} is currently unavailable")
            time.sleep(60) # Ожидание 60 секунд перед следующей проверкой

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

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

Добавление задержки времени с помощью декораторов

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

Вот пример декоратора, который добавляет задержку в 2 секунды перед выполнением функции:

import time

def sleep_decorator(func):
    def wrapper():
        time.sleep(2)
        return func()
    return wrapper

@sleep_decorator
def say_hello():
    return "Hello, world!"

print(say_hello())  # Задержка 2 секунды, затем выводит "Hello, world!"

Здесь мы определяем декоратор sleep_decorator, который принимает функцию func в качестве параметра. Внутри декоратора мы объявляем новую функцию-обертку wrapper(), которая использует функцию time.sleep() для добавления задержки в 2 секунды перед вызовом исходной функции func(). Затем мы возвращаем эту обернутую функцию wrapper.

Чтобы применить декоратор sleep_decorator к исходной функции say_hello(), мы используем синтаксис @decorator_name перед определением функции. Здесь мы помечаем функцию say_hello() декоратором sleep_decorator.

После выполнения функции say_hello() будет добавлена задержка в 2 секунды перед выводом строки “Hello, world!“. Это полезно, если вам нужно добавить задержку перед выполнением определенных действий, например, перед отправкой запроса к внешнему сервису.

Добавление задержки времени с помощью потоков

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

Например, вот как можно использовать потоки для добавления задержки в 2 секунды:

import threading
import time

def delay():
    print("Starting delay...")
    time.sleep(2)
    print("Delay complete!")

thread = threading.Thread(target=delay)
thread.start()

print("Task started!")

thread.join()

print("Program completed!")

Здесь мы создаем функцию delay(), которая просто добавляет задержку в 2 секунды с помощью функции time.sleep(). Затем мы создаем поток thread с целью выполнить функцию delay(). Мы запускаем поток thread с помощью метода start().

Затем мы выводим сообщение “Task started!” после запуска потока. Метод join() блокирует выполнение программы и ждет завершения потока thread. Когда поток завершается, программа продолжает свое выполнение и выводит “Program completed!“.

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

Добавление задержки времени с помощью Async IO

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

Вот пример кода, который использует Async IO для добавления задержки в 2 секунды:

import asyncio

async def delay():
    print("Starting delay...")
    await asyncio.sleep(2)
    print("Delay complete!")

async def main():
    print("Task started!")
    await delay()
    print("Program completed!")

asyncio.run(main())

Здесь мы определяем асинхронную функцию delay(), которая добавляет задержку в 2 секунды с помощью функции asyncio.sleep(). Затем мы создаем асинхронную функцию main(), которая вызывает функцию delay() и ожидает ее выполнения с помощью ключевого слова await. После выполнения функции delay() программа продолжает свое выполнение и выводит “Program completed!“.

Наконец, мы используем функцию asyncio.run() для запуска асинхронной функции main(). Это позволяет нам запустить асинхронный код в глобальной области видимости.

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

Добавление задержки времени в графические пользовательские интерфейсы

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

Вот пример использования функции after() в Tkinter для добавления задержки в 2 секунды:

import tkinter as tk

def delay():
    print("Starting delay...")
    root.after(2000, delayed_action)

def delayed_action():
    print("Delayed action!")

root = tk.Tk()

btn = tk.Button(root, text="Click me", command=delay)
btn.pack()

root.mainloop()

Здесь мы создаем функцию delay(), которая вызывает функцию root.after() с задержкой в 2000 миллисекунд (2 секунды). Затем мы определяем отложенное действие delayed_action(), которое будет выполнено после заданной задержки.

После этого мы создаем окно Tkinter и кнопку, которая вызывает функцию delay() при нажатии. Затем мы запускаем главный цикл окна с помощью метода mainloop(), который отображает интерфейс и обрабатывает события.

Аналогично можно добавить задержку времени с использованием объектов в wxPython. В обоих случаях использование функции after() или аналогичной функции в вашей библиотеке GUI позволяет добавлять задержку времени в вашем пользовательском интерфейсе.

Выводы

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

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