Функция time.sleep() в Python: задержка выполнения

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

Синтаксис time.sleep()

Функция входит в стандартный модуль time, устанавливать ничего не нужно. Единственный аргумент - время паузы в секундах, целое или дробное число. Возвращает функция None.

import time

print('Старт')
time.sleep(2.4)          # пауза 2,4 секунды
print('Прошло 2.4 секунды')

Миллисекунды передают дробью: time.sleep(0.5) это 500 мс, time.sleep(0.001) одна миллисекунда. Удобно записывать time.sleep(250 / 1000), чтобы было видно исходное значение. Отрицательное число вызовет ValueError, а ноль просто отдаст процессорное время другим потокам.

Если функция нужна часто, ее импортируют напрямую: from time import sleep, после чего вызывают как sleep(1).

Точность паузы

sleep() гарантирует паузу не меньше заданной, но может спать немного дольше: операционная система должна снова выделить потоку процессор. Обычно погрешность составляет доли миллисекунды в Linux и около миллисекунды в Windows. С Python 3.11 в Windows используется таймер высокого разрешения, раньше пауза могла округляться до 15,6 мс.

import time

start = time.perf_counter()
time.sleep(0.05)
elapsed = time.perf_counter() - start
print(f'{elapsed * 1000:.2f} мс')   # например 50.12 мс

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

import time

interval = 1.0
next_run = time.monotonic()
for _ in range(5):
    print('тик', round(time.monotonic(), 2))
    next_run += interval
    time.sleep(max(0, next_run - time.monotonic()))

Для замера скорости самого кода sleep() не нужен, для этого есть модуль timeit.

Примеры использования

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

Цифровые часы в консоли

Бесконечный цикл раз в секунду получает текущее время и печатает его в одной строке, перезаписывая предыдущее значение символом возврата каретки. Остановить часы можно сочетанием Ctrl+C.

import time

try:
    while True:
        now = time.strftime('%H:%M:%S')
        print(now, end='\r', flush=True)
        time.sleep(1)
except KeyboardInterrupt:
    print('\nЧасы остановлены')

Пауза между запросами к сайту

При парсинге без задержек сервер может заблокировать IP за слишком частые обращения. Случайная пауза в 1-3 секунды делает нагрузку мягче. Пример использует библиотеку requests.

import random
import time
import requests

urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    response = requests.get(url, timeout=10)
    print(url, response.status_code)
    time.sleep(random.uniform(1, 3))

Повтор с нарастающей задержкой

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

import time

def with_retry(func, attempts=4, delay=1):
    for attempt in range(1, attempts + 1):
        try:
            return func()
        except ConnectionError as err:
            if attempt == attempts:
                raise
            print(f'Ошибка: {err}, повтор через {delay} с')
            time.sleep(delay)
            delay *= 2

Обратный отсчет

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

import time

for sec in range(5, 0, -1):
    print(f'Старт через {sec}...')
    time.sleep(1)
print('Поехали')

Функция sleep() в потоках

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

import threading
import time

def worker(word, pause):
    for _ in range(4):
        time.sleep(pause)
        print(word)

t1 = threading.Thread(target=worker, args=('Hello', 0.5))
t2 = threading.Thread(target=worker, args=('Hi', 0.7))
t1.start()
t2.start()
t1.join()
t2.join()

Порядок строк зависит от моментов пробуждения: Hello появится в 0,5, 1,0, 1,5 и 2,0 секунды, Hi в 0,7, 1,4, 2,1 и 2,8. Вызовы join() заставляют основной поток дождаться завершения обоих.

Как прервать ожидание досрочно

Остановить уже начавшийся sleep() из другого потока нельзя. Если фоновый поток спит минуту, программа при выходе будет ждать эту минуту. Для пауз, которые нужно уметь прерывать, используйте threading.Event: метод wait(timeout) ждет столько же, сколько sleep(), но мгновенно просыпается после вызова set().

import threading

stop = threading.Event()

def background():
    while not stop.is_set():
        print('проверяю почту')
        stop.wait(60)     # спит до 60 с или до stop.set()

threading.Thread(target=background).start()
# ... позже в основном потоке:
stop.set()

В основном потоке сон прерывается нажатием Ctrl+C: возникает исключение KeyboardInterrupt, которое можно перехватить, как в примере с часами.

Альтернативы time.sleep()

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

import asyncio

async def tick(name, pause):
    for i in range(3):
        await asyncio.sleep(pause)
        print(name, i)

async def main():
    await asyncio.gather(tick('A', 0.3), tick('B', 0.5))

asyncio.run(main())

Обе корутины работают одновременно в одном потоке именно потому, что asyncio.sleep() не блокирует цикл событий. Описание функции есть в документации модуля time.

Частые вопросы

Короткие ответы на популярные вопросы о задержках в Python.

Как сделать паузу в миллисекундах?

Передайте дробное число секунд: time.sleep(0.2) дает паузу 200 мс. Отдельной функции для миллисекунд в модуле time нет.

Можно ли сделать паузу в минутах?

Умножьте минуты на 60: time.sleep(5 * 60). Для запуска задач по расписанию надежнее планировщик ОС (cron, Планировщик заданий Windows), чем программа, которая часами спит.

Почему программа на asyncio зависает на sleep?

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

Нагружает ли sleep() процессор?

Нет. Поток переводится в состояние ожидания и не потребляет процессорное время, в отличие от пустого цикла, который постоянно проверяет часы.

Как подождать до определенного времени суток?

Вычислите разницу между целевым и текущим моментом через datetime и передайте ее в секундах: time.sleep((target - datetime.now()).total_seconds()), предварительно убедившись, что разница положительная.