🎮 Introduction: Python Memory Ka Game

"Python me memory khud hi manage hoti hai... lekin kaise?"

"Stack aur heap kya hai? Garbage Collector kaise decide karta hai ki kya delete karna hai?"

"Aaj hum karenge ek deep internal exploration Python ke memory management ka."

"Iss video ke baad aap sirf code nahi, uske peeche ka game bhi samjhoge."

🔹 1. Stack vs Heap Memory

🧱 Stack Memory:

• Function ke andar jo variables hote hain, wo stack memory mein jaate hain.
• Jaise hi function complete hota hai, stack ka data automatically clean ho jaata hai.
• Access bahut fast hota hai.

🧱 Heap Memory:

• Bade objects, collections (jaise list, dict) heap memory mein store hote hain.
• Heap ka data manually clean hota hai — ya Python ka Garbage Collector handle karta hai.
• Same object ko multiple variables refer kar sakte hain.

📌 Code Example:

def func():
    a = 10      # 'a' stack mein
    b = [1, 2]  # list heap mein, but 'b' stack mein reference
    return b
 
res = func()

🔍 a stack pe hai.

🔍 b ka reference stack pe hai, lekin uski actual list heap pe store hoti hai.

🧠 Secret: Python heap objects ko manage karta hai reference counting se — chaliye samjhte hain kaise.

🔹 2. Reference Counting

Python track karta hai ki ek object ko kitne variables ya places se refer kiya gaya hai.

• Jab kisi object ka reference count 0 ho jaata hai — Python usse memory se hata deta hai.

import sys
 
x = [1, 2, 3]
print(sys.getrefcount(x))  # 1 extra count function argument ki wajah se

📌 Why important?

Agar object kisi se refer nahi ho raha, to woh memory waste kar raha hai.

Python usse delete karke memory free karta hai.

🔍 Real-life issue: Kabhi-kabhi reference cycles ban jaati hain (object apne aap ko refer karta hai), to woh memory leak create karte hain. Iske liye Garbage Collector use hota hai.

🔹 3. Garbage Collector (GC)

Aise cases jahan reference counting fail ho jaati hai — jaise cyclic references, wahan Garbage Collector kaam karta hai.

import gc
 
class A:
    def __init__(self):
        self.ref = self  # khud ko hi refer kar raha hai
 
a = A()
del a
gc.collect()

a delete hone ke baad bhi object memory mein hai — kyunki usne khud ko refer kiya hua tha.

gc.collect() use karke aise cyclic objects ko delete kiya ja sakta hai.

🔍 GC ko control bhi kar sakte ho:

import gc
 
gc.disable()  # temporarily disable GC
# heavy memory task
gc.enable()   # enable again

🧠 Pro Tip:

• gc.get_objects() – sab live objects dekh sakte ho.
• gc.collect() – forcefully memory clean kar sakte ho.

🔹 4. Python ke Memory Optimizations

✅ Integer Caching:

a = 10
b = 10
print(id(a), id(b))  # same object — kyunki 10 cached hai

✅ String Interning:

s1 = "hello"
s2 = "hello"
print(id(s1), id(s2))  # same object

✅ Immutable Reuse:

Python commonly used immutable objects ko reuse karta hai, taaki memory efficient ban sake.

📌 But for mutable objects:

a = [1, 2]
b = [1, 2]
print(id(a), id(b))  # alag object – kyunki list mutable hai

Har list, dict naya object banata hai.

🔹 5. Real World Examples & Tips

✅ Data Processing Code:

• Bahut bada data handle karte waqt generators ka use karo — memory efficient hota hai.

✅ Web Apps:

• Object pooling se baar-baar object create karne ki zarurat nahi padti.
• GC tuning se server performance improve hoti hai.

✅ AI / ML Projects:

• Custom classes banate waqt cyclic references se bacho.
• Models ko memory mein load karne ke baad unhe properly delete karo.

🔹 6. Pro Level Memory Debugging Tools

🧠 Memory usage track karne ke liye tracemalloc ka use karo:

import tracemalloc
 
tracemalloc.start()
# memory heavy task yahan karo
print(tracemalloc.get_traced_memory())
tracemalloc.stop()

🧠 Advanced tools for professionals:

• pympler – live memory objects analyze karta hai
• objgraph – object references ka graph banata hai
• memory_profiler – function level memory usage check karta hai

🌟 Outro: Python Memory Ki Mastery

"Aap code likhte ho... Python uska memory version bhi rakhta hai."

"Memory samajhoge, toh optimization khud aayegi."

"Agle part me seekhenge — Mutable vs Immutable ka asli farq, aur kaise optimize karte hain unhe efficiently."