Como fazer profiling de código Python: guia prático

Profiling de código — é o processo sistemático de análise de performance de um programa, que permite identificar gargalos e otimizar o funcionamento da aplicação. Em Python, existem diversas ferramentas para medir tempo de execução, consumo de memória e outras métricas críticas.

Fundamentos do profiling de código Python

Profiling é uma análise dinâmica do programa que mede:

• tempo de execução de funções individuais
• número de chamadas de métodos
• consumo de memória RAM
• carga na CPU

O principal objetivo do profiling — é identificar as seções críticas do código que estão deixando a aplicação lenta e precisam de otimização.

Quando aplicar profiling

O profiling é especialmente útil nos seguintes casos:

Performance da aplicação: Se o programa está rodando mais devagar do que o esperado, o profiling ajuda a descobrir as causas da lentidão.

Alto consumo de recursos: Quando há uso excessivo de CPU ou memória RAM, o profiling mostra quais funções consomem mais recursos.

Preparação para produção: Antes de implantar aplicações críticas, o profiling ajuda a garantir que elas sejam eficientes.

Otimização de algoritmos: Ao trabalhar com grandes volumes de dados ou cálculos complexos, o profiling revela algoritmos ineficientes.

Ferramentas de profiling integradas

Módulo cProfile

cProfile — é o profiler padrão do Python, incluído no interpretador. Ele é ideal para uma análise geral de performance do programa.

import cProfile

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

def test_function():
    result = fibonacci(30)
    return result

# Iniciando o profiling
cProfile.run('test_function()')

O resultado do profiling contém métricas importantes:

• ncalls — número total de chamadas da função
• tottime — tempo de execução da função sem chamadas internas
• percall — tempo médio por chamada
• cumtime — tempo total incluindo todas as chamadas internas
• filename:lineno(function) — localização da função no código

Módulo timeit para medições pontuais

Para medir o tempo de execução de pequenos trechos de código, use o módulo timeit:

import timeit

# Comparando diferentes formas de criar uma lista
list_comprehension = timeit.timeit('[i*2 for i in range(1000)]', number=1000)
map_function = timeit.timeit('list(map(lambda x: x*2, range(1000)))', number=1000)

print(f"List comprehension: {list_comprehension:.6f} seg")
print(f"Map function: {map_function:.6f} seg")

Módulo profile para análise detalhada

Um profiler integrado alternativo, mais lento que o cProfile, mas que fornece informações mais detalhadas:

import profile

def complex_calculation():
    data = []
    for i in range(10000):
        data.append(i ** 2)
    return sum(data)

profile.run('complex_calculation()')

Ferramentas externas de profiling

line_profiler — profiling linha por linha

Esta ferramenta mostra o tempo de execução de cada linha do código:

pip install line_profiler

@profile
def process_data():
    data = []
    for i in range(100000):  # Esta linha pode ser um gargalo
        data.append(i * 2)
    return sum(data)

Executando o profiling linha por linha:

kernprof -l -v script.py