ਪਾਈਥਨ ਮੈਮੋਰੀ ਅਤੇ ਗਾਰਬੇਜ ਕਲੈਕਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

ਪਾਈਥਨ ਮੈਮੋਰੀ ਨੂੰ **ਆਪਣੇ ਆਪ** ਦੋ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ: **reference counting** (ਮੁੱਖ ਵਿਧੀ) ਨਾਲ ਇੱਕ **cyclic garbage collector** ਜੋ reference cycles ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਕਦੇ ਵੀ ਮੈਮੋਰੀ ਨੂੰ ਹੱਥੋਂ ਮੁਕਤ ਕਰਨਾ ਨਹੀਂ ਪੈਂਦਾ, ਪਰ ਇਹ ਸਮਝਣਾ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਮੈਮੋਰੀ ਵਿਵਹਾਰ ਅਤੇ ਲੀਕਾਂ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ।

## Reference counting — ਮੁੱਖ ਵਿਧੀ

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

ਹਰੇਕ object ਟ੍ਰੈਕ ਕਰਦਾ ਹੈ ਕਿ ਕਿੰਨੇ references ਇਸ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਰਹੇ ਹਨ। ਜਦੋਂ count **ਜ਼ੀਰੋ** 'ਤੇ ਖਿਸਕ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੈਮੋਰੀ **ਤੁਰੰਤ** ਮੁਕਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਨਿਰਧਾਰਤ ਹੈ ਅਤੇ ਤੇਜ਼ — objects ਜਿਵੇਂ ਹੀ ਕੁਝ ਵੀ ਉਹਨਾਂ ਵੱਲ ਸੰਕੇਤ ਨਹੀਂ ਕਰਦਾ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ।

## ਸਮੱਸਿਆ: reference cycles

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

ਦੋ objects ਜੋ ਇੱਕ ਦੂਜੇ ਨੂੰ ਸੰਕੇਤ ਕਰਦੇ ਹਨ ਇੱਕ ਦੂਜੇ ਦੀ refcount ਨੂੰ ਜ਼ੀਰੋ ਤੋਂ ਉਪਰ ਰੱਖਦੇ ਹਨ ਭਾਵੇਂ ਅਪ੍ਰਾਪਤ ਹੋਵੇ — ਇੱਕ cycle ਜਿਸਨੂੰ ਸ਼ੁੱਧ reference counting ਇਕੱਠਾ ਨਹੀਂ ਕਰ ਸਕਦਾ।

## Cyclic garbage collector

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

ਪਾਈਥਨ ਦਾ ਪੂਰਕ **generational garbage collector** ਸਮੇਂ-ਸਮੇਂ ਤੇ ਇਨ੍ਹਾਂ ਅਪ੍ਰਾਪਤ cycles ਨੂੰ ਲੱਭਦਾ ਹੈ ਅਤੇ ਮੁਕਤ ਕਰਦਾ ਹੈ। ਇਹ *generational* ਹੈ — ਨਵੇ objects ਨੂੰ ਜ਼ਿਆਦਾ ਅਕਸਰ ਚੈੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਜ਼ਿਆਦਾਤਰ objects ਜਲਦੀ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ), ਜੋ ਕਿ ਕੁਸ਼ਲ ਹੈ।

## ਵਿਹਾਰਕ ਪ੍ਰਭਾਵ ਅਤੇ ਲੀਕ ਦੇ ਸ੍ਰੋਤ

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

GC cycles ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਪਰ ਇਹ ਉਹ objects ਨੂੰ ਮੁਕਤ ਨਹੀਂ ਕਰ ਸਕਦਾ ਜੋ ਅਜੇ ਵੀ *ਪ੍ਰਾਪਤ* ਹਨ — ਆਮ ਵਾਸਤਵਿਕ-ਜਗਤ ਦੀ "ਲੀਕ" ਅਣਜਾਣੇ ਵਿੱਚ references ਨੂੰ ਜੀਵਿਤ ਰੱਖਣਾ ਹੈ (ਉਦਾ. ਲਗਾਤਾਰ ਵੱਧ ਰਹੇ global cache)।

## ਹੋਰ ਵਿਸਥਾਰ

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

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਪਾਈਥਨ ਦੇ ਮੈਮੋਰੀ ਮਾਡਲ ਨੂੰ ਸਮਝਣਾ — ਤੇਜ਼ reference counting ਨਾਲ ਇੱਕ cyclic GC — ਅਸਲ ਵਿਵਹਾਰ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ: ਕਿਉਂ objects ਆਮ ਤੌਰ 'ਤੇ ਤੁਰੰਤ ਮੁਕਤ ਹੁੰਦੇ ਹਨ, ਕਿਉਂ reference cycles ਨੂੰ GC ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਕਿਉਂ ਪਾਈਥਨ ਵਿੱਚ "ਮੈਮੋਰੀ ਲੀਕਸ" *ਪ੍ਰਾਪਤ* references ਤੋਂ ਆਉਂਦੇ ਹਨ (ਵੱਧ ਰਹੇ caches, ਲਿੰਗਰ closures, ਹਟਾਏ ਗਏ callbacks) ਬਜਾਏ ਭੁੱਲੇ ਹੋਏ frees ਦੇ।

ਇਹ ਜਾਣਕਾਰੀ ਲੰਬੇ-ਚੱਲਣ ਵਾਲੀਆਂ ਸੇਵਾਵਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਵਾਧੇ ਦਾ ਨਿਦਾਨ ਕਰਨ ਲਈ ਅਤੇ ਮੈਮੋਰੀ-ਸੁਚੇਤ ਕੋਡ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਜਾਣਕਾਰੀ ਕਿ ਹੱਲ ਆਮ ਤੌਰ 'ਤੇ references ਨੂੰ ਤੋੜਨਾ ਹੈ (caches ਨੂੰ ਬੰਨਤ ਲਗਾਉਣਾ, ਰਜਿਸਟ੍ਰੇਸ਼ਨਾਂ ਨੂੰ ਸਾਫ ਕਰਨਾ) ਬਜਾਏ ਕਿਸੇ ਵੀ ਚੀਜ ਦੇ ਜੋ GC ਤੁਹਾਡੇ ਲਈ ਕਰ ਸਕਦਾ ਹੈ।