Descubra como medir o tempo de código com timeit

Se você já se perguntou por que um trecho de código demora mais que outro ou se uma alteração realmente melhorou o desempenho, você precisa aprender como medir o tempo de código com timeit. No mundo da programação, a eficiência não é apenas um luxo, mas uma necessidade. Pequenas variações na forma como escrevemos um loop ou processamos uma lista podem resultar em diferenças drásticas de velocidade, especialmente em grandes conjuntos de dados. O Python oferece uma ferramenta nativa e extremamente precisa para essa tarefa: o módulo timeit. Diferente de cronometragens manuais simples, essa biblioteca foi projetada para evitar distorções causadas por processos em segundo plano no sistema operacional, garantindo resultados confiáveis para micro-otimizações.

Por que medir o tempo de execução é essencial?

Muitos desenvolvedores iniciantes confiam apenas na intuição para decidir qual função é mais rápida. No entanto, a intuição muitas vezes falha quando lidamos com a complexidade da memória e do processador. Entender a performance do seu algoritmo na programação permite que você identifique gargalos antes que eles se tornem problemas reais em produção. Quando o sistema começa a escalar, um código ineficiente pode gerar custos de servidor mais altos ou uma experiência de usuário sofrível.

Além disso, o processo de medição ajuda a entender melhor o comportamento das estruturas de dados. Comparar o tempo de busca em uma lista versus um dicionário, por exemplo, é uma lição prática valiosa. Ao utilizar ferramentas profissionais para esse fim, você eleva o nível do seu desenvolvimento, aproximando-se de práticas de engenharia de software de alta performance, como as documentadas na Documentação Oficial do Python.

O que é o módulo timeit?

O timeit é um módulo da biblioteca padrão do Python criado especificamente para medir o tempo de execução de pequenos trechos de código. Ele executa o código milhares (ou milhões) de vezes e calcula a média, minimizando o impacto de flutuações temporárias de uso de CPU. Se você tentar usar apenas o módulo time python com a função time.time(), poderá obter resultados imprecisos devido à resolução do relógio do sistema ou interrupções externas.

A grande vantagem do timeit é que ele desativa temporariamente o coletor de lixo (garbage collector) durante a medição. Isso garante que o tempo gasto limpando a memória não seja contabilizado injustamente contra a lógica do seu código. É a ferramenta padrão ouro para quem deseja realizar benchmarks sérios e precisos.

Como usar o timeit na linha de comando

Uma das formas mais rápidas de testar uma ideia é através do terminal. Você não precisa criar um arquivo script completo para verificar se uma list comprehension é mais rápida que um loop for tradicional. O Python permite invocar o módulo diretamente da interface de comandos.

Veja um exemplo de como testar a criação de uma lista de números quadrados no terminal:

python -m timeit "[x**2 for x in range(100)]"

python -m timeit "[x**2 for x in range(100)]"

Neste comando, o Python fará o seguinte:

• Carregará o módulo timeit.
• Executará o trecho de código entre aspas repetidamente.
• Retornará a média do melhor tempo obtido entre vários loops.

Medindo o tempo de código com timeit dentro de um script

Embora a linha de comando seja útil, na maioria das vezes você precisará integrar a medição dentro do seu fluxo de trabalho no VS Code ou PyCharm. Para isso, usamos a função timeit.timeit(). Essa função aceita o código que deve ser testado como uma string (ou uma função chamável) e o número de repetições.

Vamos comparar duas formas de concatenar strings em Python. A primeira usando o operador + e a segunda usando o método join(), que é geralmente recomendado para melhor performance.

import timeit

# Código 1: Usando concatenação simples
codigo_mais = 's = ""; list = ["item"] * 100; \nfor i in list: s += i'

# Código 2: Usando o método join
codigo_join = 'list = ["item"] * 100; "".join(list)'

tempo_mais = timeit.timeit(stmt=codigo_mais, number=10000)
tempo_join = timeit.timeit(stmt=codigo_join, number=10000)

print(f"Tempo com '+': {tempo_mais:.5f} segundos")
print(f"Tempo com join: {tempo_join:.5f} segundos")

import timeit

# Código 1: Usando concatenação simples
codigo_mais = 's = ""; list = ["item"] * 100; \nfor i in list: s += i'

# Código 2: Usando o método join
codigo_join = 'list = ["item"] * 100; "".join(list)'

tempo_mais = timeit.timeit(stmt=codigo_mais, number=10000)
tempo_join = timeit.timeit(stmt=codigo_join, number=10000)

