आप Python performance को profile और optimize कैसे करते हैं?

Question

Accepted Answer

Python को optimize करना **bottleneck खोजने के लिए profiling** से शुरू करें — कभी अनुमान न लगाएं। Python की interpreted, dynamic प्रकृति इसे compiled languages की तुलना में धीमा बनाती है, इसलिए optimization बेहतर algorithms, C-backed libraries का लाभ, और hot paths में interpreter overhead को कम करने पर केंद्रित है।

## पहले Profile करें

```python
import cProfile
cProfile.run("my_function()")   # shows time spent per function call

# line-level profiling (third-party)
# pip install line_profiler → @profile decorator → kernprof -l -v script.py
```

```bash
python -m cProfile -s cumtime script.py   # sort by cumulative time → find hotspots
```

Profiling बताता है कि *कहाँ* समय वास्तव में जाता है, इसलिए आप कोड के उस 20% को optimize करते हैं जो महत्वपूर्ण है — अनुमान नहीं।

## सबसे बड़ी जीत: बेहतर algorithms और data structures

```python
# ❌ 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 क्रम के परिमाण से तेज़ हो सकते हैं।

## भारी numeric काम के लिए C-backed libraries का उपयोग करें

```python
# ❌ 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 देती हैं।

## अन्य optimization तकनीकें

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

## Caching का उदाहरण

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

## समय से पहले optimize न करें

```text
"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 को स्पष्ट रखते हैं।