【Python time】Tutorial: De Pausas com sleep() a Medições Precisas com perf_counter()

Para executar Python no prompt de comando ou PowerShell no seu PC, é necessário baixar e instalar o Python.
Se ainda não o fez, consulte o artigo Instalação do Python e configuração do ambiente de desenvolvimento para instalar o Python.

Olá! Sou um especialista que aprendeu a programar com IA e lancei dois sites em um mês e meio. Apenas alguns meses atrás, eu era um completo iniciante com zero conhecimento de programação, assim como muitos de vocês.

Enquanto você aprende Python, você costuma ver `import time` em código gerado por IA ou em exemplos de outras pessoas? Você pode estar pensando: "Lá vem o `time` de novo, mas o que ele realmente faz?" ou "É só para parar e medir o tempo?".

Neste artigo, vou detalhar o módulo `time` de uma forma que seja fácil para iniciantes entenderem, compartilhando minhas próprias experiências e dificuldades. Vamos focar especificamente em como "pausar um processo (sleep)" e "medir com precisão o tempo que um processo leva", que são habilidades essenciais para cenários práticos como desenvolvimento de sites e coleta de dados. Ao terminar este artigo, você será capaz de usar o módulo `time` livremente!

1. Por que precisamos manipular o tempo? - A importância de esperar

Você acha que quanto mais rápido um programa é executado, melhor? Na realidade, há momentos em que "esperar intencionalmente" é extremamente importante. Deixe-me apresentar dois casos específicos que encontrei ao desenvolver meus sites.

Caso 1: Coleta de informações de sites (Web Scraping)

Quando você tenta coletar informações de um site automaticamente, um programa acessa as páginas a uma velocidade inimaginável para um ser humano. Isso pode fazer com que um número massivo de solicitações atinja o servidor em um curto período, criando uma carga pesada. É como uma multidão invadindo uma loja e atrapalhando os negócios. No pior dos casos, seu acesso pode ser bloqueado.

É aí que a técnica de "esperar" se torna útil. Ao adicionar um processo que espera alguns segundos após acessar uma página, você pode reduzir significativamente a carga do servidor e realizar a coleta de informações de maneira educada.

Caso 2: Uso de APIs

A gestão do tempo também é essencial ao usar serviços externos (APIs) que fornecem informações sobre o tempo ou mapas. Muitas APIs têm limites de uso, como "até 60 vezes por minuto" (limites de taxa ou rate limits). Se você enviar solicitações que excedam esse limite, o serviço pode se tornar temporariamente indisponível ou você pode receber erros.

Aqui também, ao "esperar" por um certo período após cada solicitação, você pode permanecer dentro dos limites de uso.

Esse processo de criar um "tempo de espera" intencional em um programa é chamado de processo de sleep. E a maneira mais fácil de conseguir isso em Python é com a função `time.sleep()`.

2. Pausando perfeitamente! Interrompendo a execução com `time.sleep()`

`time.sleep()` é uma função muito simples que interrompe temporariamente a execução do programa por um número especificado de segundos. Vamos começar com seu uso básico.

O código a seguir é um exemplo simples que exibe "Iniciando o processo." e, após 3 segundos, exibe "3 segundos se passaram. Finalizando o processo.". Copie e cole no seu ambiente para ter uma ideia de "esperar".

# Importar o módulo time
import time

print("Iniciando o processo.")

# Pausar o processo por 3 segundos
time.sleep(3)

print("3 segundos se passaram. Finalizando o processo.")
        

Você também pode especificar decimais para o argumento, como 0.5 (0.5 segundos) ou 0.1 (100 milissegundos). Isso permite um controle de tempo mais preciso.

import time

print("Esperando por apenas 0.5 segundos.")

# Pausar o processo por 0.5 segundos
time.sleep(0.5)

print("Pronto!")
        

Combinando-o com um loop, você pode criar facilmente um programa que executa algo periodicamente. Por exemplo, aqui está um programa que faz uma contagem regressiva a cada segundo.