print(f"Tempo com '+': {tempo_mais:.5f} segundos")
print(f"Tempo com join: {tempo_join:.5f} segundos")

Note que o parâmetro number define quantas vezes o bloco será executado. Se você não definir, o padrão é 1.000.000 de vezes. Para scripts que trabalham com python para automação, entender esses tempos pode economizar horas de processamento em tarefas repetitivas.

Usando o parâmetro setup para preparar o ambiente

Muitas vezes, o código que você quer medir depende de variáveis ou importações que não devem ser contabilizadas no tempo de execução. Para isso, o timeit fornece o argumento setup. O código dentro do setup é executado apenas uma vez antes da medição começar.

Imagine que você queira testar a performance de uma função que utiliza o módulo math do python. Você não quer medir o tempo que o Python leva para importar o módulo, apenas o tempo da operação matemática em si.

import timeit

setup_code = "import math"
test_code = "math.sqrt(144)"

# Executando o teste
resultado = timeit.timeit(stmt=test_code, setup=setup_code, number=1000000)
print(f"Tempo de execução: {resultado} segundos")

import timeit

setup_code = "import math"
test_code = "math.sqrt(144)"

# Executando o teste
resultado = timeit.timeit(stmt=test_code, setup=setup_code, number=1000000)
print(f"Tempo de execução: {resultado} segundos")

Essa separação é crucial para garantir a integridade do seu benchmark. Se você incluísse o import dentro do stmt, estaria medindo algo irrelevante para a lógica do algoritmo principal.

Comparando Funções Diretamente

Passar strings para o timeit pode ser um pouco trabalhoso e propenso a erros de digitação. Uma alternativa mais moderna e legível é passar as referências das funções diretamente. Isso é especialmente útil quando você já tem suas funções definidas no script e quer testá-las rapidamente.

Considere o exemplo abaixo, onde comparamos uma list comprehension no python com a função embutida map():

import timeit

def usar_list_comp():
    return [str(i) for i in range(1000)]

def usar_map():
    return list(map(str, range(1000)))

# Medindo as funções
tempo_list = timeit.timeit(usar_list_comp, number=10000)
tempo_map = timeit.timeit(usar_map, number=10000)

print(f"List Comprehension: {tempo_list}")
print(f"Map Function: {tempo_map}")

import timeit

def usar_list_comp():
    return [str(i) for i in range(1000)]

def usar_map():
    return list(map(str, range(1000)))

# Medindo as funções
tempo_list = timeit.timeit(usar_list_comp, number=10000)
tempo_map = timeit.timeit(usar_map, number=10000)

print(f"List Comprehension: {tempo_list}")
print(f"Map Function: {tempo_map}")

Perceba que, ao passar a função sem os parênteses, você está passando o objeto da função para o timeit, permitindo que ele gerencie as chamadas internas no tempo correto.

Medir o tempo de código com timeit usando Repeat

Às vezes, uma única medição (mesmo que baseada em um milhão de loops) pode ser afetada por um pico súbito de uso de memória no sistema. Para contornar isso, o módulo oferece a função repeat(). Ela executa o timeit várias vezes e retorna uma lista com os resultados de cada rodada.

Isso permite que você aplique análises estatísticas básicas, como extrair o valor mínimo. De acordo com a Wikipedia sobre Code Profiling, o menor tempo registrado é geralmente o mais confiável, pois representa o código rodando com a menor interferência possível do sistema.

import timeit

tempos = timeit.repeat(stmt="sum(range(100))", repeat=5, number=100000)
print(f"Lista de tempos: {tempos}")
print(f"Melhor tempo: {min(tempos)}")

import timeit

tempos = timeit.repeat(stmt="sum(range(100))", repeat=5, number=100000)
print(f"Lista de tempos: {tempos}")
print(f"Melhor tempo: {min(tempos)}")

Neste caso, pedimos ao Python para repetir o ciclo de 100 mil execuções cinco vezes. O resultado será uma lista com cinco valores de ponto flutuante, facilitando a visualização de inconsistências.

Quando evitar o uso do timeit?

Apesar de poderoso, o timeit não é a ferramenta ideal para todos os cenários. Ele foca em micro-benchmarks. Se você precisa analisar um sistema complexo com acesso a banco de dados ou chamadas de rede API, o timeit não será muito útil, pois a maior parte do tempo será gasta esperando por fatores externos (I/O).

Para medir o desempenho de um script inteiro ou identificar qual função dentro de um projeto grande está consumindo mais recursos, o uso de um Profiler (como o cProfile) é mais indicado. O timeit brilha quando você tem duas ou três abordagens diferentes para resolver um problema lógico pequeno e quer saber qual é a vencedora em termos de milissegundos.

