Libérer la puissance de la communication bidirectionnelle : qu'apporte 'yield from' à Python 3.3 ?

La puissance du « rendement de » dans Python 3.3

Python 3.3 a introduit la syntaxe « rendement de », apportant une approche révolutionnaire à la programmation avec des générateurs et des coroutines. Bien que similaire aux générateurs classiques, le rendement de établit une connexion directe entre l'appelant et le sous-générateur, permettant une communication bidirectionnelle transparente.

1. Lecture de données à partir d'un générateur

Le cas d'utilisation le plus simple concerne la lecture de données à partir d'un générateur. En utilisant rendement from, nous pouvons recevoir des valeurs du générateur avec une syntaxe simplifiée, similaire à une boucle régulière.

Par exemple, considérons un générateur qui simule la lecture de données :

<code class="python">def reader():
    for i in range(4):
        yield '<< %s' % i

Utilisation rendement, nous pouvons parcourir les données comme suit :

<code class="python">def reader_wrapper(g):
    yield from g

wrap = reader_wrapper(reader())
for i in wrap:
    print(i)

2. Envoi de données à une coroutine

rendement brillant lors de l'envoi de données à une coroutine. Avec Yield from, les données envoyées au wrapper sont transmises de manière transparente à la coroutine.

Considérons une coroutine qui écrit des données vers une destination spécifique :

<code class="python">def writer():
    while True:
        w = (yield)
        print('>> ', w)</code>

Pour envoyer des données à cet écrivain en utilisant Yield de :

<code class="python">def writer_wrapper(coro):
    coro.send(None)
    while True:
        try:
            x = (yield)
            coro.send(x)
        except StopIteration:
            pass

w = writer()
wrap = writer_wrapper(w)
wrap.send(None)
for i in range(4):
    wrap.send(i)</code>

3. Gestion des exceptions

yield from gère les exceptions de manière transparente. Les exceptions déclenchées dans le sous-générateur sont propagées à l'appelant. De plus, une exception envoyée au wrapper peut être lancée dans le sous-générateur.

Par exemple, dans notre coroutine d'écriture :

<code class="python">def writer():
    while True:
        try:
            w = (yield)
        except SpamException:
            print('***')
        else:
            print('>> ', w)</code>

En utilisant le rendement de, nous pouvons gérer les exceptions comme suit :

<code class="python">def writer_wrapper(coro):
    yield from coro</code>

4. Le pouvoir de la communication bidirectionnelle

L'aspect clé du rendement est la connexion bidirectionnelle qu'il établit. Il permet non seulement d'envoyer des données à la coroutine, mais également de propager les exceptions et de renvoyer la valeur finale du sous-générateur.

Conclusion

yield from est un outil puissant qui a révolutionné les générateurs et les coroutines en Python. Il simplifie la communication bidirectionnelle, gère les exceptions de manière transparente et permet des solutions élégantes. Ses cas d'utilisation s'étendent bien au-delà des exemples discutés, ce qui en fait un composant essentiel de nombreuses tâches de programmation avancées en Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!