Como usar a função waiting em Python eficientemente

Python sleep(): Como adicionar atrasos de tempo ao seu código

Por Mike Driscoll (intermediário)

Você já precisou fazer com que o seu programa Python esperasse por algo? Na maioria das vezes, você quer que o seu código seja executado o mais rápido possível. Mas existem momentos em que é melhor deixar o seu código “dormir” por um tempo.

Por exemplo, você pode usar a função sleep() do Python para simular um atraso no seu programa. Talvez você precise esperar um arquivo ser carregado ou baixado, ou esperar que um gráfico seja exibido na tela. Você também pode precisar pausar entre chamadas de uma API da web ou entre consultas a um banco de dados. Adicionar chamadas de sleep() ao seu programa Python pode ser útil em cada um desses casos, e muitos outros!

Neste tutorial, você aprenderá como adicionar chamadas de sleep() ao seu programa Python utilizando:

• time.sleep()
• Decoradores
• Threads
• Async IO
• Interfaces gráficas do usuário

Este artigo é destinado a desenvolvedores intermediários que desejam aumentar seu conhecimento em Python. Se isso se aplica a você, vamos começar!

Adicionando uma chamada de sleep() com time.sleep()

O Python possui suporte embutido para fazer o seu programa esperar. O módulo time possui uma função chamada sleep() que você pode usar para suspender a execução da thread chamadora pelo número de segundos especificado.

Aqui está um exemplo de como usar time.sleep():

import time
time.sleep(3) # Espera por 3 segundos

Se você executar este código no seu console, deverá experimentar um atraso antes de poder inserir um novo comando no console.

Observação: A partir do Python 3.5, os desenvolvedores do Python mudaram ligeiramente o comportamento do time.sleep(). A chamada de sistema sleep() do novo Python durará pelo menos o número de segundos especificado, mesmo se o sleep for interrompido por um sinal. No entanto, isso não se aplica se o próprio sinal gerar uma exceção.

Você pode testar quanto tempo o sleep() vai durar usando o módulo timeit do Python:

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

Aqui, você executa o módulo timeit com o parâmetro -n, que indica quantas vezes executar a instrução que segue. Você pode ver que o timeit executou a instrução 3 vezes e que o tempo de execução mais rápido foi de 3 segundos, como esperado.

O número padrão de vezes em que o timeit executará o seu código é um milhão. Se você executar o código acima com o -n padrão, em 3 segundos por iteração, seu terminal ficará parado por aproximadamente 34 dias! O módulo timeit possui várias outras opções de linha de comando que você pode verificar na sua documentação.

Vamos criar algo um pouco mais realista. Um administrador do sistema precisa saber quando um dos seus sites fica fora do ar. Você quer ser capaz de verificar regularmente o código de status do site, mas não quer sobrecarregar o servidor com muitas requisições. Você pode facilmente fazer isso usando a função sleep():

import time
import requests

while True:
    response = requests.get("https:https://codemdd.io/www.example.com")
    if response.status_code != 200:
        print("Site is down!")
    time.sleep(60) # Espera por 60 segundos antes de fazer a próxima verificação

Este código verifica regularmente o status do site “https:https://codemdd.io/www.example.com” e exibe uma mensagem se o código de status for diferente de 200. Em seguida, ele espera por 60 segundos antes de fazer a próxima verificação. Dessa forma, você evita sobrecarregar o servidor com solicitações.

Adicionando uma chamada de sleep() com decoradores

Os decoradores são uma forma avançada de usar funções no Python. Neste caso, você pode usar um decorador para adicionar a funcionalidade de sleep() a outras funções. Aqui está um exemplo de como fazer isso:

import time

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

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

print(print_hello()) # Vai esperar por 2 segundos antes de imprimir "Hello, world!"

Neste exemplo, definimos um decorador chamado sleep_decorator que espera por 2 segundos antes de chamar a função decorada. Em seguida, usamos o decorador @sleep_decorator para decorar a função print_hello(), fazendo com que ela espere por 2 segundos antes de imprimir “Hello, world!“.

Adicionando uma chamada de sleep() com Threads

As threads são uma forma de realizar várias tarefas simultaneamente em um programa Python. Você pode usar threads para adicionar chamadas de sleep() a diferentes partes do seu código. Aqui está um exemplo de como fazer isso:

