import sys
import gc

# --- Comptage de references : le mecanisme PRINCIPAL de gestion memoire ---
a = [1, 2, 3]
print(sys.getrefcount(a))       # >= 2 (la variable "a" + l'argument temporaire de getrefcount)

b = a                            # nouvelle reference vers le MEME objet
print(sys.getrefcount(a))        # incremente de 1

del b                             # decremente le compteur de references
# quand le compteur atteint 0, l'objet est immediatement desalloue (pas d'attente du GC)

# --- Le garbage collector generationnel : ne gere QUE les cycles de references ---
class Noeud:
    def __init__(self):
        self.suivant = None

n1 = Noeud()
n2 = Noeud()
n1.suivant = n2
n2.suivant = n1          # cycle : n1 reference n2 qui reference n1

# Le comptage de references seul ne peut PAS liberer ce cycle (compteurs jamais a 0)
del n1, n2
# C'est le GC generationnel (gc module) qui detecte et casse ce genre de cycle
gc.collect()                # force une collecte (normalement automatique)
print(gc.get_stats())        # statistiques par generation (0, 1, 2)

# 3 generations : gen0 (jeunes objets, collectee souvent), gen1, gen2 (vieux objets, rarement)
print(gc.get_threshold())    # seuils de declenchement par generation

# --- Interning : reutilisation d'objets immuables pour economiser la memoire ---
a = 256
b = 256
print(a is b)          # True : les petits entiers [-5, 256] sont "internes" (cache par CPython)

x = 257
y = 257
print(x is y)           # peut etre False (hors du cache des petits entiers), dependant du contexte

s1 = "hello"
s2 = "hello"
print(s1 is s2)          # True : les litteraux de chaine "identifier-like" sont internes

s3 = "hello world!"
s4 = "hello world!"
print(s3 is s4)           # resultat variable : depend du compilateur/contexte (a ne jamais presupposer)

# sys.intern() : forcer l'interning explicitement (utile pour de grosses quantites de cles repetees)
s5 = sys.intern("un_identifiant_repete_des_milliers_de_fois")

# --- Mutable default et identite : verifier avec is, pas == ---
print(1 == 1.0)         # True : egalite de valeur
print(1 is 1.0)           # False : types differents, objets differents

# --- Le layout memoire d'un objet Python (simplifie) ---
# Chaque objet Python porte : ob_refcnt (compteur de refs), ob_type (pointeur vers son type),
# puis les donnees specifiques au type. C'est pourquoi meme un int occupe plus que 4/8 octets :
print(sys.getsizeof(0))          # 28 octets (CPython 3.x, overhead de l'objet)
print(sys.getsizeof(10**100))     # bien plus gros : les grands entiers sont des tableaux de "digits"

# --- id() : adresse memoire (CPython) utilisee comme identite unique ---
x = object()
print(id(x))               # identifiant unique pendant la duree de vie de l'objet

# --- weakref : reference qui n'empeche PAS la collecte de l'objet ---
import weakref

class Cache:
    pass

obj = Cache()
ref_faible = weakref.ref(obj)
print(ref_faible())        # l'objet, tant qu'il existe encore
del obj
print(ref_faible())         # None : l'objet a ete collecte, la reference faible ne l'a pas retenu

# Cas d'usage typique : caches qui ne doivent pas empecher le GC
class RegistreObjets:
    def __init__(self):
        self._objets = weakref.WeakValueDictionary()   # ne retient pas les objets artificiellement

# --- GIL revisite : pourquoi il existe (simplifie le comptage de references) ---
# Sans GIL, chaque incrementation/decrementation de ob_refcnt devrait etre atomique
# (verrouillage fin), ce qui degraderait les performances mono-thread. C'est le compromis
# historique de CPython. Le projet "no-GIL" (PEP 703, Python 3.13+ en optionnel) explore
# une alternative avec des couts differents.