Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Comprehensive guide to Python memory management, reference counting, garbage collection, memory profiling, optimization techniques, and best practices with Hindi explanations.
Introduction
Python memory management happens automatically, but as an advanced developer it's important to understand how Python allocates and deallocates memory. This knowledge helps debug memory leaks, optimize performance, and write memory-efficient code.
Python Memory ke Main Components:
- Reference Counting — primary memory management
- Garbage Collector — circular reference detection
- Memory Pools (pymalloc) — small object optimization
2. Object Identity and Small Integer Caching
Example
import sys
# Integer caching (-5 to 256)
a = 100
b = 100
print(a is b) # True — same object cached!
print(id(a) == id(b)) # True
c = 1000
d = 1000
print(c is d) # False — different objects!
print(id(c) == id(d)) # False
# String interning
s1 = "hello"
s2 = "hello"
print(s1 is s2) # True — interned!
s3 = "hello world" # Space prevents interning
s4 = "hello world"
print(s3 is s4) # May be True or False
# Force interning
import sys
s5 = sys.intern("hello world")
s6 = sys.intern("hello world")
print(s5 is s6) # True — forced interning
# Object sizes
print(f"int(1): {sys.getsizeof(1)} bytes") # 28
print(f"int(10**100): {sys.getsizeof(10**100)} bytes") # 72+ (big integer)
print(f"list[]: {sys.getsizeof([])} bytes") # 56
print(f"list[10]: {sys.getsizeof([0]*10)} bytes") # 136
print(f"dict{{}}: {sys.getsizeof({})} bytes") # 64
print(f"str 'hi': {sys.getsizeof('hi')} bytes") # 51
Output
True
True
False
False
True
True
True
int(1): 28 bytes
int(10**100): 72 bytes
list[]: 56 bytes
list[10]: 136 bytes
dict{}: 64 bytes
str 'hi': 51 bytes3. Garbage Collection — Circular References
python example
import gc
# Circular reference — reference counting alone can't handle this!
class Node:
def __init__(self, data):
self.data = data
self.next = None
# Create circular reference
a = Node("A")
b = Node("B")
a.next = b # a -> b
b.next = a # b -> a (circular!)
del a # ref count doesn't reach 0 (b still points to a)
del b # ref count doesn't reach 0 (a still points to b)
# Without GC, this would be a memory leak!
# Python's GC detects and cleans circular references
gc.collect() # Force garbage collection
print(f"Collected {gc.collect()} objects")
# Monitoring GC
print(f"GC enabled: {gc.isenabled()}")
print(f"GC thresholds: {gc.get_threshold()}") # (700, 10, 10)
# Generation 0: collect when 700 new objects created
# Generation 1: collect after gen0 collected 10 times
# Generation 2: collect after gen1 collected 10 times
# Manual GC control
gc.disable() # Turn off automatic GC
# ... performance-critical code ...
gc.enable() # Re-enable
gc.collect() # Force collect onceOutput
Collected 4 objects GC enabled: True GC thresholds: (700, 10, 10)
4. Memory Profiling with tracemalloc
Example
import tracemalloc
# Start tracing
tracemalloc.start()
# Your code here
data = [i**2 for i in range(10000)]
strings = [f"string_{i}" for i in range(1000)]
nested = [[j for j in range(100)] for i in range(100)]
# Get current memory usage
current, peak = tracemalloc.get_traced_memory()
print(f"Current: {current/1024:.2f} KB")
print(f"Peak: {peak/1024:.2f} KB")
# Get top memory consumers
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
print("\nTop 10 memory consumers:")
for stat in top_stats[:10]:
print(stat)
tracemalloc.stop()
Output
Current: 1024.56 KB Peak: 1025.12 KB Top 10 memory consumers: <stdin>:5: size=394 KiB, count=10001, average=40 B
Example
import tracemalloc
# Memory diff — before and after
tracemalloc.start()
# Snapshot 1
snap1 = tracemalloc.take_snapshot()
# Operation
large_list = list(range(1_000_000))
# Snapshot 2
snap2 = tracemalloc.take_snapshot()
# Compare
stats = snap2.compare_to(snap1, 'lineno')
print("\nMemory increase:")
for stat in stats[:5]:
print(f" {stat}")
tracemalloc.stop()
del large_list
Output
Memory increase: <stdin>:8: size=38.1 MiB (+38.1 MiB), count=1 (+1), average=38.1 MiB <stdin>:5: size=576 B (+576 B), count=1 (+1), average=576 B
📝 Hindi Explanation
tracemalloc is a built-in memory profiling tool in Python 3.4+.take_snapshot()captures a snapshot of current memory allocations.compare_to()shows the difference between two snapshots — this is the most effective way to detect memory leaks.
5. sys.getsizeof — Object Size
Example
import sys
# Basic object sizes
print(f"None: {sys.getsizeof(None)} bytes") # 16
print(f"True: {sys.getsizeof(True)} bytes") # 28
print(f"int(0): {sys.getsizeof(0)} bytes") # 28
print(f"float: {sys.getsizeof(0.0)} bytes") # 24
print(f"str '': {sys.getsizeof('')} bytes") # 49
print(f"str 'a': {sys.getsizeof('a')} bytes") # 50
print(f"list[]: {sys.getsizeof([])} bytes") # 56
print(f"tuple(): {sys.getsizeof(()) } bytes") # 40
print(f"dict{{}}: {sys.getsizeof({})} bytes") # 64
print(f"set(): {sys.getsizeof(set())} bytes") # 216
# NOTE: getsizeof doesn't count referenced objects!
import sys
lst = [1, 2, 3]
print(f"\nList [1,2,3]: {sys.getsizeof(lst)} bytes") # Only list overhead
# Doesn't include size of elements themselves!
# Total size function
def total_size(obj, seen=None):
"""Recursively calculate total size of object and all referenced objects"""
if seen is None:
seen = set()
obj_id = id(obj)
if obj_id in seen:
return 0
seen.add(obj_id)
size = sys.getsizeof(obj)
if isinstance(obj, dict):
size += sum(total_size(k, seen) + total_size(v, seen) for k, v in obj.items())
elif isinstance(obj, (list, tuple, set, frozenset)):
size += sum(total_size(item, seen) for item in obj)
return size
data = {"key1": [1, 2, 3, 4, 5], "key2": "hello world", "key3": {"nested": True}}
print(f"\nTotal size of nested dict: {total_size(data)} bytes")
Output
None: 16 bytes
True: 28 bytes
int(0): 28 bytes
float: 24 bytes
str '': 49 bytes
str 'a': 50 bytes
list[]: 56 bytes
tuple(): 40 bytes
dict{}: 64 bytes
set(): 216 bytes
List [1,2,3]: 120 bytes
Total size of nested dict: 654 bytes6. Weak References
Example
import weakref
import gc
class ExpensiveObject:
def __init__(self, name):
self.name = name
print(f"Creating {self.name}")
def __del__(self):
print(f"Deleting {self.name}")
# Strong reference — prevents garbage collection
strong = ExpensiveObject("Strong")
print(f"Strong ref count: {import_sys_getrefcount(strong)}")
# Weak reference — doesn't prevent GC
weak = weakref.ref(strong)
print(f"Weak ref alive: {weak() is not None}")
# Accessing through weak reference
obj = weak()
if obj is not None:
print(f"Object name: {obj.name}")
del obj # Release temporary strong reference
# When strong reference deleted, object is freed
del strong
gc.collect()
print(f"Weak ref alive after del: {weak() is not None}")
# Output: False — object garbage collected
def import_sys_getrefcount(obj):
import sys
return sys.getrefcount(obj) - 1
# WeakValueDictionary — cache that doesn't prevent GC
class Cache:
def __init__(self):
self._cache = weakref.WeakValueDictionary()
def get(self, key):
return self._cache.get(key)
def set(self, key, value):
self._cache[key] = value
cache = Cache()
obj1 = ExpensiveObject("Cached1")
cache.set("obj1", obj1)
print(f"Cache hit: {cache.get('obj1')}")
del obj1 # Object can be GC'd
gc.collect()
print(f"Cache after del: {cache.get('obj1')}") # None — automatically removed!
Output
Creating Strong Strong ref count: 1 Weak ref alive: True Object name: Strong Deleting Strong Weak ref alive after del: False Creating Cached1 Cache hit: <__main__.ExpensiveObject object> Deleting Cached1 Cache after del: None
7. Memory Optimization Techniques
Example
# 1. __slots__ — reduce instance memory
class RegularPoint:
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
class SlottedPoint:
__slots__ = ['x', 'y', 'z'] # Pre-define attributes
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
import sys
rp = RegularPoint(1, 2, 3)
sp = SlottedPoint(1, 2, 3)
print(f"Regular: {sys.getsizeof(rp.__dict__) + sys.getsizeof(rp)} bytes")
print(f"Slotted: {sys.getsizeof(sp)} bytes") # No __dict__!
# 2. Generator vs List — memory comparison
def process_large_data():
n = 10_000_000
# List — all in memory
# data = [x**2 for x in range(n)] # ~300MB!
# Generator — one at a time
gen = (x**2 for x in range(n))
# Process without loading all into memory
total = sum(gen)
return total
# 3. array module — typed arrays
import array
# Regular Python list
py_list = list(range(1000))
arr = array.array('i', range(1000)) # signed int array
print(f"\nPython list: {sys.getsizeof(py_list)} bytes")
print(f"array.array: {sys.getsizeof(arr)} bytes") # Much smaller!
# 4. numpy arrays for numerical data
# import numpy as np
# np_arr = np.arange(1000, dtype=np.int32)
# print(f"NumPy array: {np_arr.nbytes} bytes") # Even smaller!
Output
Regular: 200 bytes Slotted: 56 bytes Python list: 8856 bytes array.array: 4120 bytes
📝 Hindi Explanation
__slots__is a powerful optimization. Regular Python objects have their own__dict__(dictionary) per instance which consumes memory.__slots__replaces the dict with a fixed-size struct, saving 40-50% memory when creating many instances.
8. Memory Leaks — Detection and Prevention
Example
import tracemalloc
import gc
# Common Memory Leak Patterns
# Pattern 1: Unbounded cache
class BadCache:
_cache = {} # Class-level — never freed!
@classmethod
def get_or_compute(cls, key):
if key not in cls._cache:
cls._cache[key] = expensive_computation(key)
return cls._cache[key]
def expensive_computation(key):
return [0] * 1000 # Large object
# This grows forever!
# for i in range(1000000):
# BadCache.get_or_compute(i)
# Fix: Use LRU cache with limit
from functools import lru_cache
@lru_cache(maxsize=1000) # Maximum 1000 items cached
def good_computation(key):
return key * 2
# Pattern 2: Circular references (handled by GC but GC has overhead)
class LeakyClass:
def __init__(self):
self.children = []
for _ in range(10):
child = ChildClass(self) # parent reference
self.children.append(child)
class ChildClass:
def __init__(self, parent):
self.parent = parent # Back-reference creates cycle
# Fix: Use weakref for back references
import weakref
class GoodClass:
def __init__(self):
self.children = []
for _ in range(10):
child = GoodChildClass(self)
self.children.append(child)
class GoodChildClass:
def __init__(self, parent):
self.parent = weakref.ref(parent) # Weak reference!
# Pattern 3: Event handlers not unregistered
class EventEmitter:
def __init__(self):
self._handlers = []
def on(self, handler):
self._handlers.append(handler)
def off(self, handler):
self._handlers.remove(handler) # ALWAYS unregister!
# Pattern 4: Global variables accumulating
_global_registry = [] # This grows if not cleaned
def register(obj):
_global_registry.append(obj)
def unregister(obj):
_global_registry.remove(obj) # Clean up!
9. Memory Profiling Best Practices
Example
import tracemalloc
import linecache
import os
def display_top_memory(snapshot, key_type='lineno', limit=10):
"""Top memory consumers display karo"""
snapshot = snapshot.filter_traces((
tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
tracemalloc.Filter(False, "<unknown>"),
))
top_stats = snapshot.statistics(key_type)
print(f"\nTop {limit} memory consumers:")
for index, stat in enumerate(top_stats[:limit], 1):
frame = stat.traceback[0]
filename = os.sep.join(frame.filename.split(os.sep)[-2:])
print(f"#{index}: {filename}:{frame.lineno} — {stat.size/1024:.1f} KB")
line = linecache.getline(frame.filename, frame.lineno).strip()
if line:
print(f" {line}")
other = top_stats[limit:]
if other:
size = sum(stat.size for stat in other)
print(f"{len(other)} other: {size/1024:.1f} KB")
total = sum(stat.size for stat in top_stats)
print(f"Total allocated: {total/1024:.1f} KB")
# Usage
tracemalloc.start()
# Your code to profile
result = {i: list(range(100)) for i in range(1000)}
snapshot = tracemalloc.take_snapshot()
display_top_memory(snapshot, limit=5)
tracemalloc.stop()
Output
Top 5 memory consumers:
#1: script.py:15 — 820.3 KB
result = {i: list(range(100)) for i in range(1000)}
#2: script.py:15 — 39.1 KB
Total allocated: 862.4 KB10. Object Lifecycle
python example
import gc
class Tracked:
instances = []
def __init__(self, name):
self.name = name
Tracked.instances.append(weakref.ref(self))
print(f"Created: {self.name}")
def __del__(self):
print(f"Destroyed: {self.name}")
import weakref
# Lifecycle demonstration
print("=== Creating objects ===")
a = Tracked("A")
b = Tracked("B")
print("\n=== Creating reference ===")
c = a # Same object as a
print("\n=== Deleting original reference ===")
del a
# a deleted but object still alive (c references it)
print(f"Object A alive: {c.name}")
print("\n=== Deleting last reference ===")
del c
# Now object A is garbage collected
gc.collect()
print("\n=== Deleting B ===")
del b
gc.collect()
print("All objects cleaned up")Output
=== Creating objects === Created: A Created: B === Creating reference === === Deleting original reference === Object A alive: A === Deleting last reference === Destroyed: A === Deleting B === Destroyed: B All objects cleaned up
11. Summary and Cheatsheet
Example
import sys
import gc
import weakref
import tracemalloc
# Memory diagnostics cheatsheet
def memory_diagnostics():
"""Complete memory check"""
# Object size
obj = {"key": [1, 2, 3] * 1000}
print(f"Object size: {sys.getsizeof(obj)} bytes (shallow)")
# Reference count
print(f"Ref count: {sys.getrefcount(obj) - 1}")
# GC stats
print(f"GC counts: {gc.get_count()}") # (gen0, gen1, gen2) objects
print(f"GC thresholds: {gc.get_threshold()}")
# Force collection
collected = gc.collect()
print(f"Collected {collected} objects")
memory_diagnostics()
Output
Object size: 64 bytes (shallow) Ref count: 1 GC counts: (595, 2, 1) GC thresholds: (700, 10, 10) Collected 0 objects
| Tool | Purpose |
|---|---|
sys.getsizeof() | Object size in bytes |
sys.getrefcount() | Reference count |
gc.collect() | Force garbage collection |
gc.get_count() | Generation object counts |
tracemalloc | Memory allocation tracing |
weakref.ref() | Weak references |
__slots__ | Reduce instance memory |
array.array | Typed array (smaller than list) |
Memory Optimization Priority: Use generators > lists, use__slots__for many small objects, useweakreffor caches, profile withtracemallocbefore optimizing.
⚠️ Common Mistakes
❌ Mistake 1: Relying Only on del for Memory Cleanup
Example
# ❌ Wrong — del only removes the reference, memory is not freed immediately
large_data = [i for i in range(10_000_000)]
del large_data # Object can still be alive if another reference exists
# ✅ Right — Ensure no other references exist + force GC if needed
large_data = [i for i in range(10_000_000)]
large_data = None # Reassign to None
import gc
gc.collect() # Force cleanup
❌ Mistake 2: Ignoring Circular References
python example
# ❌ Wrong — Circular reference without weakref causes hidden memory leaks
class Parent:
def __init__(self):
self.child = Child(self)
class Child:
def __init__(self, parent):
self.parent = parent # Strong back-reference = circular!
# ✅ Right — Use weakref for back-references
import weakref
class Child:
def __init__(self, parent):
self.parent = weakref.ref(parent) # Weak reference breaks cycle❌ Mistake 3: Using Lists Where Generators Work
Example
# ❌ Wrong — Entire list is loaded in memory
total = sum([x**2 for x in range(10_000_000)]) # ~300MB RAM!
# ✅ Right — Generator lazy evaluation karta hai
total = sum(x**2 for x in range(10_000_000)) # Almost 0 extra memory
❌ Mistake 4: Not Using __slots__ for Data-Heavy Classes
Example
# ❌ Wrong — With millions of instances, `__dict__` wastes a lot of memory
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# ✅ Right — __slots__ saves ~40-50% memory
class Point:
__slots__ = ['x', 'y']
def __init__(self, x, y):
self.x = x
self.y = y
❌ Mistake 5: Unbounded Caches Without Size Limits
Example
# ❌ Wrong — Cache grows forever, eventually eats all RAM
cache = {}
def get_data(key):
if key not in cache:
cache[key] = expensive_function(key)
return cache[key]
# ✅ Right — Use lru_cache with maxsize
from functools import lru_cache
@lru_cache(maxsize=512)
def get_data(key):
return expensive_function(key)
❌ Mistake 6: Confusing sys.getsizeof() with Total Memory
Example
# ❌ Wrong — getsizeof only gives shallow size
import sys
nested = {"data": [1, 2, 3] * 10000}
print(sys.getsizeof(nested)) # Only dict overhead, NOT list content!
# ✅ Right — Recursive function ya pympler use karo for deep size
from pympler import asizeof
print(asizeof.asizeof(nested)) # Actual total memory usage
❌ Mistake 7: Not Profiling Before Optimizing
Example
# ❌ Wrong — Blindly optimize without knowing bottleneck
# "I'll add __slots__ everywhere!" — unnecessary complexity
# ✅ Right — Profile first, then optimize
import tracemalloc
tracemalloc.start()
# ... your code ...
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:5]:
print(stat) # Ab pata chalega kahan memory jaa rahi hai
✅ Key Takeaways
- 🔢 Reference Counting is Python's primary memory management — when count reaches 0, memory is freed immediately
- 🔄 Garbage Collector detects circular references that reference counting misses — it uses a generational algorithm (gen0, gen1, gen2)
- 📦 Small Integer Caching (-5 to 256) and String Interning save memory — this is why
100 is 100evaluates to True - 🛠️ Use
__slots__when creating many instances — eliminating__dict__saves 40-50% memory - 🌊 Prefer Generators over lists when you don't need all data in memory at once — lazy evaluation keeps memory constant
- 🔗 Use
weakreffor caches and back-references — it doesn't prevent the object from being garbage collected - 📊
tracemalloccan be used in production code to find memory leaks — snapshot comparison is the most powerful technique - 💡 Profile first, optimize later — optimization without measurement is premature and makes code unnecessarily complex
- 🧹 Call
gc.collect()manually after critical sections — especially when circular references may have been created - ⚡ Use
array.arrayfor homogeneous numeric data — it uses 4-5x less memory than a Python list
❓ FAQ
Q1: If Python manages memory automatically, why should we understand it manually?
Answer: Yes, Python provides automatic memory management, but in real-world applications, memory leaks, performance bottlenecks, and OOM (Out of Memory) errors require deep understanding of memory internals for diagnosis and resolution.
Q2: Does the del statement actually free memory?
Answer: del only removes the variable's reference — it doesn't delete the object. If the object's reference count reaches 0 after del, then memory is freed. If other references exist, the object remains in memory.
Q3: When does the Garbage Collector run? Can we control it?
Answer: GC runs automatically when generation thresholds are exceeded (default: 700, 10, 10). You can manually trigger with gc.collect(), disable with gc.disable(), or change thresholds with gc.set_threshold().
Q4: What is a circular reference and why is it dangerous?
Answer: A circular reference occurs when two or more objects reference each other (A → B → A). Reference counting cannot free these objects since their count never reaches 0. The garbage collector handles them, but if __del__ is defined, they may end up in gc.garbage (uncollectable).
Q5: When should you use __slots__ and when not?
Answer: Use __slots__ when: (1) Many instances are being created (thousands/millions), (2) Attributes are fixed and dynamic addition isn't needed, (3) Memory optimization is critical. Don't use when: inheritance with dict-based classes, need for dynamic attributes, or prototyping.
Q6: What is the difference between weakref and a normal reference?
Answer: A normal (strong) reference increments the object's reference count — the object won't be garbage collected as long as a strong reference exists. weakref doesn't increment the count — when all strong references disappear, the object is garbage collected even if weak references exist.
Q7: Is memory profiling safe in production?
Answer: tracemalloc is lightweight and can be used in production, but adds ~5-10% performance overhead. Best practice: enable only in development and staging. In production, use it temporarily for debugging specific memory issues.
Q8: How do you detect memory leaks in Python?
Answer: Steps: (1) Start monitoring with tracemalloc.start(), (2) Take snapshots at two time points with take_snapshot(), (3) Use compare_to() to see the difference — growing allocations indicate leaks.
🎯 Interview Questions
Q1: How does memory management work in Python? Explain the role of reference counting and garbage collection.
Answer: Python (CPython) has a dual memory management system:
- Reference Counting (Primary): Every object maintains a count of how many references point to it. When the count reaches 0, memory is freed immediately. This is fast and deterministic.
- Garbage Collector (Secondary): Uses a generational algorithm (3 generations: gen0, gen1, gen2). It specifically detects and cleans up circular references that reference counting cannot handle.
- Memory Pools (pymalloc): An optimized allocator for small objects (≤512 bytes) that reduces system malloc overhead.
Q2: What is a circular reference? How does Python handle it? Explain with an example.
Answer: A circular reference forms when objects reference each other directly or indirectly. Example: a.ref = b and b.ref = a. Reference counting can't free them (count never reaches 0). Python's GC uses a cycle-detecting algorithm that traverses object graphs to find and break these cycles.
Q3: When should gc.collect() be called manually? What are the drawbacks?
Answer: Manual gc.collect() call karein jab:
- After large batch processing where circular references are possible
- Before memory-critical operations to maximize free memory
- In testing/profiling when deterministic behavior is needed
Drawbacks: GC pause can freeze the application (stop-the-world), especially when many objects need scanning. For real-time applications (games, trading systems), disable automatic GC and collect at safe points.
Q4: How does __slots__ optimize memory? Explain the internal mechanism.
Answer: Normal Python objects store data in __dict__ (a dictionary) — this is flexible but allocates a separate dict for every instance. __slots__ replaces the dict with a fixed-size C struct with direct pointers, saving ~40-50% memory per instance.
Q5: Why does sys.getrefcount() return 1 more than the actual count?
Answer: When calling sys.getrefcount(obj), obj is passed as a function argument — this creates a temporary reference. So the returned count is always actual_count + 1.
Q6: How do you identify and fix a memory leak in Python? Explain with a real-world scenario.
Answer: Scenario: A web server's RAM usage gradually increases over time.
Identification Steps:
- Use
tracemallocsnapshot comparison — find growing allocations - Monitor object count over time with
gc.get_objects() - Use
objgraph.show_growth()to see which object types are increasing
Common Causes & Fixes:
- Unbounded caches:
lru_cache(maxsize=N)yaWeakValueDictionaryuse karo - Circular references: Use
weakrefin parent-child relationships - Global accumulators: Periodic cleanup ya bounded collections use karo
- Event listener leaks: Always unsubscribe/deregister when done
Q7: What is generational garbage collection? How many generations does Python have and how do they work?
Answer: Generational GC is based on the "weak generational hypothesis" — most objects die young. Python has 3 generations:
- Generation 0: New objects go here. Threshold 700 — when 700 new allocations happen, gen0 is collected.
- Generation 1: Gen0 survivors are promoted here. Threshold 10 — after 10 gen0 collections, gen1 is collected.
- Generation 2: Long-lived objects. Threshold 10 — after 10 gen1 collections, gen2 is collected.
The young generation is scanned frequently (fast, few objects), the old generation rarely (slow, many objects but stable). View thresholds with gc.get_threshold(), modify with gc.set_threshold().
Q8: Explain the practical use case of the weakref module with code.
Answer: Use Case: Object Cache — Hold objects in cache without extending their lifetime.
Example
import weakref
class ImageCache:
def __init__(self):
self._cache = weakref.WeakValueDictionary()
def get_image(self, path):
img = self._cache.get(path)
if img is None:
img = load_image(path) # Expensive operation
self._cache[path] = img
return img
When other code releases its reference to an image object, it will automatically be removed from the cache — no memory leak! Useful for observer pattern, tree structures (parent-child), and caching.
Q9: What is the difference between tracemalloc and sys.getsizeof()? When should you use which?
Answer:
| Feature | sys.getsizeof() | tracemalloc |
|---|---|---|
| Scope | Single object (shallow) | Entire program allocations |
| Overhead | Zero | 5-10% runtime cost |
| Depth | Only immediate object, not referenced objects | Tracks all allocations with tracebacks |
| Use Case | Quick size check | Memory leak detection, profiling |
| Live tracking | No | Yes (snapshots over time) |
Use sys.getsizeof() for quick checks. Use tracemalloc when you need to detect memory leaks or identify which code lines consume the most memory.
Q10: What is Python's memory pool (pymalloc) and how does it work?
Answer: pymalloc is CPython's small-object allocator optimized for objects ≤512 bytes. Instead of calling system malloc() directly, it maintains memory arenas (256KB chunks) divided into pools (4KB) and blocks. This reduces allocation overhead and fragmentation for the many small objects Python creates.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Memory Management.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, advanced, memory, management
Related Python Master Course Topics
Continue learning this concept
Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.Advanced PythonAdvanced Python DecoratorsMaster advanced Python decorators including decorator factories, class decorators, stacking decorators, functools.wraps, parameterized decorators, and real-world patterns.Advanced PythonAdvanced Python GeneratorsDeep dive into Python generators, yield keyword, generator expressions, send(), throw(), close() methods, pipelines, and coroutines with Hindi explanations.Advanced PythonPython Iterators - Advanced GuideMaster Python iterators with __iter__, __next__, custom iterator classes, infinite iterators, and real-world use cases with detailed examples and Hindi explanations.Advanced PythonPython MultiprocessingMaster Python multiprocessing with Process class, Pool, shared memory, inter-process communication, pipes, queues, and comparison with multithreading.