Kako Python upravlja s pomnilnikom in zbiranjem smeti?

Question

Accepted Answer

Python upravlja s pomnilnikom **avtomatično** z dvema mehanizmoma: **štetjem referenc** (primarni način) in **ciklično zbirko smeti**, ki obravnava ciklične reference. Nikoli ročno ne sproščate pomnilnika, vendar razumevanje delovanja pojasni obnašanje pomnilnika in puščanje pomnilnika.

## Štetje referenc — primarni mehanizem

```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
```

Vsak predmet prati, koliko referenc nanj kaže. Ko se število zmanjša na **nič**, se je pomnilnik osvobodi **takoj**. To je determinističko in hitro — predmeti izginejo, takoj ko jih nič ne referenciuje.

## Problem: ciklične reference

```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
```

Dva predmeta, ki se sklicujeta drug na drugega, obdržita število referenc drug drugega nad ničlo, tudi če sta nedosegljiva — cikel, ki ga čisto štetje referenc ne more zbrati.

## Ciklična zbirka smeti

```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
```

Supplementalna **generacijska zbirka smeti** Pythona periodično zaznava in spremeni te nedosegljive cikle. Je *generacijska* — novejši predmeti se preverjajo pogosteje (večina predmetov hitro izgineva), kar je učinkovito.

## Praktične posledice in viri puščanja

```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
```

Zbirka smeti obravnava cikle, vendar ne more osvoboditi predmetov, ki so še vedno *dosegljivi* — pogosto "puščanje" v praksi je nenaklučno ohranjanje referenc aktivno (npr. vedno večja globalna predpomnilna shema).

## Drugi podrobnosti

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

## Zakaj je to važno

Razumevanje Pythonovega modela pomnilnika — hitro štetje referenc in ciklična zbirka smeti — pojasni resnično obnašanje: zakaj se predmeti običajno osvobodijo takoj, zakaj ciklične reference potrebujejo zbiranje smeti in predvsem zakaj "puščanja pomnilnika" v Pythonu izhajajo iz *dosegljivih* referenc (naraščajoče predpomnilne sheme, trajne zaprtine, neprimerjene povratne kliche) namesto pozabljenih sproščanj.

To znanje je bistvenega pomena za diagnosticiranje rasti pomnilnika v dolgotrajnih storitvah in za pisanje kode, ki je zavest do pomnilnika — vedenje, da je popravek običajno prelomljenje referenc (omejitev predpomnilnih shem, čiščenje registracij) namesto česar koli, kar bi lahko storila zbirka smeti za vas.