# Le protocole iterateur : __iter__ retourne un iterateur, __next__ retourne l'element suivant
class CompteurBornes:
    def __init__(self, debut, fin):
        self.actuel = debut
        self.fin = fin

    def __iter__(self):
        return self          # l'objet est son propre iterateur

    def __next__(self):
        if self.actuel >= self.fin:
            raise StopIteration
        valeur = self.actuel
        self.actuel += 1
        return valeur

for n in CompteurBornes(0, 5):
    print(n)

# Ce que fait "for" en coulisses :
it = iter(CompteurBornes(0, 3))
while True:
    try:
        print(next(it))
    except StopIteration:
        break

# --- Generateurs : meme resultat, syntaxe radicalement plus simple ---
def compteur_bornes(debut, fin):
    actuel = debut
    while actuel < fin:
        yield actuel          # suspend l'execution et renvoie une valeur
        actuel += 1

for n in compteur_bornes(0, 5):
    print(n)

# Un generateur est paresseux : rien n'est calcule avant qu'on le demande
def nombres_infinis():
    n = 0
    while True:
        yield n
        n += 1

gen = nombres_infinis()
print(next(gen), next(gen), next(gen))    # 0 1 2 -- consomme a la demande

# Generateur pour traiter un gros fichier sans le charger entierement en memoire
def lire_gros_fichier(chemin):
    with open(chemin, encoding="utf-8") as f:
        for ligne in f:
            yield ligne.strip()

# yield from : deleguer a un sous-generateur ou sous-iterable
def aplatir(structure):
    for element in structure:
        if isinstance(element, list):
            yield from aplatir(element)     # delegation recursive
        else:
            yield element

print(list(aplatir([1, [2, 3, [4, 5]], 6])))    # [1, 2, 3, 4, 5, 6]

# Generateurs bidirectionnels : send() envoie une valeur DANS le generateur
def accumulateur():
    total = 0
    while True:
        valeur = yield total     # yield retourne total, ET recoit la prochaine valeur envoyee
        total += valeur

acc = accumulateur()
next(acc)                   # "amorcer" le generateur (avance jusqu'au premier yield)
print(acc.send(10))          # 10
print(acc.send(5))            # 15
print(acc.send(20))            # 35

# close() et gestion des exceptions dans un generateur
def generateur_avec_nettoyage():
    try:
        yield 1
        yield 2
    finally:
        print("Nettoyage du generateur execute")

g = generateur_avec_nettoyage()
next(g)
g.close()          # declenche le "finally" a l'interieur du generateur

# itertools : boite a outils pour manipuler des iterateurs efficacement
import itertools

print(list(itertools.islice(nombres_infinis(), 5)))         # prend les 5 premiers
print(list(itertools.chain([1, 2], [3, 4])))                 # concatene sans copier
print(list(itertools.combinations([1, 2, 3], 2)))              # combinaisons
print(list(itertools.groupby("aaabbbcc")))                      # regroupe les elements consecutifs
print(list(itertools.accumulate([1, 2, 3, 4])))                  # sommes cumulees

# Comparaison memoire : generateur vs liste sur un grand volume
import sys
liste = [x for x in range(100_000)]
generateur = (x for x in range(100_000))
print(sys.getsizeof(liste), "octets pour la liste")
print(sys.getsizeof(generateur), "octets pour le generateur")   # bien plus petit