Comment profilez-vous et optimisez-vous les performances de Python ?

Question

Accepted Answer

L'optimisation de Python commence par **le profilage pour trouver le vrai goulot d'étranglement** — ne devinez jamais. La nature interprétée et dynamique de Python la rend plus lente que les langages compilés, l'optimisation se concentre donc sur de meilleurs algorithmes, l'exploitation de bibliothèques C et la réduction de la surcharge de l'interpréteur dans les chemins critiques.

## Profilez d'abord

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

Le profilage révèle *où* le temps s'écoule réellement, vous optimisez donc les 20% du code qui importent — pas des suppositions aléatoires.

## Le plus grand gain : meilleurs algorithmes et structures de données

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

Les améliorations algorithmiques (bonne structure de données, éviter les motifs O(n²)) dépassent généralement les micro-optimisations — une recherche d'ensemble vs un balayage de liste peut être des ordres de grandeur plus rapide.

## Utilisez les bibliothèques C pour le travail numérique lourd

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

Pour le travail numérique/données, les bibliothèques comme **NumPy/pandas** exécutent les boucles lourdes en C (libèrent le GIL), surpassant largement les boucles Python pures.

## Autres techniques d'optimisation

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

## Exemple de mise en cache

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

## Ne pas optimiser prématurément

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

## Pourquoi c'est important

La lenteur relative de Python rend la sensibilité aux performances précieuse, mais l'optimisation efficace est **disciplinée** : profilez d'abord (cProfile/line_profiler) pour trouver le vrai goulot d'étranglement, puis appliquez la correction à plus fort impact — généralement un meilleur algorithme/structure de données (O(n) → O(1) lookups), des bibliothèques C (NumPy/pandas) pour le travail numérique, la mise en cache pour les calculs répétés et les built-ins/générateurs pour l'efficacité.

Connaître ces techniques — et le principe de mesurer avant d'optimiser plutôt que de deviner ou d'optimiser prématurément de façon fine — c'est ce qui vous permet de rendre Python assez rapide où cela compte tout en gardant le code clair ailleurs.