Appel de méthode asynchrone en Python ?

Question

Je me demandais si il y a n’importe quelle bibliothèque pour les appels de méthode asynchrone en Python. Ce serait formidable si vous pouviez faire quelque chose comme

Ou d’appeler une routine non-async asynchrone

Il serait bon d’avoir une stratégie plus affinée en natif dans le noyau de la langue. Il considérait ?

Answer 1

Qu’en est-il quelque chose comme

Voir les docs à https://docs.python.org/2/library/threading.html#module-threading pour plus de détails ; Ce code devrait fonctionner pour python 3 aussi bien.

Answer 2

Vous pouvez utiliser le module de multitraitement ajouté dans Python 2.6. Vous pouvez utiliser des pools de processus et puis obtenir des résultats de façon asynchrone avec :

Par exemple :

Ce n’est qu’un autre. Ce module fournit beaucoup d’installations pour réaliser ce que vous voulez. Aussi, il sera vraiment facile à faire un décorateur de cela.

Answer 3

Il n’est pas dans le noyau de la langue, mais une bibliothèque très mature qui fait ce que vous voulez est tordu. Il introduit l’objet de paiement différé, que vous pouvez fixer des rappels ou des gestionnaires d’erreurs (« errbacks ») à. Un paiement différé est essentiellement une « promesse » qu’une fonction aura un résultat finalement.

Answer 4

Vous pouvez mettre en œuvre un décorateur pour faire de vos fonctions asynchrones, même si c'est un peu délicat. L' multiprocessing module est plein de bizarreries et apparemment arbitraire des restrictions – une raison de plus pour encapsuler derrière une interface conviviale.

from inspect import getmodule
from multiprocessing import Pool


def async(decorated):
    r'''Wraps a top-level function around an asynchronous dispatcher.

        when the decorated function is called, a task is submitted to a
        process pool, and a future object is returned, providing access to an
        eventual return value.

        The future object has a blocking get() method to access the task
        result: it will return immediately if the job is already done, or block
        until it completes.

        This decorator won't work on methods, due to limitations in Python's
        pickling machinery (in principle methods could be made pickleable, but
        good luck on that).
    '''
    # Keeps the original function visible from the module global namespace,
    # under a name consistent to its __name__ attribute. This is necessary for
    # the multiprocessing pickling machinery to work properly.
    module = getmodule(decorated)
    decorated.__name__ += '_original'
    setattr(module, decorated.__name__, decorated)

    def send(*args, **opts):
        return async.pool.apply_async(decorated, args, opts)

    return send

Le code ci-dessous illustre l'utilisation de la décoratrice:

@async
def printsum(uid, values):
    summed = 0
    for value in values:
        summed += value

    print("Worker %i: sum value is %i" % (uid, summed))

    return (uid, summed)


if __name__ == '__main__':
    from random import sample

    # The process pool must be created inside __main__.
    async.pool = Pool(4)

    p = range(0, 1000)
    results = []
    for i in range(4):
        result = printsum(i, sample(p, 100))
        results.append(result)

    for result in results:
        print("Worker %i: sum value is %i" % result.get())

Dans un cas, je ellaborate un peu plus sur le décorateur, de la fourniture de certains moyen de le désactiver pour le débogage (tout en gardant l'avenir de l'interface en place), ou peut-être une installation de traitement des exceptions; mais je pense que cela démontre le principe assez bien.

Answer 5

Vous pouvez utiliser eventlet. Il vous permet d’écrire ce qui semble être code synchrone, mais faites-le fonctionner de façon asynchrone sur le réseau.

Voici un exemple d’un robot super minime :