Este guia prático demonstrará como empregar a função sleep(), integrante do módulo de tempo nativo do Python, para incorporar pausas temporais na execução do seu código.
Em geral, ao executar um programa Python, as instruções são processadas de forma sequencial – uma após a outra – sem interrupções. Contudo, em certas situações, pode ser preciso retardar a execução. A função sleep(), do módulo time do Python, oferece essa capacidade.
Ao longo deste tutorial, você explorará a sintaxe para usar a função sleep() em Python, complementada por exemplos ilustrativos que esclarecem seu funcionamento. Vamos começar!
Sintaxe de time.sleep() em Python
O módulo time, parte da biblioteca padrão do Python, disponibiliza várias funções úteis relacionadas ao tempo. O primeiro passo é importar o módulo time para o seu ambiente:
import timeComo a função sleep() reside dentro do módulo time, agora você pode acessá-la utilizando a seguinte sintaxe geral:
time.sleep(n)Nesse contexto, n representa o número de segundos que o programa deve “dormir”. Pode ser um número inteiro ou um número de ponto flutuante.
Por vezes, o atraso necessário pode ser de poucos milissegundos. Nesses casos, converta a duração de milissegundos para segundos e use na chamada da função sleep. Por exemplo, para uma pausa de 100 milissegundos, especifique 0.1 segundo: time.sleep(0.1).
▶ Uma alternativa é importar diretamente a função sleep do módulo time:
from time import sleepUtilizando este método, você pode invocar a função sleep() de forma direta, sem precisar usar time.sleep().
Agora que você está familiarizado com a sintaxe da função sleep() do Python, vamos analisar alguns exemplos práticos para ver essa função em ação. Você pode obter os scripts Python utilizados neste tutorial no diretório python-sleep deste repositório no GitHub. 👩🏽💻
Atrasando a Execução de Código com sleep()
Para começar, vamos utilizar a função sleep para introduzir uma pausa na execução de um programa Python simples.
No trecho de código a seguir:
- A primeira instrução
print()é executada sem demora. - Em seguida, introduzimos um atraso de 5 segundos através da função
sleep(). - A segunda instrução
print()será executada somente após a conclusão da pausa.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Agora, execute o arquivo simple_example.py e observe o resultado:
$ python3 simple_example.pyInserindo Atrasos Variados em um Bloco de Código
No exemplo anterior, adicionamos um atraso fixo de 5 segundos entre duas instruções print(). A seguir, exploraremos um exemplo para inserir diferentes tempos de pausa durante a iteração de um objeto iterável.
Neste exemplo, desejamos realizar o seguinte:
- Percorrer uma frase, acessar cada palavra e imprimi-la.
- Após imprimir cada palavra, pausar por um período específico, antes de imprimir a próxima palavra da frase.
Percorrendo uma Cadeia de Caracteres
Considere a string frase. É uma sequência onde cada palavra é também uma string.
Se iterarmos diretamente sobre a string, obteremos cada caractere, como demonstrado:
>>> sentence = "How long will this take?"
>>> for char in sentence:
... print(char)
# Resultado (truncado para melhor visualização)
H
o
w
.
.
.
t
a
k
e
?
Mas não é isso que buscamos. Queremos iterar sobre a frase, acessando cada palavra. Para isso, podemos utilizar o método split() na string da frase. Isso retornará uma lista de strings, geradas pela divisão da frase em todos os espaços em branco.
>>> sentence.split()
['How', 'long', 'will', 'this', 'take?']
>>> for word in sentence.split():
... print(word)
# Resultado
How
long
will
this
take?
Iterando sobre Iteráveis com Diferentes Pausas
Vamos retomar o exemplo:
fraseé a string que queremos percorrer para acessar cada palavra.tempo_de_esperaé a lista de tempos de pausa que usaremos como argumento para a funçãosleep()em cada iteração do loop.
Aqui, desejamos percorrer simultaneamente duas listas: a lista tempo_de_espera e a lista de strings resultante da divisão da string frase. A função zip() permite realizar essa iteração paralela.
A função zip() do Python: zip(lista1, lista2) retorna um iterador de tuplas, onde cada tupla contém o item no índice i de lista1 e lista2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)
Sem a função sleep, o controle seguiria imediatamente para a próxima iteração. Ao introduzir uma pausa, a próxima iteração do loop acontece somente após a conclusão da operação de pausa.
Agora, execute delay_times.py e observe a saída:
$ python3 delay_times.pyAs palavras subsequentes na string são impressas após um atraso. O atraso após a impressão da palavra no índice i na string corresponde ao valor no índice i da lista tempo_de_espera.
Temporizador de Contagem Regressiva em Python
Como próximo exemplo, vamos criar um temporizador de contagem regressiva simples em Python.
Definiremos uma função contagemRegressiva():
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)
A seguir, vamos analisar a definição da função contagemRegressiva():
- A função recebe um número
ncomo argumento e realiza a contagem regressiva até zero a partir desse númeron. - Utilizamos
time.sleep(1)para inserir uma pausa de um segundo entre as contagens. - Quando a contagem chega a 0, a função exibe “Ready to go!”.
🎯 Para realizar a contagem regressiva, utilizamos a função range() com um valor de passo negativo de -1. range(n, -1, -1) nos ajudará a percorrer o intervalo de números em n, n - 1, n - 2, e assim por diante, até zero. Lembre-se que o ponto final é excluído por padrão ao usar a função range().
A seguir, vamos adicionar uma chamada à função contagemRegressiva() com 5 como argumento.
countDown(5)
Agora, execute o script countdown.py e veja a função contagemRegressiva em ação!
$ python3 countdown.py
A Função sleep em Multithreading
O módulo threading do Python oferece recursos de multithreading de fácil utilização. No Python, o Global Interpreter Lock, ou GIL, garante que apenas um thread esteja ativo e em execução em um dado momento.
No entanto, durante operações de I/O e operações de espera, como a suspensão via sleep, o processador pode suspender a execução do thread atual e alternar para outro thread que esteja em espera.
Para entender melhor esse funcionamento, vamos analisar um exemplo.
Criando e Executando Threads em Python
Considere as funções func1(), func2() e func3(). Elas percorrem uma sequência de números e os imprimem. Após isso, há uma operação de suspensão – por um tempo específico em segundos – em cada iteração do loop. Utilizamos tempos de atraso diferentes para cada uma das funções para ilustrar como a execução alterna entre os threads simultaneamente.
import time
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
Em Python, você pode usar o construtor Thread() para criar um objeto thread. Usando a sintaxe threading.Thread(target = …, args = …), um thread é criado para executar a função de destino com os argumentos especificados na tupla args.
Neste exemplo, as funções func1, func2 e func3 não requerem nenhum argumento. Portanto, basta especificar o nome da função como destino. Em seguida, definimos os objetos de thread t1, t2 e t3, com func1, func2 e func3 como destinos, respectivamente.
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Aqui está o código completo para o exemplo de threading:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Observe o resultado. A execução alterna entre os três threads. O thread t3 tem o menor tempo de pausa, então fica suspenso por menos tempo. O thread t1 tem a maior duração de suspensão, dois segundos, sendo o último thread a concluir a execução.
Para mais informações, consulte o tutorial sobre os fundamentos de multithreading em Python.
Conclusão
Neste tutorial, você aprendeu como usar a função sleep() do Python para adicionar atrasos temporais ao seu código.
A função sleep() pode ser acessada através do módulo embutido time, usando time.sleep(). Para pausar a execução por n segundos, utilize time.sleep(n). Além disso, você viu exemplos de como retardar iterações subsequentes em um loop por diferentes valores, criar uma contagem regressiva e também usar com multithreading.
Agora você pode explorar os recursos avançados do módulo time. Quer trabalhar com datas e horas em Python? Além do módulo time, você pode aproveitar a funcionalidade dos módulos datetime e calendar.
Em seguida, aprenda como calcular a diferença de tempo em Python.⏰