Python આપોઆપ બે મિકેનિઝમ્સનો ઉપયોગ કરીને મેમરીને સંચાલિત કરે છે: reference counting (પ્રાથમિક પદ્ધતિ) અને cyclic garbage collector જે reference cycles ને હેન્ડલ કરે છે. તમે ક્યારેય મેમરીને મેન્યુઅલી મુક્ત કરવાની જરૂર નથી, પરંતુ તે કેવી રીતે કામ કરે છે તે સમજવું મેમરીની વર્તણૂક અને લીક્સને સમજાવે છે.
sys
x = [, , ]
y = x
sys.getrefcount(x)
y
x
પ્રતિેક ઑબ્જેક્ટ ટ્રેક કરે છે કે તેની તરફ કેટલા references છે. જ્યારે ગણતરી શૂન્ય પર પડે છે, તો મેમરી તરત જ મુક્ત થાય છે. આ નિર્ધારિત અને ત્વરિત છે — જો કોઈ તેમનો સંદર્ભ ન આપે તો ઑબ્જેક્ટ્સ તરત જ મૃત્યુ પામે છે.
# 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
દો ઑબ્જેક્ટ્સ જે એક બીજાને સંદર્ભિત કરે છે તેઓ એક બીજાના refcount ને શૂન્ય ઉપર રાખે છે ભલે તે પહોંચી ન શકાય — એક ચક્ર જે શુદ્ધ reference counting સંગ્રહ કરી શકતો નથી.
import gc
# the generational GC periodically finds and frees unreachable CYCLES
gc.collect() # manually trigger a collection
gc.get_count() # objects tracked per generation
Python ની આનુષંગિક generational garbage collector સમયાંતરે આ અપ્રાપ્ય ચક્રને શોધે છે અને મુક્ત કરે છે. તે generational છે — નવા ઑબ્જેક્ટ્સ વધુ વાર તપાસવામાં આવે છે (મોટાભાગના ઑબ્જેક્ટ્સ કાચે મૃત્યુ પામે છે), જે કાર્યક્ષમ છે.
✓ 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 ચક્રોનો સામનો કરે છે, પરંતુ તે ઑબ્જેક્ટ્સને મુક્ત કરી શકતો નથી જે હજુ પણ reachable છે — સામાન્ય વાસ્તવિક-વિશ્વ "લીક" અનિચ્છાપૂર્વક જીવંત રહેવાતાં સંદર્ભો (ઉદાહરણ તરીકે, સર્વદા વધતો વૈશ્વિક કેશ) છે.
- Small integers (-5..256) and short strings are CACHED/interned (shared, reused)
- CPython uses memory pools (pymalloc) for small objects (efficiency)
Python ના મેમરી મોડેલને સમજવું — તત્પર reference counting અને cyclic GC — વાસ્તવિક વર્તણૂકો સમજાવે છે: શા માટે ઑબ્જેક્ટ્સ સામાન્ય રીતે તરત જ મુક્ત થાય છે, શા માટે reference cycles ને GC ની જરૂર છે, અને નિર્ણાયક રીતે શા માટે Python માં "memory leaks" reachable સંદર્ભો (વધતાં કેશ, ક્ષણભંગુર closures, અપ્રયુક્ત callbacks) થી આવે છે બીજી તમામ વસ્તુઓ આપણે GC ને કરવા માટે કહી શકીએ તેનાથી.
યોગ્ય સંદર્ભો તોડી નાખવો (કેશ્સને બાધ્ય કરવું, નોંધણીને સાફ કરવી) એ સામાન્ય રીતે તમારો સૈન્યને લાંબા-ચાલતી સેવાઓમાં મેમરીના વૃદ્ધિને નિદાન કરવા માટે અને સ્મૃતિ-સચેત કોડ લખવા માટે આવશ્યક છે — તે જાણવું કે તમારું સુધાર સામાન્ય રીતે સંદર્ભો તોડી નાખવા (કેશ્સને બાધ્ય કરવું, નોંધણીને સાફ કરવી) છે આ બીજી તમામ બાબતે GC તમારા માટે કરી શકે છે.