0Pricing
Python Academy · Leçon

Le mot-clé yield

Écrivez des fonctions génératrices avec yield pour créer des itérateurs personnalisés.

Le mot-clé yield est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Introduction

Les fonctions génératrices utilisent yield pour produire une suite de valeurs de manière paresseuse, en suspendant l’exécution entre chaque yield.

Qu’est-ce que yield ?

Une fonction contenant yield est une fonction génératrice. Chaque appel à next() reprend l’exécution à partir du dernier yield.
def count_up(n):
    for i in range(n):
        yield i
for x in count_up(3):
    print(x)

Fonction génératrice ou fonction classique

L’appel d’une fonction génératrice renvoie un objet générateur : il n’exécute encore aucun code. Le code s’exécute au fil de l’itération.
def gen():
    print('start')
    yield 1
    print('middle')
    yield 2
g = gen()  # no print yet
print(next(g))  # 'start', then 1

Générateur infini

def naturals(n=0): while True: yield n; n+=1 est une suite infinie. Utilisez-la avec islice ou break.
def naturals(n=0):
    while True:
        yield n
        n += 1
import itertools
print(list(itertools.islice(naturals(), 5)))

yield from

yield from sub_gen() délègue l’exécution à un sous-générateur en transmettant toutes les valeurs. Cela équivaut à for x in sub: yield x.
def chain(*iters):
    for it in iters:
        yield from it
print(list(chain([1,2], [3,4], [5])))

Envoyer des valeurs avec send()

gen.send(value) reprend le générateur et lui transmet une valeur qui devient le résultat de l’expression yield.
def accumulator():
    total = 0
    while True:
        n = yield total
        if n is None: break
        total += n
g = accumulator()
next(g)  # prime
print(g.send(10))
print(g.send(5))

État d’un générateur

Un générateur se met en pause à chaque yield et conserve ses variables locales entre les appels : c’est une coroutine naturelle.
def stateful():
    seen = set()
    while True:
        item = yield
        seen.add(item)
        yield len(seen)
g = stateful()
next(g); g.send('a'); print(next(g)); g.send('b'); print(next(g))

Fermer un générateur

gen.close() déclenche GeneratorExit à l’intérieur du générateur. Utilisez try/finally dans le générateur pour effectuer le nettoyage.
def resource_gen():
    try:
        while True:
            yield
    finally:
        print('cleaned up')
g = resource_gen()
next(g)
g.close()

StopIteration et return

return value dans un générateur définit l’attribut value de l’exception StopIteration. yield from l’utilise pour récupérer cette valeur.
def gen_with_return():
    yield 1
    yield 2
    return 'done'
g = gen_with_return()
try:
    while True: print(next(g))
except StopIteration as e:
    print('returned:', e.value)

Générateur de Fibonacci

Les générateurs sont particulièrement adaptés aux suites mathématiques infinies : yield a; a, b = b, a+b
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
import itertools
print(list(itertools.islice(fibonacci(), 10)))

Générateurs ou classes avec __iter__

Les générateurs sont plus simples que l’écriture d’une classe avec __iter__ et __next__. Utilisez-les pour les suites simples.
# Generator is simpler than:
# class Counter:
#     def __iter__(self): return self
#     def __next__(self): ...
print('generators simplify iterators')

Vérification rapide

Que fait yield from sub() dans une fonction génératrice ?

Récapitulatif

`yield` met en pause une fonction génératrice. Les fonctions génératrices renvoient un objet générateur. `yield from` délègue l’exécution à des sous-générateurs. `send()` transmet des valeurs. `close()` déclenche le nettoyage.

Continuez

Excellent ! Continuez avec la leçon suivante pour approfondir vos compétences.

Questions Fréquemment Posées

La leçon « Le mot-clé yield » est-elle gratuite ?

Oui — le texte complet de « Le mot-clé yield » 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 « Le mot-clé yield » ?

Écrivez des fonctions génératrices avec yield pour créer des itérateurs personnalisés. 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 4 sur 4.

Combien de temps prend la leçon « Le mot-clé yield » ?

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

  1. Compréhensions de listes
  2. Compréhensions d’ensembles et de dictionnaires
  3. Expressions génératrices
  4. Le mot-clé yield
← Retour à Python Academy