Quelque chose comme JS setTimeout en python

J'en ai essayé avec le thème.

Traitement synchrone

Tout d'abord, vous pouvez retarder le traitement du temps spécifié en utilisant time.sleep comme suit.

import time
def hello(target):
    print("Hello {}".format(target))

time.sleep(3)
hello("World")

Cependant, cela retarde tout après "time.sleep". Comment puis-je retarder un processus spécifique comme setTimeout?

Traitement asynchrone (thread)

Vous pouvez le faire avec threading.Timer.

from threading import Timer

def hello(target):
    print("Hello {}".format(target))
    
timer = Timer(3, hello, ("World", ))
timer.start()

Vous pouvez également annuler au milieu comme suit.

timer.cancel()

Cette méthode génère un thread pour chaque appel à Timer. C'est un peu inefficace et différent de la méthode JavaScript setTimeout.

Traitement asynchrone (asyncio)

En JavaScript, la boucle d'événements gère divers événements dans un seul thread. Il existe un moyen de le faire dans Python 3.4 et versions ultérieures. Il s'agit d'une méthode utilisant asyncio, un package fourni en standard avec Python 3.4 ou version ultérieure. Comme JavaScript, il utilise une boucle d'événements. Cependant, en JavaScript, les boucles d'événements étaient implicites, mais en asyncio, vous devez être explicite.

Les deux suivants sont des exemples de code. [^ 1] [^ 2] [^ 3]

J'ai publié un exemple d'utilisation d'une API différente, qui est presque la même que ce que je fais. La version call_later déclenche un événement qui exécute la fonction spécifiée après (ou plus tard) le nombre de secondes spécifié dans asyncio.call_later. La version collout [^ 4] s'enroule avec un collout qui appelle la fonction d'origine après avoir renvoyé le nombre de secondes spécifié de contrôle appelé wrap_with_delay à la boucle d'événements. Dans ce code, la version call_later est plus simple, mais lorsque plusieurs processus sont chaînés, la version collout qui peut être écrite comme un traitement synchrone est plus facile à comprendre.

version call_later

import asyncio

def hello(target, loop=None):
    print("Hello {}".format(target))
    if loop is None:
        loop = asyncio.get_event_loop()
    loop.stop()  #Ajout d'un traitement pour arrêter la boucle d'événements et retourner le contrôle

loop = asyncio.get_event_loop() #Obtenir la boucle d'événements par défaut
loop.call_later(3, hello, "World")
loop.run_forever() #Début de la boucle d'événement. Il ne reviendra que si vous l'arrêtez explicitement.
# loop.close()

Version Corroutine

import asyncio

#Si vous ajoutez async, ce n'est pas une fonction normale mais un collout
async def wrap_with_delay(sec, func, *args):
    await asyncio.sleep(sec) #Renvoyer le contrôle à la boucle d'événements avec await
    func(*args)

def hello(target, loop=None):
    print("Hello {}".format(target))
    if loop is None:
        loop = asyncio.get_event_loop()
    loop.stop()  #Ajout d'un traitement pour arrêter la boucle d'événements et retourner le contrôle
    
loop = asyncio.get_event_loop()
asyncio.ensure_future(wrap_with_delay(3, hello, "World"))
loop.run_forever()
# loop.close()

[^ 1]: À l'origine, la boucle d'événements est un mécanisme permettant de fractionner plusieurs processus dans le temps et de les exécuter en parallèle, il n'est donc pas habituel de mettre uniquement une exécution retardée dans la boucle d'événements comme dans cet exemple.

[^ 2]: L'exécution ne s'arrêtera pas si vous ne faites pas pivoter la boucle d'événements, nous avons donc ajouté un processus pour arrêter la boucle afin que vous puissiez l'essayer facilement. Il s'agit d'un traitement supplémentaire du point de vue de la comparaison avec d'autres méthodes.

[^ 3]: Si vous fermez la boucle d'événements par défaut, asyncio.get_event_loop entraînera une erreur après cela, donc je l'ai commenté en envisageant de l'exécuter sur un notebook Jupyter.

[^ 4]: Ce code lui-même fonctionne sur Python 3.5 ou version ultérieure, mais avec un petit changement, il peut également être exécuté sur Python 3.4