0Pricing
Python Academy · Aula

Criação de perfis com cProfile e line_profiler

Encontre gargalos de CPU com cProfile e criação de perfis linha a linha.

Criação de perfis com cProfile e line_profiler é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Por que criar perfis?

A criação de perfis identifica quais funções consomem mais tempo, orientando os esforços de otimização. Sempre crie um perfil antes de otimizar — nunca faça suposições.

import cProfile

def slow():
    total = 0
    for i in range(1_000_000):
        total += i
    return total

cProfile.run("slow()")

Execução do cProfile pela CLI

Analise um script inteiro sem modificá-lo: python -m cProfile -s cumtime script.py. Classifique por cumtime, tottime ou calls.

# python -m cProfile -s cumtime my_script.py
#
# ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#   1000    0.500    0.001    2.100    0.002 utils.py:10(process)

cProfile no código

Crie um cProfile.Profile, ative-o/desative-o e depois imprima as estatísticas com pstats.

import cProfile, pstats, io

pr = cProfile.Profile()
pr.enable()

# ... code to profile ...

pr.disable()
stream = io.StringIO()
ps = pstats.Stats(pr, stream=stream).sort_stats("cumulative")
ps.print_stats(10)   # top 10
print(stream.getvalue())

Filtragem de pstats

Filtre a saída do perfilador para um módulo específico ou para um padrão de nome de função usando print_stats(pattern).

import cProfile, pstats

cProfile.run("my_function()", "profile.out")
stats = pstats.Stats("profile.out")
stats.sort_stats("tottime")
stats.print_stats("mymodule")   # only mymodule functions

perfilador de linhas

line_profiler mostra o tempo de execução por linha, não apenas por função — algo essencial para encontrar a linha mais demorada dentro de uma função.

# pip install line_profiler
# Decorate target function:
from line_profiler import profile

@profile
def process(data):
    result = []
    for item in data:          # <- which line is slow?
        result.append(item*2)
    return result

# Run: kernprof -l -v script.py

CLI do kernprof

kernprof -l script.py executa o script com a análise por linha ativada; -v exibe o relatório imediatamente.

# kernprof -l -v script.py
#
# Line #  Hits  Time  Per Hit  % Time  Line Contents
# ======================================================
#     4    1  2.0   2.0       1.0    result = []
#     5  1000  120.0  0.1     60.0    for item in data:
#     6  1000   80.0  0.1     39.0        result.append(item*2)

Análise de desempenho no Jupyter

O Jupyter fornece os comandos mágicos %prun (cProfile) e %lprun (line_profiler).

# In a Jupyter cell:
# %prun -s cumulative my_function(data)

# %load_ext line_profiler
# %lprun -f my_function my_function(data)

Identificando gargalos

Concentre-se nas funções com o maior tempo cumulativo (toda a cadeia) e com o maior tempo total (a própria função, excluindo as funções chamadas).

# cumtime = total time including callees (find root cause)
# tottime = time in function itself (find where work happens)
#
# Optimise the function with highest tottime first

Evitando otimização prematura

Faça a análise primeiro e depois otimize o gargalo medido. Acelerações comuns em Python: use funções integradas, mova os loops para o NumPy, armazene em cache as consultas repetidas ou chame C por meio de ctypes/cffi.

# Before optimising:
# profile shows: process_row() 95% of time

# Speedup: vectorise with NumPy
import numpy as np
arr = np.array(data)
result = arr * 2   # 100x faster than Python loop

py-spy: perfilador por amostragem

py-spy analisa processos em execução sem modificar o código — conecte-se a um PID ativo.

# pip install py-spy

# Profile for 30 s and show flamegraph:
# py-spy top --pid 12345
# py-spy record -o profile.svg --pid 12345 --duration 30

Benchmarking com timeit

Use timeit para microbenchmarks de expressões específicas.

import timeit

result = timeit.timeit(
    "[x*2 for x in range(1000)]",
    number=10_000
)
print(f"{result:.3f} s for 10k runs")

Verificação rápida

O que tottime mostra em um relatório do cProfile?

Recapitulação

Use cProfile para encontrar funções lentas e line_profiler para encontrar a linha lenta. Faça a análise com -s cumtime para encontrar as causas principais. Otimize apenas os gargalos comprovados — use vetorização com NumPy, armazenamento em cache ou extensões em C para obter os maiores ganhos.

Perguntas Frequentes

A aula “Criação de perfis com cProfile e line_profiler” é grátis?

Sim — o texto completo de “Criação de perfis com cProfile e line_profiler” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Criação de perfis com cProfile e line_profiler”?

Encontre gargalos de CPU com cProfile e criação de perfis linha a linha. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Criação de perfis com cProfile e line_profiler”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Contagem de referências do CPython
  2. O coletor de lixo e referências cíclicas
  3. Criação de perfis com cProfile e line_profiler
  4. Criação de perfis de memória com tracemalloc
← Voltar para Python Academy