Como utilizar a função de tempo do Python?

Funções de Temporização em Python: Três Maneiras de Monitorar Seu Código

by Geir Arne Hjelle (intermediário)

Enquanto muitos desenvolvedores reconhecem o Python como uma linguagem de programação eficaz, programas Python puros podem ser executados mais lentamente do que seus equivalentes em linguagens compiladas como C, Rust e Java. Neste tutorial, você aprenderá a usar um temporizador em Python para monitorar a velocidade de execução dos seus programas.

Neste tutorial, você aprenderá como usar:

• time.perf_counter() para medir o tempo em Python
• Classes para manter o estado
• Context managers para trabalhar com um bloco de código
• Decorators para personalizar uma função

Você também ganhará conhecimentos sobre como as classes, os context managers e os decorators funcionam. Conforme você explora exemplos de cada conceito, você será inspirado a usar um ou vários deles no seu código, para temporizar a execução do código, bem como em outras aplicações. Cada método tem suas vantagens e você aprenderá a usá-los dependendo da situação. Além disso, você terá um temporizador Python funcional que poderá usar para monitorar seus programas!

Python Timers

Primeiro, vamos dar uma olhada em um código exemplo que usaremos ao longo do tutorial. Mais tarde, adicionaremos um temporizador em Python a esse código para monitorar seu desempenho. Você também aprenderá algumas das maneiras mais simples de medir o tempo de execução desse exemplo.

Funções de Temporização em Python

Se você verificar o módulo time embutido no Python, notará várias funções que podem medir o tempo:

• monotonic()
• perf_counter()
• process_time()
• time()

O Python 3.7 introduziu diversas novas funções, como thread_time(), bem como versões em nanossegundos de todas as funções acima, com o sufixo _ns. Por exemplo, perf_counter_ns() é a versão em nanossegundos do perf_counter().

Vamos criar um exemplo simples em que faremos o download de vários tutoriais usando um temporizador em Python para medir o tempo de execução do código. Isso nos dará uma noção de como as diferentes funções de temporização se comparam.

Exemplo: Fazendo o Download de Tutoriais

Vamos considerar que temos uma lista de URLs de tutoriais e queremos fazer o download de cada um deles. Usaremos a biblioteca requests para isso. Primeiro, importe a biblioteca:

import requests

Agora, vamos criar uma função chamada download_tutorial() que recebe uma URL como parâmetro e faz o download do conteúdo da página usando a função get() da biblioteca requests:

def download_tutorial(url):
    response = requests.get(url)
    return response.content

Em seguida, precisamos definir a lista de URLs dos tutoriais:

urls = [
    "https:https://codemdd.io/tutorial1.com",
    "https:https://codemdd.io/tutorial2.com",
    "https:https://codemdd.io/tutorial3.com",
    # adicione mais URLs se desejar
]

Agora, vamos fazer o download de cada tutorial da lista e imprimir o conteúdo na tela:

for url in urls:
    content = download_tutorial(url)
    print(content)

Agora que temos o código para fazer o download dos tutoriais, vamos adicionar um temporizador em Python para medir o tempo de execução do código.

Seu Primeiro Temporizador em Python

Vamos começar utilizando a função perf_counter() do módulo time. Essa função retorna a quantidade de segundos como um ponto flutuante, que representa a hora atual do relógio do sistema com a maior precisão disponível.

Importe o módulo time:

import time

Em seguida, vamos adicionar chamadas à função perf_counter() antes e depois do bloco de código que faz o download dos tutoriais. Assim, poderemos calcular a diferença entre esses dois tempos e obter o tempo de execução:

start_time = time.perf_counter()

for url in urls:
    content = download_tutorial(url)
    print(content)

end_time = time.perf_counter()

execution_time = end_time - start_time
print(f"Tempo de execução: {execution_time:.2f} segundos")

Agora, ao executar o código, você verá o tempo de execução do bloco de código que faz o download dos tutoriais.

Vamos explorar outras maneiras de implementar temporizadores em Python nos próximos tópicos.

Uma Classe de Temporizador em Python

Agora que você já tentou usar a função perf_counter() para temporizar o código, vamos dar um passo adiante e criar uma classe de temporizador em Python. Isso nos permitirá reutilizar o código de temporização em diferentes partes do nosso programa.

Entendendo Classes em Python

Antes de prosseguirmos, vamos entender rapidamente como as classes funcionam em Python.

Uma classe é uma estrutura de dados que define os atributos e comportamentos de um objeto. Ela é como um plano ou esquema a partir do qual os objetos podem ser criados.

class MyClass:
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

    def my_method(self):
        # faz alguma coisa

Nesse exemplo, definimos uma classe chamada MyClass que tem dois atributos (attribute1 e attribute2) e um método (my_method). A função __init__() é um método especial chamado de construtor, que é chamado automaticamente quando um objeto da classe é criado.

Criando uma Classe de Temporizador em Python

Agora que entendemos o básico das classes em Python, podemos criar nossa própria classe de temporizador.

Vamos criar uma classe chamada Timer que inicializa um temporizador quando é instanciada, registra o tempo de início quando o temporizador é iniciado e o tempo de término quando é parado.

import time

class Timer:
    def __init__(self):
        self.start_time = 0
        self.end_time = 0

    def start(self):
        self.start_time = time.perf_counter()

    def stop(self):
        self.end_time = time.perf_counter()

    def elapsed_time(self):
        return self.end_time - self.start_time

Nesse exemplo, importamos o módulo time e criamos uma classe chamada Timer com três métodos: __init__(), start() e stop().

O método __init__() é chamado automaticamente quando um objeto da classe é criado e define as variáveis start_time e end_time como 0. Essas variáveis são usadas para registrar o tempo de início e término, respectivamente.

O método start() atribui o valor retornado pela função perf_counter() à variável start_time quando o temporizador é iniciado.

O método stop() atribui o valor retornado pela função perf_counter() à variável end_time quando o temporizador é parado.

O método elapsed_time() retorna a diferença entre end_time e start_time, ou seja, retorna o tempo decorrido desde que o temporizador foi iniciado até que ele foi parado.

Usando a Classe de Temporizador em Python

Vamos agora utilizar nossa classe de temporizador para medir o tempo de execução do bloco de código que faz o download dos tutoriais.

Primeiro, crie uma instância da classe Timer:

timer = Timer()

Em seguida, chame o método start() antes do início do bloco de código que faz o download dos tutoriais:

timer.start()

for url in urls:
    content = download_tutorial(url)
    print(content)

Depois, chame o método stop() depois que o bloco de código terminar:

timer.stop()

Finalmente, chame o método elapsed_time() para obter o tempo de execução:

execution_time = timer.elapsed_time()
print(f"Tempo de execução: {execution_time:.2f} segundos")

Agora, ao executar o código, você verá o tempo de execução usando a classe Timer.

Continuaremos explorando outras maneiras de implementar temporizadores em Python nos próximos tópicos.