Função de suspensão do Python: como adicionar atrasos ao código

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!

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 time 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 sleep do módulo time :

 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, sentence . É 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 sentence . Isso retornará uma lista de strings—obtidas pela divisão da string da sentence —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:

• sentence é 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 sentence . 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 target 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.