Conas a dhéanann tú próifíliú agus barruchtú feidhmíochta Python?

Question

Accepted Answer

Tosú ar bharruchtú Python le **próifíliú chun an bottleneck fíor a aimsiú** — ná bí ag gealadh. Toisc gur teanga léite agus dinimiciúil a bhí i Python, bíonn sé níos moille ná teangacha comhthiomsaithe, mar sin díríonn an barrúchú ar algartam níos fearr, leabharlanna atá bheith i gcúl C a bhaint úsáide, agus ísliú ar chosaing an léitheora i spréacharnach te.

## Próifíl ar dtús

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

Noilsíonn próifíliú *cá háit* go raibh am i ndáiríre ag dul, agus sin an fáth go bhfuil tú ag barruchtú an 20% de chód atá ábhartha — ní drochdhréachtanna randamach.

## An bhuairt is mó: algartam agus struchtúir sonraí níos fearr

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

Soilsiú algartaimíochta (an struchtúr sonraí ceart, O(n²) patrúin a sheachaint) go hiondúil níos mó ná beag-bharruchtúintí — is féidir le cuardach tacar i gcomparáid le scan liosta a bheith níos tapa ó thaobh ór.

## Úsáid leabharlanna atá bheith i gcúl C do obair uimhríochta trom

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

Do obair uimhríochta/sonraí, rith leabharlanna cosúil le **NumPy/pandas** an lúp trom i C (ag scaoileadh an GIL), i bhfad níos fearr ná lúp glan-Python.

## Teicníochtaí barruchtaithe eile

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

## Sampla foluain

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

## Ná déan barruchtú go tobann

```text
"Premature optimization is the root of all evil." Write clear code first,
profile to find real bottlenecks, then optimize those specifically.
```

## Cén fáth a bhfuil sé tábhachtach

Go raibh moilleacht choibhneasta Python tógáil léimneachta feidhmíochta luachmhar, ach tá barruchtú éifeachtach **socraithe**: próifíl ar dtús (cProfile/line_profiler) chun an bottleneck fíor a aimsiú, agus ansin feidhmigh an leigheas is airde-bhabhta — ar an iomlán algartam níos fearr/struchtúr sonraí (O(n) → O(1) cuardach), leabharlanna atá bheith i gcúl C (NumPy/pandas) do obair uimhríochta, foluain do thuairimí athdhéanta, agus built-ins/gineadóirí don éifeachtúlacht.

Má bhíonn a fhios agat na teicníochtaí seo — agus an prionsabal a thomhas sula ndéanann tú barruchtú seachas a bheith ag gealadh nó barruchtú tobann — is é sin a ligeann duit Python a dhéanamh gasta go leor i gceannanna ina bhfuil sé ábhartha agus an cód a choimeád geal in gach áit eile.