Python को optimize करना bottleneck खोजने के लिए profiling से शुरू करें — कभी अनुमान न लगाएं। Python की interpreted, dynamic प्रकृति इसे compiled languages की तुलना में धीमा बनाती है, इसलिए optimization बेहतर algorithms, C-backed libraries का लाभ, और hot paths में interpreter overhead को कम करने पर केंद्रित है।
import cProfile
cProfile.run("my_function()") # shows time spent per function call
# line-level profiling (third-party)
python -m cProfile -s cumtime script.py # sort by cumulative time → find hotspots
Profiling बताता है कि कहाँ समय वास्तव में जाता है, इसलिए आप कोड के उस 20% को optimize करते हैं जो महत्वपूर्ण है — अनुमान नहीं।
# ❌ O(n) membership test in a list — slow for large data
if item in my_list: ... # scans every element
# ✅ O(1) membership test in a set/dict
if item in my_set: ... # hash lookup — dramatically faster at scale
Algorithmic सुधार (सही data structure, O(n²) patterns से बचना) आमतौर पर micro-optimizations को कम करते हैं — set lookup बनाम list scan क्रम के परिमाण से तेज़ हो सकते हैं।
# ❌ pure-Python loop over millions of numbers — slow (interpreter overhead per element)
result = [x * 2 for x in big_list]
# ✅ NumPy does it in optimized C, vectorized — far faster
import numpy as np
result = np.array(big_list) * 2
Numeric/data काम के लिए, NumPy/pandas जैसी libraries भारी loops को C में चलाती हैं (GIL को release करते हुए), pure-Python loops से बहुत बेहतर performance देती हैं।
✓ Caching/memoization: @functools.lru_cache for repeated expensive calls
✓ Use built-ins (sum, map, sorted) — implemented in C, faster than manual loops
✓ Use generators for large data (avoid building huge lists in memory)
✓ Use local variables in hot loops (local lookup is faster than global/attribute)
✓ Use __slots__ to reduce per-object memory for many instances
✓ For CPU parallelism: multiprocessing (bypass the GIL)
✓ Last resort: rewrite hotspots in C / Cython / Rust (PyO3), or try PyPy
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n-1) + fib(n-2) # memoized → exponential becomes linear
"Premature optimization is the root of all evil." Write clear code first,
profile to find real bottlenecks, then optimize those specifically.
Python की सापेक्ष slowness performance awareness को मूल्यवान बनाती है, लेकिन प्रभावी optimization अनुशासित है: पहले profile करें (cProfile/line_profiler) true bottleneck खोजने के लिए, फिर highest-leverage fix लागू करें — आमतौर पर बेहतर algorithm/data structure (O(n) → O(1) lookups), numeric काम के लिए C-backed libraries (NumPy/pandas), repeated computation के लिए caching, और efficiency के लिए built-ins/generators।
इन तकनीकों को जानना — और optimization से पहले measure करने का सिद्धांत बजाय अनुमान लगाने या समय से पहले micro-optimize करने के — यही है जो आपको Python को तेज़ enough बनाने देता है जहाँ यह महत्वपूर्ण है जबकि हर जगह code को स्पष्ट रखते हैं।
विस्तृत उत्तरों के साथ IT इंटरव्यू प्रश्नों की एक लाइब्रेरी — जूनियर से सीनियर तक।
दान करें