J'en ai essayé avec le thème.
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?
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.
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.
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()
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
Recommended Posts