import time

print("Início da contagem regressiva!")

for i in range(5, 0, -1):
    print(i)
    # Esperar por 1 segundo
    time.sleep(1)

print("Lançar!")
        

3. Função de Cronômetro! Como Medir o Tempo de Processamento com Precisão

Outro papel importante do módulo `time` é a medição do tempo de processamento. Entender quais partes do seu código estão demorando mais é o primeiro passo para a melhoria do desempenho.

Quando você sente que "este processo parece lento...", é importante medir o tempo e identificar o gargalo, em vez de confiar na intuição.

A Abordagem do Iniciante: `time.time()`

A maneira mais básica de medir o tempo é chamar `time.time()` antes e depois de um processo e calcular a diferença. `time.time()` retorna o número de segundos que se passaram desde um tempo de referência chamado "Época Unix" (1 de janeiro de 1970, 00:00:00).

import time

# Registrar o tempo antes do início do processo
start_time = time.time()

# Escreva o código que você quer medir aqui
# Como exemplo, vamos colocar uma pausa de 1 segundo
print("Executando o processo a ser medido...")
time.sleep(1)
print("Processo concluído.")

# Registrar o tempo após o término do processo
end_time = time.time()

# Calcular e exibir o tempo decorrido
elapsed_time = end_time - start_time
print(f"Tempo gasto no processo: {elapsed_time} segundos")
        

【Minha História de Fracasso】 A Armadilha do `time.time()`

Na verdade, embora `time.time()` seja conveniente, ele tem uma grande armadilha. Ou seja, ele é afetado por alterações no relógio do sistema do PC.

Quando eu estava começando, usei `time.time()` para medir um processo de longa duração. No entanto, no meio do processo, meu PC sincronizou automaticamente seu relógio (sincronização NTP), o que resultou em uma medição completamente errada, diferente do tempo de processamento real. Por exemplo, se o relógio do sistema for atrasado em 1 segundo durante o processo, o tempo decorrido calculado será 1 segundo menor. Você não consegue uma medição precisa dessa forma, certo?

É aí que entra um método de medição de tempo mais confiável.

A Escolha do Profissional: `time.perf_counter()`

`time.perf_counter()` (abreviação de contador de performance) é uma função especializada em medir durações curtas, exatamente como medir o tempo de processamento. O valor que ele retorna não é uma "hora do dia" específica, mas sim um tempo monotonicamente crescente com a mais alta resolução disponível fornecida pelo sistema operacional.

"Monotonicamente crescente" é o ponto-chave aqui. Significa que mesmo que o relógio do sistema seja alterado, o valor do contador nunca retrocederá. Portanto, mesmo que ocorra uma sincronização do relógio durante o seu processo, isso não afetará o resultado da medição.

Até mesmo na documentação oficial do Python, o uso de `perf_counter()` é recomendado para medir o tempo de processamento.

O uso é exatamente o mesmo que `time.time()`.

import time

# Registrar o valor do contador antes do início do processo
start_counter = time.perf_counter()

# Escreva o código que você quer medir aqui
print("Executando o processo a ser medido...")
total = 0
for i in range(10000000): # Exemplo de um processo demorado
    total += i
print("Processo concluído.")

# Registrar o valor do contador após o término do processo
end_counter = time.perf_counter()

# Calcular e exibir o tempo decorrido
elapsed_time = end_counter - start_counter
print(f"Tempo gasto no processo: {elapsed_time} segundos")
        

A menos que você tenha um motivo específico para não fazer isso, não há como errar ao lembrar de usar `time.perf_counter()` para medir o tempo de processamento!

4. 【Avançado】 Para Criadores Web! Um Cronômetro HTML Totalmente Funcional

Até agora, aprendemos sobre o módulo `time` do Python. Eles são muito úteis para programas que rodam no lado do servidor (o backend). No entanto, como um criador web, você quer apresentar os resultados de uma forma que os usuários possam ver, ou seja, em uma página da web, certo?

