import cProfile
import pstats
import timeit
from functools import lru_cache

# --- cProfile : profiler l'ensemble d'un programme ---
def fonction_lente():
    total = 0
    for i in range(1_000_000):
        total += i ** 2
    return total

def fonction_rapide():
    return sum(i ** 2 for i in range(1_000_000))

def programme():
    fonction_lente()
    fonction_rapide()

cProfile.run("programme()", "profile_output.prof")

stats = pstats.Stats("profile_output.prof")
stats.sort_stats("cumulative").print_stats(10)     # top 10 fonctions les plus couteuses

# --- timeit : mesurer precisement un micro-benchmark ---
temps_boucle = timeit.timeit(
    "sum(i**2 for i in range(1000))", number=10_000
)
temps_liste = timeit.timeit(
    "sum([i**2 for i in range(1000)])", number=10_000
)
print(f"Generateur : {temps_boucle:.3f}s, Liste : {temps_liste:.3f}s")

# --- Optimisations idiomatiques courantes ---

# 1. Concatenation de chaines : eviter += en boucle (O(n^2)), preferer join
def mauvais_join(mots):
    resultat = ""
    for mot in mots:
        resultat += mot + " "        # cree une nouvelle chaine a chaque iteration
    return resultat

def bon_join(mots):
    return " ".join(mots)             # une seule allocation

# 2. Recherche : set/dict (O(1)) plutot que list (O(n)) pour un "in" repete
def mauvais_recherche(items, valeurs_recherchees):
    return [v for v in valeurs_recherchees if v in items]        # items est une list

def bon_recherche(items, valeurs_recherchees):
    items_set = set(items)
    return [v for v in valeurs_recherchees if v in items_set]     # O(1) par recherche

# 3. Memoisation avec lru_cache pour eviter les recalculs
@lru_cache(maxsize=None)
def fibonacci(n):
    return n if n < 2 else fibonacci(n - 1) + fibonacci(n - 2)

# 4. Utiliser les fonctions natives (implementees en C, bien plus rapides)
donnees = list(range(100_000))
somme_native = sum(donnees)                        # rapide (C)
somme_manuelle = 0
for x in donnees:
    somme_manuelle += x                              # plus lent (bytecode Python)

# 5. Local variable caching dans les boucles chaudes
class Traitement:
    def methode_lente(self, donnees):
        resultat = []
        for x in donnees:
            resultat.append(self.transformer(x))      # attribut lookup a chaque iteration
        return resultat

    def methode_rapide(self, donnees):
        transformer = self.transformer                 # cache la reference localement
        resultat = []
        for x in donnees:
            resultat.append(transformer(x))
        return resultat

    def transformer(self, x):
        return x * 2

# --- Profiling memoire ---
import tracemalloc

tracemalloc.start()
grosse_liste = [i for i in range(1_000_000)]
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("lineno")
for stat in top_stats[:3]:
    print(stat)
tracemalloc.stop()

# --- Quand aller au-dela de Python pur ---
# NumPy : vectorisation, delegue les boucles a du code C optimise (BLAS/LAPACK)
# import numpy as np
# array = np.arange(1_000_000)
# resultat = array ** 2          # bien plus rapide qu'une comprehension pure Python

# Cython : compiler un sous-ensemble de Python (avec annotations de type) vers du C
# fichier .pyx :
# def fibonacci_cython(int n):
#     cdef int a = 0, b = 1, i
#     for i in range(n):
#         a, b = b, a + b
#     return a

# PyPy : implementation alternative avec JIT, souvent 4-10x plus rapide sur du code CPU-bound pur