Como o Python gerencia memória e coleta de lixo?

Question

Accepted Answer

O Python gerencia memória **automaticamente** usando dois mecanismos: **contagem de referências** (o método principal) mais um **coletor de lixo cíclico** que trata ciclos de referência. Você nunca libera memória manualmente, mas entender como funciona explica o comportamento da memória e vazamentos.

## Contagem de referências — o mecanismo principal

```python
import sys

x = [1, 2, 3]        # the list object has refcount 1
y = x                 # refcount 2 (another name references it)
sys.getrefcount(x)    # shows the count (slightly higher due to the call itself)

del y                 # refcount 1
del x                 # refcount 0 → the object is FREED immediately
```

Cada objeto rastreia quantas referências apontam para ele. Quando a contagem cai para **zero**, a memória é liberada **imediatamente**. Isso é determinístico e rápido — objetos morrem assim que nada os referencia.

## O problema: ciclos de referência

```python
# reference counting alone can't free this:
a = {}
b = {}
a["b"] = b      # a references b
b["a"] = a      # b references a → they reference EACH OTHER
del a, b        # the names are gone, but the objects still reference each other
# → refcounts never reach 0 → they'd leak with refcounting alone
```

Dois objetos se referenciando mutuamente mantêm a contagem de referências um do outro acima de zero mesmo quando inacessíveis — um ciclo que a contagem pura de referências não consegue coletar.

## O coletor de lixo cíclico

```python
import gc

# the generational GC periodically finds and frees unreachable CYCLES
gc.collect()        # manually trigger a collection
gc.get_count()      # objects tracked per generation
```

O **coletor de lixo geracional** suplementar do Python detecta e libera periodicamente esses ciclos inacessíveis. É *geracional* — objetos mais novos são verificados com mais frequência (a maioria dos objetos morre jovem), o que é eficiente.

## Implicações práticas & fontes de vazamento

```text
✓ Most memory is reclaimed promptly via reference counting
⚠️ Leaks still happen from REACHABLE references that outlive their usefulness:
   - global caches/lists that only grow
   - objects held by long-lived closures or class attributes
   - registered callbacks/listeners never removed
```

O GC trata ciclos, mas não consegue liberar objetos que ainda são *acessíveis* — o "vazamento" comum do mundo real é manter referências inadvertidamente vivas (por exemplo, um cache global em crescimento contínuo).

## Outros detalhes

```text
- Small integers (-5..256) and short strings are CACHED/interned (shared, reused)
- CPython uses memory pools (pymalloc) for small objects (efficiency)
```

## Por que isso importa

Entender o modelo de memória do Python — contagem de referências rápida mais um GC cíclico — explica comportamentos reais: por que objetos são geralmente liberados imediatamente, por que ciclos de referência precisam do GC e, crucialmente, por que "vazamentos de memória" em Python vêm de referências *acessíveis* (caches crescentes, closures persistentes, callbacks não removidos) em vez de liberações esquecidas.

Esse conhecimento é essencial para diagnosticar crescimento de memória em serviços de longa execução e para escrever código consciente de memória — sabendo que a solução é geralmente quebrar referências (limitar caches, limpar registros) em vez de qualquer coisa que o GC possa fazer por você.