Fonctions génératrices
Produire des valeurs de manière différée avec yield
Fonctions génératrices est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.
Qu'est-ce qu'un générateur ?
Une fonction génératrice ressemble à une fonction ordinaire, mais utilise yield à la place de return, ou en complément de celui-ci. Son appel n'exécute pas son corps ; il renvoie un objet générateur, qui est un itérateur.
def gen():
yield 1
yield 2
yield 3
g = gen()
print(type(g).__name__)
print(list(g))yield met l'exécution en pause
Chaque fois que vous appelez next(), la fonction s'exécute jusqu'à rencontrer un yield, renvoie cette valeur, puis fige son état. L'appel suivant reprend juste après le yield.
def steps():
print('start')
yield 'a'
print('resumed')
yield 'b'
g = steps()
print(next(g))
print(next(g))Parcourir un générateur
Comme un générateur est un itérateur, une boucle for le parcourt automatiquement et s'arrête lorsque la fonction se termine (ce qui déclenche StopIteration en interne).
def countdown(n):
while n > 0:
yield n
n -= 1
for x in countdown(4):
print(x)Évaluation différée
Les générateurs sont paresseux : les valeurs ne sont produites que lorsqu'elles sont demandées. Vous pouvez ainsi représenter des séquences très grandes ou infinies sans utiliser beaucoup de mémoire.
def naturals():
n = 1
while True:
yield n
n += 1
g = naturals()
print(next(g), next(g), next(g))L'état entre les yield
Les variables locales conservent leur valeur entre les points yield. Un générateur se souvient naturellement de l'endroit où il s'est arrêté, sans avoir besoin de gérer manuellement un index.
def fib():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
g = fib()
print([next(g) for _ in range(7)])Générateurs ou création d'une liste
Une fonction ordinaire crée et renvoie toute la liste en une seule fois. Un générateur fournit les éléments à la demande. Utilisez un générateur lorsque la séquence est volumineuse ou que vous pourriez vous arrêter avant la fin.
def squares_list(n):
result = []
for i in range(n):
result.append(i * i)
return result
def squares_gen(n):
for i in range(n):
yield i * i
print(squares_list(5))
print(list(squares_gen(5)))S'arrêter avant la fin
Comme la production est différée, vous pouvez sortir d'une boucle : le générateur ne calculera tout simplement jamais le reste.
def naturals():
n = 1
while True:
print('producing', n)
yield n
n += 1
for x in naturals():
if x > 3:
break
print('got', x)return dans un générateur
Un return sans valeur dans un générateur met simplement fin à celui-ci (en déclenchant StopIteration). Toute valeur renvoyée devient l'attribut value de l'exception, que la plupart des boucles ignorent.
def up_to(stop):
i = 0
while True:
if i >= stop:
return
yield i
i += 1
print(list(up_to(4)))Les générateurs ne s'utilisent qu'une fois
Comme tous les itérateurs, un générateur est consommé une seule fois. Une fois épuisé, il ne fournit plus rien. Appelez de nouveau la fonction pour obtenir un nouveau générateur.
def gen():
yield 1
yield 2
g = gen()
print(list(g))
print(list(g))
print(list(gen()))Filtrer avec des générateurs
Les générateurs permettent de créer des pipelines de données clairs. Ici, nous ne fournissons que les nombres pairs, un à la fois.
def evens(numbers):
for n in numbers:
if n % 2 == 0:
yield n
print(list(evens(range(10))))Enchaîner des générateurs
Un générateur peut consommer un autre générateur et créer un pipeline en plusieurs étapes, où chaque étape est paresseuse.
def numbers(n):
for i in range(n):
yield i
def doubled(src):
for x in src:
yield x * 2
print(list(doubled(numbers(5))))Vérification rapide
Testez votre compréhension des fonctions génératrices.
Récapitulatif
Vous avez appris les fonctions génératrices :
yieldmet l'exécution en pause puis la reprend, tout en conservant l'état local.- L'appel de la fonction renvoie un objet générateur paresseux.
- Elles économisent la mémoire et sont particulièrement adaptées aux pipelines et aux flux infinis.
- Elles ne s'utilisent qu'une seule fois, comme n'importe quel itérateur.
Ensuite : les expressions génératrices, encore plus compactes.
Questions Fréquemment Posées
La leçon « Fonctions génératrices » est-elle gratuite ?
Oui — le texte complet de « Fonctions génératrices » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Fonctions génératrices » ?
Produire des valeurs de manière différée avec yield Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Python Academy ?
Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Fonctions génératrices » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?
Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Le protocole des itérateurs
- Fonctions génératrices
- Expressions génératrices
- yield from et délégation