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 நேரம் உண்மையில் *எங்கு* செல்கிறது என்பதை வெளிப்படுத்துகிறது, எனவே நீங்கள் முக்கியமான code-இன் 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 vs ஒரு 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-ஐ விடுவித்து), pure-Python loops-ஐ பெரிதும் விஞ்சுகின்றன.

## பிற optimization techniques

```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-இன் ஒப்பீட்டு மெதுவான தன்மை performance விழிப்புணர்வை மதிப்புமிக்கதாக ஆக்குகிறது, ஆனால் திறமையான optimization **ஒழுங்குபடுத்தப்பட்டது**: உண்மையான bottleneck-ஐ கண்டறிய முதலில் profile செய்யவும் (cProfile/line_profiler), பிறகு அதிக-நெம்புகோல் fix-ஐ பயன்படுத்தவும் — பொதுவாக சிறந்த algorithm/data structure (O(n) → O(1) lookups), numeric வேலைக்கு C-backed libraries (NumPy/pandas), மீண்டும் செய்யப்படும் computation-க்கு caching, மற்றும் திறமைக்கு built-ins/generators.

இந்த techniques-ஐ — மற்றும் யூகிப்பதற்கு அல்லது முன்கூட்டியே micro-optimize செய்வதற்கு பதிலாக optimize செய்வதற்கு முன் அளவிடும் கொள்கையை — அறிந்துகொள்வது தான், code-ஐ எல்லா இடங்களிலும் தெளிவாக வைத்திருக்கும் அதே வேளையில் முக்கியமான இடங்களில் Python-ஐ போதுமான வேகமாக ஆக்க உங்களை அனுமதிக்கிறது.