Comment la fonction « envoyer » de Python permet-elle une communication bidirectionnelle avec les générateurs ?

Comprendre le rôle de « envoyer » dans les générateurs Python

Le mot-clé « yield » en Python permet aux générateurs de générer des valeurs, permettant à l'appelant pour parcourir la sortie du générateur. Cependant, les générateurs fournissent également une fonction complémentaire appelée "send", qui offre une couche de contrôle supplémentaire.

La fonction "send", documentée sous le nom "generator.send(value)", permet à l'appelant de saisir un valeur dans un générateur qui vient de céder. Cette valeur d'entrée devient le résultat de l'expression de rendement actuelle. Il est important de noter qu'elle est distincte de la valeur d'argument transmise à la fonction génératrice lors de sa première instanciation.

Pour illustrer, considérons le générateur suivant :

<code class="python">def double_inputs():
    while True:
        x = yield  # Pauses the generator
        yield x * 2  # Returns the doubled value</code>

Initialement, appeler next(gen) sur l'objet générateur, gen avance son exécution jusqu'à la première instruction rendement. À ce stade, nous pouvons utiliser la fonction « envoyer » pour saisir une valeur. Par exemple, l'exécution de gen.send(10) définira x sur 10 et reprendra le générateur, ce qui lui donnera 20.

<code class="python">gen = double_inputs()
next(gen)       # Pause at first yield
gen.send(10)    # Send input value of 10
20</code>

Ce processus peut être répété, permettant d'envoyer plusieurs entrées au générateur. . Il convient de noter que cette capacité ne peut pas être obtenue uniquement via le mécanisme « rendement ».

Une application pratique de la fonction « envoyer » se situe dans le contexte du décorateur @defer.inlineCallbacks de Twisted. Il permet de créer des fonctions qui ressemblent à des fonctions procédurales standards mais peuvent effectuer des calculs et des rappels asynchrones.

Par exemple, en utilisant la fonction "envoyer", le code suivant peut être modernisé :

<code class="python"># Old approach with callbacks
def doStuff():
    returnDeferred = defer.Deferred()
    def gotNextResult(nextResult):
        returnDeferred.callback(nextResult / 10)
    def gotResult(result):
        takesTenSeconds(result * 10).addCallback(gotNextResult)
    takesTwoSeconds().addCallback(gotResult)
    return returnDeferred

# New approach using @defer.inlineCallbacks
@defer.inlineCallbacks
def doStuff():
    result = yield takesTwoSeconds()
    nextResult = yield takesTenSeconds(result * 10)
    defer.returnValue(nextResult / 10)</code>

En comprenant l'objectif et les capacités de la fonction « envoyer », les développeurs peuvent libérer le potentiel des générateurs dans un plus large éventail de scénarios de programmation.

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!