Como adicionar um atraso de tempo em um script Python?

Ao trabalhar com Python, você pode se encontrar em uma situação em que precisa pausar a execução do seu script por um determinado período de tempo. Isso é comumente conhecido como adicionar atraso de tempo em Python. Seja esperando a geração de um arquivo, dando tempo para um usuário ler uma mensagem ou simplesmente espaçando chamadas de API, os atrasos de tempo podem ser bastante úteis. Neste post, vamos explorar como implementar atrasos de tempo em Python usando o módulo time e a função sleep.

Usando a Função sleep

A maneira mais simples de criar um atraso de tempo em Python é usando a função sleep do módulo time. Esta função recebe um argumento: o número de segundos que você quer que o programa faça uma pausa. Aqui está um exemplo básico:

import time

# Atrasa por 2,5 segundos
time.sleep(2.5)

Neste trecho, o script vai pausar por 2,5 segundos antes de prosseguir para a próxima linha de código.

Atraso de Tempo em um Loop

Se você quiser criar um atraso de tempo recorrente, como realizar uma ação uma vez a cada minuto, você pode usar um loop:

import time

while True:
    print("Isso é impresso uma vez por minuto.")
    time.sleep(60)  # Atraso de 1 minuto (60 segundos)

Este loop vai imprimir uma mensagem no console e depois esperar 60 segundos antes de imprimi-la novamente, indefinidamente.

Atrasos Sub-Segundo

A função sleep também pode lidar com atrasos sub-segundo, aceitando um float como argumento. Isso é útil para pausas muito curtas:

from time import sleep

# Atrasa por 0,1 segundos
sleep(0.1)

Usando sleep com Funções

Você também pode usar sleep para atrasar a execução de uma função. Aqui está um exemplo:

from time import sleep

def hora_da_festa():
    print('viva!')

# Espera por 3 segundos antes de chamar hora_da_festa
sleep(3)
hora_da_festa()

Após executar este script, “viva!” será impresso 3 segundos após a função sleep ser chamada.

Avançado: Multithreading e Multiprocessing

Para cenários mais complexos, você pode estar trabalhando com múltiplas threads ou processos. A função sleep ainda é aplicável para adicionar atraso de tempo, pois ela suspende a thread em que é chamada, permitindo que outras threads ou processos executem.

Aqui está um exemplo usando sleep com multithreading e multiprocessing:

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from time import sleep, time

def festa_mais_tarde(tipo='', n=''):
    sleep(3)
    return f"{tipo}{n} hora da festa!"

def main():
    with ProcessPoolExecutor() as executor_de_processos:
        with ThreadPoolExecutor() as executor_de_threads:
            tempo_inicial = time()
            futuros = [
                executor_de_processos.submit(festa_mais_tarde, tipo='proc', n='1'),
                executor_de_processos.submit(festa_mais_tarde, tipo='proc', n='2'),
                executor_de_threads.submit(festa_mais_tarde, tipo='thread', n='1'),
                executor_de_threads.submit(festa_mais_tarde, tipo='thread', n='2')
            ]
            for f in as_completed(futuros):
                print(f.result())
            tempo_final = time()
    print(f"Tempo total para executar quatro funções de 3 segundos: {tempo_final - tempo_inicial}")

if __name__ == '__main__':
    main()

Este script demonstra como você pode executar funções que incluem um atraso em threads e processos separados, e mostrará o tempo total levado para executar todas as funções.

Resumo

Neste post, cobrimos como adicionar atrasos de tempo em seus scripts Python usando a função sleep do módulo time. Vimos como usá-la para atrasos únicos, dentro de loops para atrasos repetidos, para precisão sub-segundo e dentro de ambientes multithreaded e multiprocessados. Atrasos de tempo são uma ferramenta simples, mas poderosa, no controle do fluxo dos seus programas Python.