Então, vamos aplicar os conceitos do módulo `time` do Python para criar um cronômetro de contagem regressiva simples que roda no navegador usando HTML e JavaScript. Assim como o `time.sleep(1)` do Python era um comando para "esperar por 1 segundo", em JavaScript, você pode usar o comando `setInterval()` para "fazer algo a cada segundo".

O código a seguir é um arquivo HTML completo. Copie este código, salve-o com um nome como `timer.html` e abra-o no seu navegador. Ao pressionar o botão, você deve ver o número na tela diminuir a cada segundo. Este é o primeiro passo para permitir que os usuários experimentem algo "que funciona"!

<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Cronômetro de Contagem Regressiva</title>
    <style>
        body {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #121212;
            color: #e0e0e0;
            font-family: sans-serif;
            text-align: center;
        }
        #timer-display {
            font-size: 8rem;
            font-weight: bold;
            color: #669df6;
        }
        button {
            margin-top: 2rem;
            padding: 1rem 2rem;
            font-size: 1.5rem;
            cursor: pointer;
            border: 1px solid #5f6368;
            background-color: transparent;
            color: #8ab4f8;
            border-radius: 5px;
        }
        button:disabled {
            cursor: not-allowed;
            opacity: 0.5;
        }
    </style>
</head>
<body>
    <div>
        <h1>Contagem Regressiva com JavaScript</h1>
        <div id="timer-display">10</div>
        <button id="start-btn">Iniciar</button>
        <p>Aplicando o conceito do time.sleep() do Python!</p>
    </div>

    <script>
        // A tag script é escrita aqui
        const timerDisplay = document.getElementById('timer-display');
        const startButton = document.getElementById('start-btn');
        let timeLeft = 10;
        let timerId = null;

        function startTimer() {
            // Desabilitar o botão para evitar cliques duplos
            startButton.disabled = true;

            // Executar o processo a cada 1 segundo (1000 milissegundos)
            timerId = setInterval(() => {
                timeLeft--;
                timerDisplay.textContent = timeLeft;

                if (timeLeft <= 0) {
                    clearInterval(timerId); // Parar o cronômetro
                    timerDisplay.textContent = "Vai!";
                }
            }, 1000);
        }

        // Iniciar o cronômetro quando o botão de início for clicado
        startButton.addEventListener('click', startTimer);
    </script>
</body>
</html>
        

5. Resumo dos Pontos a Observar ao Usar o Módulo `time`

Finalmente, vamos revisar os pontos importantes a serem lembrados ao trabalhar com o módulo `time`.

• Use `time.sleep()` para dormir: Use-o quando quiser pausar intencionalmente um processo, como uma cortesia na raspagem da web ou ao usar APIs.
• Use `time.perf_counter()` para medição de tempo: Use-o quando quiser medir com precisão o desempenho de um processo. É mais confiável do que `time.time()` porque não é afetado por alterações no relógio do sistema.
• A precisão de `sleep()` não é perfeita: Mesmo com `time.sleep(1)`, dependendo do status de outros processos do sistema operacional, o tempo de espera real pode ser de 1.002 segundos ou 1.01 segundos em vez de exatamente 1.000 segundos. Lembre-se de que não é adequado para controle de altíssima precisão.

Conclusão

Neste artigo, aprendemos a "pausar" e "medir" processos usando o módulo `time` do Python. Pode parecer um módulo modesto à primeira vista, mas é uma ferramenta indispensável e muito poderosa para criar programas práticos.

Especificamente, `time.sleep()` é uma função importante para mostrar consideração pelos outros (servidores), enquanto `time.perf_counter()` é para mostrar consideração por si mesmo (melhorando o desempenho do código).

Tente incorporar o conceito de "tempo" em seus programas usando o que você aprendeu hoje. Tenho certeza de que isso ampliará muito o leque de coisas que você pode criar.