Este tutorial ensinará como usar a função sleep() do módulo de tempo interno do Python para adicionar atrasos de tempo ao código.
Quando você executa um programa Python simples, a execução do código ocorre sequencialmente — uma instrução após a outra — sem nenhum atraso. No entanto, pode ser necessário atrasar a execução do código em alguns casos. A função sleep() do módulo de tempo interno do Python ajuda você a fazer isso.
Neste tutorial, você aprenderá a sintaxe do uso da função sleep() em Python e vários exemplos para entender como ela funciona. Vamos começar!
últimas postagens
Sintaxe do Python time.sleep()
O módulo time, construído na biblioteca padrão do Python, fornece várias funções úteis relacionadas ao tempo. Como primeiro passo, importe o módulo de tempo para o seu ambiente de trabalho:
import time
Como a função sleep() faz parte do módulo time, agora você pode acessá-la e usá-la com a seguinte sintaxe geral:
time.sleep(n)
Aqui, n é o número de segundos para dormir. Pode ser um número inteiro ou um número de ponto flutuante.
Às vezes, o atraso necessário pode ser de alguns milissegundos. Nesses casos, você pode converter a duração em milissegundos para segundos e usá-la na chamada da função sleep. Por exemplo, se você deseja introduzir um atraso de 100 milissegundos, pode especificá-lo como 0,1 segundo: time.sleep(0,1).
▶ Você também pode importar apenas a função dormir do módulo de tempo:
from time import sleep
Se você usar o método acima para importar, poderá chamar a função sleep() diretamente — sem usar time.sleep().
Agora que você aprendeu a sintaxe da função sleep() do Python, vamos codificar exemplos para ver a função em ação. Você pode baixar os scripts Python usados neste tutorial na pasta python-sleep neste repositório do GitHub. 👩🏽💻
Atrasar a execução do código com sleep ()
Como primeiro exemplo, vamos usar a função sleep para atrasar a 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 usando a função sleep().
- A segunda instrução print() será executada somente após a conclusão da operação de suspensão.
# /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 a saída:
$ python3 simple_example.py
Adicionar atrasos diferentes a um bloco de código
No exemplo anterior, introduzimos um atraso fixo de 5 segundos entre a execução de duas instruções print(). Em seguida, vamos codificar outro exemplo para introduzir diferentes tempos de atraso ao percorrer um iterável.
Neste exemplo, gostaríamos de fazer o seguinte:
- Percorra uma frase, acesse cada palavra e imprima-a.
- Depois de imprimir cada palavra, gostaríamos de esperar por um período de tempo específico – antes de imprimir a próxima palavra da frase.
Percorrendo uma sequência de sequências
Considere a string, frase. É uma string onde cada palavra é uma string em si.
Se fizermos um loop pela string, obteremos cada caractere, conforme mostrado:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Mas não é isso que queremos. Gostaríamos de percorrer a frase e acessar cada palavra. Para fazer isso, podemos chamar o método split() na string da frase. Isso retornará uma lista de strings—obtidas pela divisão da string da sentença—em todas as ocorrências de espaço em branco.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Percorrendo iteráveis com atrasos diferentes
Vamos revisitar o exemplo:
- sentença é a string que gostaríamos de percorrer para acessar cada palavra.
- delay_times é a lista de tempos de atraso que usaremos como argumento para a função sleep() durante cada passagem pelo loop.
Aqui, gostaríamos de percorrer simultaneamente duas listas: a lista delay_times e a lista de strings obtidas pela divisão da string de sentença. Você pode usar a função zip() para executar essa iteração paralela.
A função zip() do Python: zip(list1, list2) retorna um iterador de tuplas, onde cada tupla contém o item no índice i em list1 e list2.
# /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 prosseguiria imediatamente para a próxima iteração. Como introduzimos um atraso, a próxima passagem pelo loop ocorre somente após a conclusão da operação de hibernação.
Agora execute delay_times.py e observe a saída:
$ python3 delay_times.py
As palavras subsequentes na string serão impressas após um atraso. O atraso após imprimir a palavra no índice i na string é o número no índice i na lista delay_times.
Temporizador de contagem regressiva em Python
Como próximo exemplo, vamos codificar um cronômetro de contagem regressiva simples em Python.
Vamos definir uma função countDown():
# /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)
Em seguida, vamos analisar a definição da função countDown():
- A função recebe um número n como argumento e faz a contagem regressiva até zero a partir desse número n.
- Usamos time.sleep(1) para obter um atraso de um segundo entre as contagens.
- Quando a contagem chega a 0, a função imprime “Ready to go!”.
🎯 Para realizar a operação de contagem regressiva, usamos 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 de que o ponto final é excluído por padrão ao usar a função range().
Em seguida, vamos adicionar uma chamada à função countDown() com 5 como argumento.
countDown(5)
Agora execute o script countdown.py e veja a função countDown em ação!
$ python3 countdown.py
Função de suspensão em multithreading
O módulo de threading do Python oferece recursos de multithreading prontos para uso. Em Python, o Global Interpreter Lock ou GIL garante que haja apenas um thread ativo em execução a qualquer momento.
No entanto, durante operações de E/S e operações de espera, como suspensão, o processador pode suspender a execução do thread atual e alternar para outro thread que está aguardando.
Para entender como isso funciona, vamos dar um exemplo.
Criando e executando threads em Python
Considere as seguintes funções, func1(), func2() e func3(). Eles percorrem uma série de números e os imprimem. Isso é seguido por uma operação de hibernação – por um número específico de segundos – durante cada passagem pelo loop. Usamos tempos de atraso diferentes para cada uma das funções para entender melhor como a execução alterna entre 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 instanciar um objeto thread. Usando a sintaxe threading.Thread(target = …, args = …) cria um thread que executa a função de destino com o argumento especificado na tupla args.
Neste exemplo, as funções func1, func2 e func3 não aceitam nenhum argumento. Portanto, basta especificar apenas o nome da função como destino. Em seguida, definimos objetos de encadeamento, t1, t2 e t3 com func1, func2 e func3 como alvos, 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 a saída. A execução é alterada entre os três threads. A thread t3 tem o menor tempo de espera, então fica suspensa por menos tempo. O thread t1 tem a maior duração de suspensão de dois segundos, portanto, é o último thread a concluir a execução.
Para saber mais, leia o tutorial sobre os fundamentos do multithreading em Python.
Conclusão
Neste tutorial, você aprendeu a usar a função sleep() do Python para adicionar atrasos de tempo ao código.
Você pode acessar a função sleep() a partir do módulo de tempo embutido, time.sleep(). Para atrasar a execução em n segundos, use time.sleep(n). Além disso, você viu exemplos de atraso de iterações subsequentes em um loop por diferentes valores, contagem regressiva e multithreading.
Agora você pode explorar recursos mais avançados do módulo de tempo. Quer trabalhar com datas e horas em Python? Além do módulo de hora, você pode aproveitar a funcionalidade dos módulos de data e hora e calendário.
Em seguida, aprenda a calcular a diferença de tempo em Python.⏰