Comando wait em Python: como usar eficientemente?

[

Python wait command: Como adicionar atrasos de tempo ao seu código

por Mike Driscoll (intermediário)

Você já precisou fazer o seu programa em Python esperar por algo? Na maioria das vezes, você quer que o seu código seja executado o mais rápido possível. Mas há momentos em que deixar o seu código dormir por um tempo é realmente do seu interesse.

Por exemplo, você pode usar a função sleep() em Python para simular um atraso em seu programa. Talvez você precise esperar o upload ou o download de um arquivo, ou o carregamento ou o desenho de uma imagem na tela. Talvez você até precise pausar entre chamadas a uma API web, ou entre consultas a um banco de dados. Adicionar chamadas sleep() em Python ao seu programa pode ajudar em cada um desses casos, e em muitos outros!

Neste tutorial, você aprenderá como adicionar chamadas sleep() em Python usando:

time.sleep()
Decoradores
Threads
Async IO
Interfaces Gráficas do Usuário

Este artigo é destinado a desenvolvedores intermediários que desejam expandir seus conhecimentos em Python. Se você se enquadra nesse perfil, então vamos começar!

Adicionando uma chamada sleep() em Python com time.sleep()

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

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

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

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

Nota: No Python 3.5, os desenvolvedores principais modificaram ligeiramente o comportamento da função time.sleep(). A nova chamada sleep() em Python durará pelo menos o número de segundos especificado, mesmo que o sleep seja interrompido por um sinal. Isso não se aplica se o próprio sinal gerar uma exceção, no entanto.

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

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

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

O número padrão de vezes que o timeit executará o seu código é de um milhão. Se você executar o código acima com o -n padrão, então, a 3 segundos por iteração, seu terminal ficará pendurado por aproximadamente 34 dias! O módulo timeit tem 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 de sistemas precisa saber quando um de seus sites fica fora do ar. Você quer ser capaz de verificar o código de status do site regularmente, mas não quer que seu programa em Python fique em um loop infinito consumindo recursos. Em vez disso, você quer que o programa verifique o status a cada 30 segundos. Aqui está como você pode atingir esse objetivo:

import time

while True:
    # Faz a verificação do status do site aqui
    print("Verificando status do site...")
    time.sleep(30)

O código acima criará um loop infinito que verifica o status do site a cada 30 segundos. O time.sleep(30) é responsável por fazer o programa dormir por 30 segundos antes de fazer a próxima verificação.

Agora você sabe como usar a função sleep() em Python para adicionar atrasos de tempo ao seu código! Na próxima seção, exploraremos como adicionar chamadas sleep() em Python utilizando decoradores.

Adicionando uma chamada sleep() em Python com Decoradores

Em Python, os decoradores são uma maneira poderosa de adicionar funcionalidades extras a funções e métodos existentes. Isso inclui a capacidade de adicionar atrasos de tempo a funções usando a função sleep(). Aqui está um exemplo de como usar um decorador para adicionar um atraso de 2 segundos a uma função:

import time

def add_delay(func):
    def wrapper(*args, **kwargs):
        time.sleep(2)
        return func(*args, **kwargs)
    return wrapper

@add_delay
def hello():
    print("Olá, mundo!")

hello()

No exemplo acima, definimos um decorador chamado add_delay, que envolve a função passada a ele em uma função wrapper. A função wrapper adiciona um atraso de 2 segundos usando time.sleep(2), e então chama a função original passada a add_delay usando return func(*args, **kwargs). O decorador é aplicado à função hello adicionando a anotação @add_delay acima da definição da função.

Quando chamamos hello(), o decorador add_delay é executado, adicionando um atraso de 2 segundos antes de imprimir “Olá, mundo!” na tela.

Os decoradores são uma maneira poderosa de adicionar funcionalidades extras a funções sem modificar seu código original. Você pode usar essa técnica para adicionar atrasos de tempo a qualquer função em seu programa Python.

Na próxima seção, exploraremos como adicionar chamadas sleep() em Python usando Threads.

Adicionando uma chamada sleep() em Python com Threads

Nesta seção, você aprenderá como adicionar chamadas sleep() em Python usando Threads. Threads são uma forma de executar várias partes do código simultaneamente em Python, imitando a execução concorrente. Aqui está um exemplo de como usar um thread para adicionar um atraso de 5 segundos a uma função:

import time
import threading

def delay_function():
    time.sleep(5)
    print("Atraso de 5 segundos!")

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

No exemplo acima, definimos uma função chamada delay_function que adiciona um atraso de 5 segundos usando time.sleep(5) e imprime “Atraso de 5 segundos!“. Em seguida, criamos uma nova instância da classe Thread do módulo threading e passamos a função delay_function como o alvo para o Thread. Finalmente, chamamos thread.start() para iniciar a execução do thread.

Quando executamos esse código, o thread criado executará a função delay_function em paralelo com o resto do nosso programa. Isso significa que a função delay_function fará um atraso de 5 segundos enquanto outras partes do nosso programa continuam executando normalmente.

Esse é um exemplo simples, mas mostra como adicionar uma chamada sleep() em Python usando threads pode ser útil quando você precisa adicionar atrasos a partes específicas do seu programa.

Na próxima seção, exploraremos como adicionar chamadas sleep() em Python usando Async IO.

Adicionando uma chamada sleep() em Python com Async IO

O Async IO é uma forma de programação assíncrona em Python que permite que você execute várias tarefas de forma concorrente e lidar com atrasos de tempo de maneira eficiente. Aqui está um exemplo de como usar o Async IO para adicionar um atraso de 2 segundos em uma função:

import asyncio

async def delay_function():
    await asyncio.sleep(2)
    print("Atraso de 2 segundos!")

asyncio.run(delay_function())

No exemplo acima, definimos uma função chamada delay_function como uma função assíncrona usando a palavra-chave async. Em seguida, usamos a função asyncio.sleep(2) para adicionar um atraso de 2 segundos e a palavra-chave await para esperar a conclusão do atraso. Por fim, chamamos a função asyncio.run(delay_function()) para executar a função delay_function.

Ao executar esse código, o atraso de 2 segundos é adicionado de forma assíncrona, permitindo que outras partes do seu programa continuem a se executar normalmente. Essa abordagem é útil quando você precisa fazer várias tarefas ao mesmo tempo e controlar o tempo de execução de cada tarefa de forma eficiente.

Na próxima seção, exploraremos como adicionar chamadas sleep() em Python em interfaces gráficas do usuário.

Adicionando uma chamada sleep() em Python em interfaces gráficas do usuário

Se você estiver desenvolvendo um programa com uma interface gráfica, como um aplicativo de desktop, poderá querer adicionar atrasos de tempo para criar efeitos de animação ou imitar o atraso de carregamento de elementos visuais. Vamos explorar como adicionar chamadas sleep() em Python em duas bibliotecas populares de interface gráfica: Tkinter e wxPython.

Dormindo em Tkinter

Tkinter é uma biblioteca padrão do Python para criar interfaces gráficas. Aqui está um exemplo de como adicionar um atraso de 2 segundos em uma GUI Tkinter usando sleep():

import tkinter as tk
import time

def start_animation():
    # Faça algo antes do atraso
    time.sleep(2)
    # Faça algo após o atraso

root = tk.Tk()
button = tk.Button(root, text="Iniciar Animação", command=start_animation)
button.pack()
root.mainloop()

No exemplo acima, definimos uma função chamada start_animation que faz algo antes do atraso usando time.sleep(2) e faz algo após o atraso. Em seguida, criamos uma janela Tkinter, um botão e vinculamos a função start_animation ao clique do botão.

Ao clicar no botão, o atraso de 2 segundos é adicionado antes que o código continue executando. Isso pode ser usado para simular o carregamento de elementos visuais ou adicionar efeitos de animação a uma GUI.

Dormindo em wxPython

wxPython é outra biblioteca popular para criar interfaces gráficas em Python. Aqui está um exemplo de como adicionar um atraso de 2 segundos em uma GUI wxPython usando sleep():

import wx
import time

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title="Exemplo de Atraso")
        panel = wx.Panel(self)
        button = wx.Button(panel, label="Iniciar Animação")
        button.Bind(wx.EVT_BUTTON, self.start_animation)

    def start_animation(self, event):
        # Faça algo antes do atraso
        time.sleep(2)
        # Faça algo após o atraso

app = wx.App()
frame = MyFrame()
frame.Show()
app.MainLoop()

No exemplo acima, definimos uma classe chamada MyFrame que herda da classe wx.Frame. Dentro dessa classe, definimos um método chamado start_animation que faz algo antes do atraso usando time.sleep(2) e faz algo após o atraso. Em seguida, criamos um aplicativo wxPython, uma instância da classe MyFrame e a exibimos para o usuário.

Ao clicar no botão na janela wxPython, o atraso de 2 segundos é adicionado antes que o código continue executando, permitindo que você adicione atrasos de tempo em sua interface gráfica.

Conclusão

Você aprendeu várias maneiras de adicionar atrasos de tempo ao seu código em Python usando a função sleep() do módulo time, decoradores, threads, Async IO e bibliotecas de interface gráfica. Agora você pode usar essas técnicas em seus programas Python para criar atrasos estratégicos, controlar o fluxo de execução e adicionar efeitos visuais interessantes. Experimente essas técnicas e veja como elas podem melhorar seus programas!