Otimizando seu código após a medição

Depois de descobrir qual parte do seu código está lenta, o próximo passo é a otimização. Muitas vezes, a lentidão ocorre porque o desenvolvedor desconhece funções internas mais eficientes. Estudar as funções built-in do python é o primeiro passo para escrever códigos mais velozes. O Python é uma linguagem de alto nível, o que significa que suas funções internas são geralmente implementadas em C e altamente otimizadas.

Outro ponto comum de gargalo é o uso incorreto de tipos de dados. Substituir uma lista por um set para operações de verificação de pertinência (usando o operador in) pode transformar um código que leva segundos em algo que roda em microssegundos. Sempre realize o benchmark antes e depois da mudança para confirmar o ganho real.

Medindo o tempo em projetos reais

Para aplicar isso na prática, imagine que você está desenvolvendo uma ferramenta para extrair texto de PDFs com python. O processamento de centenas de páginas pode ser demorado. Ao medir o tempo de diferentes bibliotecas de extração com o timeit, você pode escolher a que oferece o melhor equilíbrio entre precisão e velocidade, garantindo que sua automação seja eficiente.

Outro exemplo é na análise de dados. Ao utilizar o pandas no python, frequentemente existem várias formas de filtrar um DataFrame. Usar o timeit ajuda a decidir se o método .loc ou uma máscara booleana direta é mais rápida para o seu volume de dados específico.

Comparação de Performance: Tabela Prática

Abaixo, apresentamos uma comparação hipotética de tempos de execução para tarefas comuns de manipulação de dados em Python, simulando o que você encontraria ao realizar seus próprios testes.

Dicas para benchmarks precisos

Para obter os melhores resultados ao medir o tempo de código com timeit, siga estas diretrizes:

• Feche outros programas pesados (como navegadores ou editores de vídeo) enquanto roda os testes.
• Use um número de repetições suficientemente alto para que o tempo total seja de pelo menos 0,2 segundos.
• Mantenha as funções que você está testando puras, ou seja, sem efeitos colaterais como comandos print, que são lentos e mascaram o tempo real do cálculo.
• Considere o hardware; códigos que dependem de paralelismo podem se comportar de forma diferente em máquinas com mais núcleos.

Conclusão sobre a eficiência em Python

Dominar o módulo timeit transforma a maneira como você escreve código. Em vez de seguir cegamente tutoriais, você passa a ter dados concretos para justificar suas escolhas técnicas. A busca pela performance não deve ser uma obsessão prematura (como diz a famosa frase de Donald Knuth), mas sim uma ferramenta de polimento para tornar seu software profissional e robusto.

Comece hoje mesmo a testar seus scripts. Escolha um pequeno loop que você escreveu recentemente e veja se consegue reduzir seu tempo de execução pela metade. A prática constante de medição e otimização é o que diferencia programadores médios de especialistas em Python.

Perguntas Frequentes

O timeit funciona com funções que recebem argumentos?

Sim, você pode passar argumentos usando funções lambda ou a função partial do módulo functools para envolver sua função original antes de passá-la ao timeit.

Por que os resultados do timeit variam um pouco a cada execução?

Isso ocorre devido à carga atual do sistema operacional, gerenciamento de memória do Python e outros processos rodando no computador, por isso o uso do repeat() é recomendado.

Qual a diferença entre time.time() e timeit.default_timer()?

O default_timer() escolhe automaticamente o melhor relógio disponível para a sua plataforma (Windows ou Linux), oferecendo maior precisão para intervalos curtos do que o time.time().

O timeit mede o uso de memória?

Não, o foco exclusivo dele é tempo. Para medir memória, você deve usar bibliotecas como memory_profiler ou tracemalloc.

Posso medir códigos que envolvem banco de dados?

Pode, mas os resultados refletirão mais a velocidade da conexão e do banco do que a performance do Python em si, o que pode ser enganoso.

O timeit desativa o Garbage Collector automaticamente?

Sim, por padrão ele desativa a coleta de lixo para tornar a medição do tempo de CPU do código testado mais isolada e consistente.

Como medir o tempo de uma única execução de uma função longa?

Para funções que demoram muito, o timeit com number=1 ainda é útil, mas o módulo time com perf_counter() pode ser mais prático nesse caso específico.

O timeit é compatível com Python 2 e 3?

Sim, o módulo existe em ambas as versões, mas a precisão dos timers internos foi significativamente melhorada nas versões mais recentes do Python 3.