import time
import threading

def sleep_function(seconds):
    time.sleep(seconds)
    print("Sleep complete!")

# Criar as threads e iniciar a execução
thread1 = threading.Thread(target=sleep_function, args=[2])
thread1.start()

thread2 = threading.Thread(target=sleep_function, args=[4])
thread2.start()

# Aguardar a conclusão das threads
thread1.join()
thread2.join()

print("Programa concluído!")

Neste exemplo, definimos uma função chamada sleep_function() que utiliza a função sleep() para esperar o número de segundos passado como argumento. Criamos duas threads, cada uma chamando a função sleep_function() com diferentes argumentos. Em seguida, iniciamos a execução das threads com o método start(). Por fim, aguardamos a conclusão das threads com o método join() e imprimimos uma mensagem indicando que o programa foi concluído.

Esse é apenas um exemplo simples de como usar threads com a função sleep(). As threads podem ser úteis quando você precisa realizar várias tarefas simultaneamente ou quando deseja interromper a execução do seu programa enquanto espera por algo.

Adicionando uma chamada de sleep() com Async IO

A programação assíncrona é uma forma avançada de lidar com tarefas concorrentes em um programa Python. O módulo asyncio fornece suporte para esse tipo de programação. Aqui está um exemplo de como adicionar uma chamada de sleep() usando Async IO:

import asyncio

async def sleep_coroutine():
    await asyncio.sleep(2)
    print("Sleep complete!")

# Criar a event loop
loop = asyncio.get_event_loop()

# Rodar o coroutine na event loop
loop.run_until_complete(sleep_coroutine())

# Fechar a event loop
loop.close()

print("Programa concluído!")

Neste exemplo, definimos um coroutine chamado sleep_coroutine() usando a palavra-chave async. Dentro do coroutine, utilizamos a função sleep() do módulo asyncio para esperar 2 segundos. Em seguida, usamos a função run_until_complete() para rodar o coroutine na event loop e imprimir uma mensagem após a espera. Por fim, fechamos a event loop usando o método close().

A programação assíncrona pode ser útil quando você precisa lidar com tarefas concorrentes em um programa Python. Você pode usar o Async IO para adicionar chamadas de sleep() em partes específicas do seu código que requerem espera assíncrona.

Adicionando uma chamada de sleep() com interfaces gráficas de usuário (GUIs)

Se você estiver desenvolvendo uma aplicação com interface gráfica de usuário usando bibliotecas como Tkinter ou wxPython, pode utilizar as próprias funcionalidades de sleep() dessas bibliotecas para criar atrasos. Aqui está um exemplo de como fazer isso usando Tkinter:

import time
import tkinter as tk

def sleep_print():
    time.sleep(2) # Espera por 2 segundos
    print("Sleep complete!")

# Criar a janela
window = tk.Tk()

# Criar um botão que chama a função sleep_print() quando clicado
button = tk.Button(window, text="Click me", command=sleep_print)
button.pack()

# Rodar a janela
window.mainloop()

Neste exemplo, importamos a biblioteca time e a biblioteca Tkinter para criar uma janela com um botão. Quando o botão é clicado, ele chama a função sleep_print(), aguarda por 2 segundos usando a função sleep() e, em seguida, imprime uma mensagem indicando que a espera foi concluída.

Você pode adaptar esse exemplo para usar outras bibliotecas de GUI, como wxPython, substituindo as partes específicas do código. O objetivo é mostrar como você pode adicionar chamadas de sleep() em uma aplicação com interface gráfica de usuário.

Conclusão

Neste tutorial, você aprendeu várias maneiras de adicionar chamadas de sleep() ao seu código Python. A função sleep() do módulo time é a forma mais básica de adicionar atrasos de tempo, enquanto os decoradores, threads, Async IO e interfaces gráficas de usuário oferecem maneiras mais avançadas de lidar com espera em diferentes contextos.

Agora que você conhece essas técnicas, pode usar a função sleep() para adicionar atrasos no seu código quando necessário. Lembre-se de considerar cuidadosamente o tempo de espera necessário para evitar impor atrasos desnecessários ao seu programa.