Análise de desempenho com timeit e memory_profiler

Um erro comum é otimizar o código intuitivamente — reescrever uma função que parece lenta sem medir se ela é realmente o gargalo. Em fluxos de processamento de dados, 90% do tempo de execução geralmente vem de 10% do código. A análise de desempenho identifica exatamente onde tempo e memória são consumidos, para que você possa concentrar o esforço de otimização no que realmente importa. A regra de ouro é: meça primeiro, otimize depois. Ferramentas como timeit medem o tempo, e memory_profiler mede a RAM.

O módulo timeit mede o tempo de execução executando uma instrução várias vezes e retornando o tempo total decorrido. timeit.timeit(stmt, number=n) executa stmt n vezes e retorna o total em segundos. Divida por number para obter o tempo por execução. Para obter medições precisas, escolha number de modo que a execução total leve pelo menos 0,1 segundo — uma única execução de uma operação rápida não é representativa devido às variações do agendamento do sistema.

Nos notebooks Jupyter, a função mágica %timeit seleciona automaticamente o número de repetições e execuções para fornecer uma estimativa estatisticamente estável e, em seguida, informa os melhores tempos e a média com o desvio padrão. É a maneira mais conveniente de fazer rapidamente uma medição de desempenho de uma única linha. Use %%timeit (percentual duplo) para medir uma célula inteira. O formato da saída é: X ns/μs/ms ± Y ns por loop (média ± desvio-padrão de 7 execuções, N loops cada).

Enquanto timeit mede uma única expressão, cProfile analisa toda a pilha de chamadas — ele mostra quanto tempo é gasto em cada função chamada durante a execução. Isso é essencial para identificar o gargalo em um fluxo de processamento complexo. Execute python -m cProfile -s cumulative script.py na linha de comando ou use cProfile.run('function()') em um script. No Jupyter, use %prun function().

Use df.memory_usage(deep=True) para ver quanta RAM cada coluna consome. O argumento deep=True mede a memória realmente usada pelas colunas do tipo object (strings), que, caso contrário, informam apenas o tamanho do ponteiro. Use .sum() para obter a memória total do DataFrame em bytes. Divida por 1e6 para obter MB ou por 1e9 para obter GB. Este é o ponto de partida para otimizar a memória — não é possível reduzir aquilo que não foi medido.

O pacote memory_profiler (pip install memory-profiler) mede o uso de RAM linha a linha em uma função. Decore uma função com @profile e execute-a com python -m memory_profiler script.py. No Jupyter, use a função mágica %memit (da extensão do ipython) para medir o pico de memória de uma única expressão. Isso identifica quais estruturas de dados causam aumentos repentinos de memória — geralmente, concatenar dentro de um loop em vez de coletar os dados e concatená-los uma única vez.

sys.getsizeof(obj) retorna o tamanho da memória de um objeto Python, mas, para DataFrames do pandas, informa apenas a sobrecarga do contêiner (algumas centenas de bytes), não os dados reais. Use sempre df.memory_usage(deep=True).sum() para DataFrames. Para objetos Python individuais, como listas e dicionários, sys.getsizeof é preciso, mas não percorre objetos aninhados — use a biblioteca pympler (asizeof) para obter os tamanhos completos dos objetos.

Para etapas mais longas do fluxo de processamento, nas quais timeit não é adequado (por exemplo, consultas ao banco de dados ou entrada e saída de arquivos), use um gerenciador de contexto simples com time.perf_counter(). Envolva cada etapa do fluxo de processamento em um contexto de temporizador para registrar sua duração. Isso é mais prático do que timeit no código de produção, pois registra o tempo real decorrido, incluindo a espera por entrada e saída, que timeit também mede, mas é mais difícil de integrar a estruturas de registro.

Um fluxo de trabalho sistemático de criação de perfis: 1) Comece com uma amostra representativa dos seus dados (10.000 linhas são suficientes para comparações de tempo). 2) Identifique as etapas mais lentas usando um contexto de temporização ou cProfile. 3) Reescreva a etapa mais lenta usando uma abordagem mais rápida (vetorização, dtype Categorical, extensão em C). 4) Verifique a correção com instruções assert. 5) Meça o tempo novamente para confirmar o ganho de velocidade. 6) Repita o processo para o próximo gargalo até que o pipeline atenda ao seu SLA.

Nem todo script precisa de criação de perfis. Invista nisso quando: um pipeline demora mais de 30 segundos para ser executado e é executado com frequência (diariamente ou mais), uma função processa mais de 100.000 linhas ou o uso de memória excede 50% da RAM disponível. Para scripts executados uma única vez ou em questão de segundos, a legibilidade é mais importante do que a optimização de microssegundos. O custo de manter código muito optimizado e obscuro frequentemente supera o tempo economizado pela optimização.

Uma referência rápida:

• timeit.timeit — mede o tempo de uma única instrução (script)
• %timeit / %%timeit — mede o tempo no Jupyter (repete automaticamente)
• %prun / cProfile — criação de perfis da pilha de chamadas no nível das funções
• df.memory_usage(deep=True) — medição da RAM por coluna
• memory_profiler @profile — medição da RAM linha a linha
• time.perf_counter() — temporizador manual para as etapas do pipeline

Teste a sua compreensão das ferramentas de criação de perfis apresentadas nesta lição.

Nesta lição, aprendeu que timeit.timeit e %timeit medem o tempo de execução de operações específicas, df.memory_usage(deep=True) mede a RAM de cada coluna com precisão e cProfile / memory_profiler fornecem uma análise mais detalhada de pipelines complexos. Crie sempre perfis antes de optimizar e verifique a correção após cada alteração. A seguir, veremos como evitar loops lentos com iterrows e substituí-los por operações vetorizadas.