Python Demande: N'attendez pas pour demander à terminer

En Bash, il est possible d'exécuter une commande en arrière-plan en ajoutant &. Comment puis-je le faire en Python?

while True:
    data = raw_input('Enter something: ') 
    requests.post(url, data=data) # Don't wait for it to finish.
    print('Sending POST request...') # This should appear immediately.
Contrairement au CPU des problèmes de concurrence, en Python, cela pourrait être résolu avec un thread séparé, ou l'utilisation de multiprocessing.dummy pour un pool de threads.

OriginalL'auteur octosquidopus | 2014-11-19

  1. 17

    - Je utiliser multiprocessing.dummy.Pool. J'ai créer un singleton pool de threads au niveau du module, et ensuite utiliser pool.apply_async(requests.get, [params]) pour lancer la tâche.

    Cette commande me donne un avenir qui, je peux l'ajouter à une liste avec d'autres futures indéfiniment jusqu'à ce que je voudrais récupérer la totalité ou certains des résultats.

    multiprocessing.dummy.Pool est, contre toute logique et de la raison, un pool de THREADS et non pas un processus de piscine.

    Exemple (travaux en Python 2 et 3, tant que la demande est installé):

    from multiprocessing.dummy import Pool

import requests

pool = Pool(10) # Creates a pool with ten threads; more threads = more concurrency.
                # "pool" is a module attribute; you can be sure there will only
                # be one of them in your application
                # as modules are cached after initialization.

if __name__ == '__main__':
    futures = []
    for x in range(10):
        futures.append(pool.apply_async(requests.get, ['http://example.com/']))
    # futures is now a list of 10 futures.
    for future in futures:
        print(future.get()) # For each future, wait until the request is
                            # finished and then print the response object.

    Les requêtes sont exécutées simultanément, de sorte que l'exécution de l'ensemble des dix de ces demandes ne doivent pas prendre plus que la plus longue. Cette stratégie permettra d'utiliser un seul cœur de PROCESSEUR, mais cela ne devrait pas être un problème parce que presque tous le temps sera passé à attendre pour les I/O.

    Votre solution semble intéressante, mais aussi à confusion. Qu'est ce qu'un avenir? Quel est le niveau de module? Pourriez-vous fournir un exemple?
    ajout d'un exemple de réponse
    Ton exemple fonctionne bien, mais ce n'est pas exactement ce que je suis en train de faire. Au lieu d'envoyer des demandes simultanées, je voudrais leur en envoyer un à la fois, mais sans bloquer le reste du code. Mon exemple devrait être maintenant être moins ambigu.
    Je pense que la mise en forme doit être pool.apply_async(requests.post, [url], {'data': data}). La signature de la fonction est essentiellement (function_to_run, list_of_positional_args, dict_of_kwargs).
    r n'est pas un objet de réponse, c'est un avenir pour un objet de réponse. Vous obtenez la vraie réponse avec r.get() -- qui produit un objet response qui est le même que toute autre. Si vous voulez seulement le code de statut que vous pourriez faire r.get().status_code (à noter que si la demande a entraîné une exception, l'exception sera levée lorsque vous appelez get()). Vous pouvez également faire response = r.get() et procéder comme d'habitude. Si vous r.get() avant la requête asynchrone est terminée, alors vous aurez automatiquement attendre jusqu'à ce que la demande est complète avant de procéder.

    OriginalL'auteur Andrew Gorcester

  2. 6

    Voici un hacky façon de le faire:

    try:
    requests.get("http://127.0.0.1:8000/test/",timeout=0.0000000001)
except requests.exceptions.ReadTimeout: 
    pass
    Vous pouvez la perte d'une réponse de cette façon, souvent. La question était sur les demandes.poste et que son corps est aussi plus fragile, avec un très court délai d'attente qu'un simple get.
    fonctionne bien quand on n'a pas besoin de la réponse de l'api

    OriginalL'auteur keithhackbarth

  3. 2

    Selon la doc, vous devez les déplacer vers une autre bibliothèque :

    Bloquant Ou Non Bloquant?

    Avec le Transport par défaut de l'Adaptateur en place, les Demandes ne fournit pas de
    tout type de non-blocage IO. La Réponse.le contenu de la propriété va bloquer
    jusqu'à ce que la totalité de la réponse a été téléchargé. Si vous avez besoin de plus d'
    la granularité, les fonctionnalités de diffusion de la bibliothèque (voir en Streaming
    Les demandes) vous permettent de récupérer des quantités plus petites de la réponse à
    un temps. Cependant, ces appels seront toujours bloquer.

    Si vous êtes préoccupé par l'utilisation de blocage IO, il y a beaucoup de
    les projets qui combinent des Demandes avec l'un de Python
    l'asynchronicité des cadres.

    Deux excellents exemples sont
    grequests et
    les demandes de contrats à terme.

    J'ai essayé les demandes de contrats à terme, mais il ne parvient pas à csrf = s.cookies['csrftoken'].

    OriginalL'auteur Romain Jouin

  4. 1

    Si vous pouvez écrire le code à exécuter séparément dans un autre programme en python, ici est une solution basée sur subprocessing.

    Sinon, vous pourriez trouver utiles cette question et liées réponse: l'astuce est d'utiliser le filetage de la bibliothèque pour démarrer un thread à exécuter la séparation de la tâche.

    Une mise en garde à la fois de l'approche pourrait être le nombre d'éléments (c'est-à-dire le nombre de threads), vous avez à gérer. Si le items dans parent sont trop nombreux, vous pouvez envisager l'arrêt de chaque lot d'articles jusqu'à au moins certains threads ont fini, mais je pense que ce type de gestion est non-trivial.

    Pour une approche plus sophistiquée, vous pouvez utiliser un acteur en fonction de l'approche, je n'ai pas utilisé cette bibliothèque moi, mais je pense que ça pourrait aider dans ce cas.

    OriginalL'auteur Chosmos

  5. 0

    Solution élégante de Andrew Gorcester. En outre, sans l'aide de contrats à terme, il est possible d'utiliser les callback et error_callback attributs (voir
    doc) afin d'effectuer un traitement asynchrone:

    def on_success(r: Response):
    if r.status_code == 200:
        print(f'Post succeed: {r}')
    else:
        print(f'Post failed: {r}')

def on_error(ex: Exception):
    print(f'Post requests failed: {ex}')

pool.apply_async(requests.post, args=['http://server.host'], kwargs={'json': {'key':'value'},
                        callback=on_success, error_callback=on_error))

    OriginalL'auteur Nemolovich