yield from et délégation
Composer des générateurs
yield from et délégation 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.
Le problème résolu par yield from
Lorsqu'un générateur veut fournir chaque valeur d'un autre itérable, vous pouvez écrire une boucle manuelle. yield from fait la même chose en une seule ligne.
def manual():
for x in [1, 2, 3]:
yield x
print(list(manual()))Présentation de yield from
yield from iterable délègue le travail à cet itérable et fournit chacune de ses valeurs à tour de rôle. Cette écriture est plus courte et plus claire qu'une boucle de transmission.
def delegate():
yield from [1, 2, 3]
print(list(delegate()))Combiner plusieurs sources
Vous pouvez enchaîner plusieurs instructions yield from pour concaténer des séquences de manière différée.
def chained():
yield from 'ab'
yield from [1, 2]
yield from range(2)
print(list(chained()))Déléguer à un autre générateur
L'itérable délégué peut lui-même être un générateur, ce qui vous permet de composer des générateurs pour en créer de plus grands.
def evens(n):
for i in range(n):
if i % 2 == 0:
yield i
def report(n):
print('evens:')
yield from evens(n)
print(list(report(6)))Aplatir des listes imbriquées
Un usage classique de yield from est l'aplatissement récursif : un générateur qui se délègue à lui-même pour traiter les sous-listes.
def flatten(items):
for item in items:
if isinstance(item, list):
yield from flatten(item)
else:
yield item
print(list(flatten([1, [2, [3, 4]], 5])))yield from ou une boucle
Les deux versions ci-dessous produisent le même résultat. yield from est préférable pour la lisibilité et parce qu'il transmet également des fonctionnalités avancées, comme l'envoi de valeurs et les résultats renvoyés.
def with_loop(src):
for x in src:
yield x
def with_yield_from(src):
yield from src
print(list(with_loop(range(3))))
print(list(with_yield_from(range(3))))Récupérer la valeur renvoyée par un sous-générateur
Lorsqu'un générateur délégué renvoie une valeur avec return, yield from prend cette valeur comme résultat. Les sous-générateurs peuvent ainsi communiquer un résultat.
def counter(n):
count = 0
for i in range(n):
yield i
count += 1
return count
def driver():
total = yield from counter(3)
print('subgen yielded', total, 'items')
list(driver())Créer un pipeline
La délégation permet de diviser facilement un pipeline en étapes nommées et de les composer.
def source():
yield from range(5)
def only_odd(src):
for x in src:
if x % 2 == 1:
yield x
def pipeline():
yield from only_odd(source())
print(list(pipeline()))Déléguer à n'importe quel itérable
yield from fonctionne avec n'importe quel itérable, et pas seulement avec les générateurs : listes, tuples, ensembles, chaînes de caractères, clés de dictionnaire, et bien plus encore.
def mixed():
yield from {1, 2, 3}
yield from ('a', 'b')
result = list(mixed())
print(sorted(str(x) for x in result))Fusionner des générateurs dans l'ordre
Vous pouvez créer un générateur qui parcourt plusieurs sources successivement, ce qui est utile pour réunir des flux.
def concat(*iterables):
for it in iterables:
yield from it
print(list(concat([1, 2], [3], [4, 5])))La lisibilité avant tout
Pour les données profondément imbriquées ou organisées en arbre, yield from permet de garder des générateurs récursifs courts et d'exprimer clairement leur intention.
def walk(tree):
yield tree['name']
for child in tree.get('children', []):
yield from walk(child)
tree = {'name': 'root', 'children': [
{'name': 'a'},
{'name': 'b', 'children': [{'name': 'c'}]}
]}
print(list(walk(tree)))Vérification rapide
Testez votre compréhension de yield from.
Récapitulatif
Vous avez appris yield from et la délégation :
- Cette construction transmet chaque valeur d'un itérable interne.
- Elle compose les générateurs et permet l'aplatissement récursif.
- Elle récupère la valeur renvoyée par le sous-générateur.
- Elle est plus claire qu'une boucle de transmission manuelle.
Prochain cours : la concurrence avec les threads et le traitement multiprocessus.
Questions Fréquemment Posées
La leçon « yield from et délégation » est-elle gratuite ?
Oui — le texte complet de « yield from et délégation » 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 « yield from et délégation » ?
Composer des générateurs 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 « yield from et délégation » ?
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