Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como Usar a Função Pause do Python?

[

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

por Mike Driscoll

Introdução

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

Neste tutorial, você aprenderá como adicionar chamadas de 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 isso se parece com você, então vamos começar!

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

O Python tem suporte integrado para colocar seu programa para “dormir”. O módulo time possui uma função sleep() que você pode usar para suspender a execução da thread chamadora pelo tempo que você especificar em segundos.

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

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

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

Observe que, no Python 3.5, os desenvolvedores alteraram levemente o comportamento do time.sleep(). A chamada de sleep() do Python agora durará pelo menos o número de segundos especificado, mesmo se o sono for interrompido por um sinal. Isso não se aplica se o sinal em si levantar uma exceção, no entanto.

Você pode testar por quanto tempo o sono dura usando o módulo timeit do Python:

Terminal window
$ 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 indica ao timeit quantas vezes executar a declaração que segue. Você pode ver que o timeit executou a declaração 3 vezes e que o tempo de execução mais rápido foi de 3 segundos, o que era esperado.

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

Vamos criar algo um pouco mais realista. Um administrador de sistema precisa saber quando um de seus sites está fora do ar. Você quer poder verificar regularmente o código de status do site, mas você não quer sobrecarregar o servidor enviando várias solicitações em um curto período de tempo. Adicionar uma chamada de sleep() entre as solicitações garantirá que você esteja respeitando as limitações de recursos do servidor.

import time
import requests


def check_website(url):
    while True:
        response = requests.get(url)


        if response.status_code != 200:
            print(f"O site {url} está offline!")


        time.sleep(60)  # Espera por 1 minuto antes de fazer outra verificação


check_website("https://www.example.com")

Neste exemplo, a função check_website() faz uma solicitação para o site especificado e verifica o código de status da resposta. Se o código não for 200 (indicando uma resposta bem-sucedida), uma mensagem será exibida indicando que o site está offline. Em seguida, o programa espera por 1 minuto antes de fazer a próxima verificação. Repetindo esse processo, você pode criar um script de monitoramento básico que é sensível às limitações do servidor.

Adicionando uma chamada sleep() em Python com decoradores

Decoradores são uma maneira elegante de modificar ou estender o comportamento das funções existentes em Python. Você pode usar um decorator para adicionar uma chamada de sleep() a uma função. Aqui está um exemplo:

import time


def sleep_decorator(function):
    def wrapper(*args, **kwargs):
        time.sleep(2)
        return function(*args, **kwargs)
    return wrapper


@sleep_decorator
def greet(name):
    print(f"Olá, {name}!")


greet("João")

Neste exemplo, o decorator sleep_decorator adiciona um atraso de 2 segundos antes de chamar a função decorada greet. Quando você chama a função greet("João"), você verá uma pausa de 2 segundos antes do programa exibir “Olá, João!” no console.

Decoradores podem ajudar a encapsular comportamentos repetitivos e tornar seu código mais legível. Eles podem ser particularmente úteis quando você deseja adicionar comportamentos a várias funções sem precisar duplicar código.

Adicionando uma chamada sleep() em Python com Threads

Threads são uma forma de concorrência em Python. Você pode criar várias threads de execução dentro de um programa para executar tarefas diferentes simultaneamente. Ao adicionar uma chamada de sleep() a uma thread, você pode controlar o atraso entre as ações realizadas por cada thread. Aqui está um exemplo básico:

import time
import threading


def thread_function(name):
    print(f"{name} started")
    time.sleep(2)
    print(f"{name} ended")


threads = []
for i in range(3):
    t = threading.Thread(target=thread_function, args=(f"Thread {i}",))
    threads.append(t)
    t.start()


# Espera todas as threads terminarem
for t in threads:
    t.join()


print("Todas as threads terminaram")

Neste exemplo, criamos três threads usando um loop for. Cada thread chama a função thread_function, que exibe uma mensagem indicando o início da thread, em seguida, pausa por 2 segundos e finalmente exibe uma mensagem indicando o término da thread. O programa espera que todas as threads terminem usando o método join() de cada objeto de Thread.

Note que a ordem de execução das threads não é garantida em Python. Isso significa que elas podem terminar em qualquer ordem e a ordem das mensagens de saída pode variar cada vez que você executa o programa.

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ê realize operações de I/O de forma eficiente. Você pode adicionar uma chamada de sleep() em um programa Async IO para pausar a execução de uma tarefa e permitir que outras tarefas avancem. Aqui está um exemplo:

import asyncio


async def my_task():
    print("Iniciando tarefa")
    await asyncio.sleep(3)
    print("Tarefa concluída")


async def main():
    await asyncio.gather(my_task(), my_task(), my_task())


asyncio.run(main())

Neste exemplo, temos a função my_task(), que é uma tarefa assíncrona. Dentro dessa tarefa, chamamos asyncio.sleep(3) para pausar a execução por 3 segundos. Em seguida, temos a função main(), que usa asyncio.gather() para criar e agendar três instâncias da tarefa my_task(). Finalmente, chamamos asyncio.run() com a função main() para executar o programa Async IO.

Observe que o Async IO requer a versão 3.7 ou superior do Python. Se você estiver usando uma versão mais antiga, você precisará instalar o pacote asyncio usando o pip.

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

As interfaces gráficas do usuário (GUI) permitem criar aplicativos visualmente atraentes com botões, menus e outros elementos interativos. Você pode adicionar chamadas de sleep() ao seu código de GUI para controlar o atraso entre os eventos ou para fornecer uma experiência de usuário mais amigável. Aqui está um exemplo usando a biblioteca Tkinter:

import tkinter as tk
import time


def show_message():
    label.config(text="Nova mensagem")


def reset_message():
    label.config(text="")


root = tk.Tk()
root.geometry("300x200")


label = tk.Label(root, text="")
label.pack()


button = tk.Button(root, text="Mostrar mensagem", command=show_message)
button.pack()


reset_button = tk.Button(root, text="Resetar mensagem", command=reset_message)
reset_button.pack()


root.mainloop()

Neste exemplo, criamos uma janela com duas áreas de botão e um rótulo vazio usando a biblioteca Tkinter. Quando o botão “Mostrar mensagem” é clicado, a função show_message() é chamada, que atualiza o texto do rótulo com uma nova mensagem. Depois que a mensagem é exibida por um tempo, podemos clicar no botão “Resetar mensagem” para limpar o rótulo.

Essa é apenas uma implementação de GUI básica usando Tkinter, mas você pode adicionar chamadas de sleep() a qualquer lugar do código para controlar o tempo de espera entre os eventos.

Conclusão

Neste tutorial, você aprendeu várias maneiras de adicionar chamadas de sleep() ao seu código Python. Você viu como usar time.sleep() para pausar a execução do programa por um determinado número de segundos. Você também aprendeu como adicionar um atraso com decoradores, threads, Async IO e interfaces gráficas do usuário.

As chamadas de sleep() podem ser úteis para controlar o tempo de execução do código, criar atrasos intencionais entre as ações ou gerenciar tarefas assíncronas. Agora que você conhece essas técnicas, pode usá-las em seus próprios projetos Python para torná-los mais eficientes e responsivos. Divirta-se codificando!