0Pricing
Python Academy · Aula

Criação de perfis de memória com tracemalloc

Acompanhe alocações de memória e encontre vazamentos com tracemalloc.

Criação de perfis de memória com tracemalloc é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 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.

O que é tracemalloc?

tracemalloc é um módulo da biblioteca padrão que acompanha as alocações de memória do Python por arquivo e número de linha.

import tracemalloc

tracemalloc.start()

x = [i for i in range(100_000)]

current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Current: {current/1024:.1f} KB")
print(f"Peak:    {peak/1024:.1f} KB")

Tirando instantâneos

Um instantâneo captura todas as alocações atuais em determinado momento. Compare dois instantâneos para descobrir o que foi alocado entre eles.

import tracemalloc

tracemalloc.start()

snap1 = tracemalloc.take_snapshot()

data = [{"key": str(i)} for i in range(10_000)]

snap2 = tracemalloc.take_snapshot()

stats = snap2.compare_to(snap1, "lineno")
for stat in stats[:5]:
    print(stat)

Filtrando instantâneos

Filtre as estatísticas para mostrar apenas o código da sua aplicação, excluindo a biblioteca padrão.

import tracemalloc

tracemalloc.start()
leak_function()
snap = tracemalloc.take_snapshot()

filters = [tracemalloc.Filter(True, "*/myapp/*")]
stats = snap.filter_traces(filters).statistics("lineno")
for stat in stats[:10]:
    print(stat)

Principais alocadores

Use snapshot.statistics("lineno") ou "traceback" para ver os maiores consumidores de memória por linha ou pelo traceback completo.

import tracemalloc

tracemalloc.start(nframe=10)   # track 10 frames deep

big_list = [i**2 for i in range(500_000)]

snap = tracemalloc.take_snapshot()
for stat in snap.statistics("traceback")[:3]:
    print(stat)
    for line in stat.traceback.format():
        print("  ", line)

Encontrando vazamentos de memória

Tire dois instantâneos ao redor de um possível vazamento e compare-os. O crescimento das estatísticas entre os instantâneos indica um vazamento.

import tracemalloc

tracemalloc.start()
snap_before = tracemalloc.take_snapshot()

for _ in range(100):
    suspected_leaky_function()

snap_after = tracemalloc.take_snapshot()
diff = snap_after.compare_to(snap_before, "lineno")
for stat in diff[:5]:
    print(stat)

get_traced_memory()

tracemalloc.get_traced_memory() retorna os bytes (current, peak) — útil para verificações leves antes e depois.

import tracemalloc

tracemalloc.start()
before, _ = tracemalloc.get_traced_memory()

do_something()

after, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Delta: {(after-before)/1024:.1f} KB, Peak: {peak/1024:.1f} KB")

perfilador de memória

memory_profiler fornece o uso de memória linha a linha, de modo semelhante ao line_profiler para a CPU.

# pip install memory_profiler
from memory_profiler import profile

@profile
def build_data():
    data = [i**2 for i in range(100_000)]
    filtered = [x for x in data if x % 2 == 0]
    return filtered

build_data()
# python -m memory_profiler script.py

memray

memray (da Bloomberg) é um perfilador rápido de memória do Python, com saída em forma de gráfico de chamas.

# pip install memray
# python -m memray run script.py
# python -m memray flamegraph memray-script.py.bin

# Generates an interactive HTML flamegraph
# showing allocations by call stack

Reduzindo o uso de memória

Técnicas comuns: use geradores em vez de listas, __slots__, o módulo array para dados numéricos e arrays do numpy; evite também manter objetos grandes vivos em fechamentos.

# Instead of:
data = [process(x) for x in huge_list]   # all in memory

# Use a generator:
def gen_data(lst):
    for x in lst:
        yield process(x)

for item in gen_data(huge_list):
    consume(item)   # one at a time

sys.getsizeof()

sys.getsizeof(obj) retorna a memória usada por um objeto em bytes (superficial — não inclui os objetos referenciados).

import sys

print(sys.getsizeof([]))          # 56
print(sys.getsizeof([1,2,3]))     # 88
print(sys.getsizeof("hello"))     # 54
print(sys.getsizeof({}))          # 64

# For deep size, use recursive measurement:
def deep_size(obj):
    return sys.getsizeof(obj) + sum(
        sys.getsizeof(v) for v in vars(obj).values()
        if hasattr(obj, "__dict__")
    )

Análise em produção

Execute tracemalloc com um número limitado de nframes em produção para minimizar a sobrecarga. Armazene os instantâneos em um arquivo para análise posterior.

import tracemalloc, pickle

tracemalloc.start(nframe=5)   # low overhead

# ... serve some requests ...

snap = tracemalloc.take_snapshot()
with open("snap.pkl","wb") as f:
    pickle.dump(snap, f)
# Analyse later offline

Verificação rápida

O que representam os dois valores retornados por tracemalloc.get_traced_memory()?

Recapitulação

Use tracemalloc.start() + instantâneos para encontrar vazamentos de memória. Compare os instantâneos com compare_to(). Use memory_profiler para acompanhar o uso linha a linha e memray para gerar gráficos de chamas. Reduza o uso de memória com geradores, __slots__ e arrays do NumPy.

Perguntas Frequentes

A aula “Criação de perfis de memória com tracemalloc” é grátis?

Sim — o texto completo de “Criação de perfis de memória com tracemalloc” é 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 de memória com tracemalloc”?

Acompanhe alocações de memória e encontre vazamentos com tracemalloc. 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 4 de 4.

Quanto tempo leva a aula “Criação de perfis de memória com tracemalloc”?

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