Exécution d'actions périodiques

Question

Je travaille sous Windows. Je veux exécuter une fonction foo() toutes les 10 secondes.
Comment dois-je m'y prendre ?

Answer 1

A la fin de l'année foo() créer un Timer qui appelle foo() après 10 secondes.
Parce que, Timer créer un nouveau thread d'appeler foo() .
Vous pouvez faire d'autres choses sans être bloqué.

import time, threading
def foo():
    print(time.ctime())
    threading.Timer(10, foo).start()

foo()

#output:
#Thu Dec 22 14:46:08 2011
#Thu Dec 22 14:46:18 2011
#Thu Dec 22 14:46:28 2011
#Thu Dec 22 14:46:38 2011

Answer 2

Il suffit de dormir pendant 10 secondes ou d'utiliser threading.Timer(10,foo) entraînera une dérive de l'heure de démarrage. (Il se peut que vous ne vous en souciiez pas, ou que ce soit une source importante de problèmes, selon votre situation exacte). Il peut y avoir deux causes à cela - des inexactitudes dans le temps de réveil de votre thread ou le temps d'exécution de votre fonction.

Vous pouvez voir quelques résultats à la fin de ce post, mais d'abord un exemple de la façon de le corriger. Vous devez déterminer à quel moment votre fonction devrait être appelée et à quel moment elle a été appelée et tenir compte de la différence.

Voici une version qui dérive légèrement :

import datetime, threading

def foo():
    print datetime.datetime.now()
    threading.Timer(1, foo).start()

foo()

Sa sortie ressemble à ceci :

2013-08-12 13:05:36.483580
2013-08-12 13:05:37.484931
2013-08-12 13:05:38.485505
2013-08-12 13:05:39.486945
2013-08-12 13:05:40.488386
2013-08-12 13:05:41.489819
2013-08-12 13:05:42.491202
2013-08-12 13:05:43.492486
2013-08-12 13:05:44.493865
2013-08-12 13:05:45.494987
2013-08-12 13:05:46.496479
2013-08-12 13:05:47.497824
2013-08-12 13:05:48.499286
2013-08-12 13:05:49.500232

Vous pouvez voir que le nombre de sous-secondes augmente constamment et que, par conséquent, l'heure de départ "dérive".

Il s'agit d'un code qui tient compte correctement de la dérive :

import datetime, threading, time

next_call = time.time()

def foo():
  global next_call
  print datetime.datetime.now()
  next_call = next_call+1
  threading.Timer( next_call - time.time(), foo ).start()

foo()

Sa sortie ressemble à ceci :

2013-08-12 13:21:45.292565
2013-08-12 13:21:47.293000
2013-08-12 13:21:48.293939
2013-08-12 13:21:49.293327
2013-08-12 13:21:50.293883
2013-08-12 13:21:51.293070
2013-08-12 13:21:52.293393

Ici, vous pouvez voir qu'il n'y a plus d'augmentation des temps inférieurs à la seconde.

Si vos événements sont très fréquents, vous voudrez peut-être exécuter la minuterie dans un seul thread, plutôt que de démarrer un nouveau thread pour chaque événement. En tenant compte de la dérive, cela pourrait ressembler à ceci :

import datetime, threading, time

def foo():
    next_call = time.time()
    while True:
        print datetime.datetime.now()
        next_call = next_call+1;
        time.sleep(next_call - time.time())

timerThread = threading.Thread(target=foo)
timerThread.start()

Cependant, votre application ne se terminera pas normalement, vous devrez tuer le fil de la minuterie. Si vous souhaitez quitter normalement votre application lorsque celle-ci est terminée, sans tuer manuellement le fil d'exécution, vous devez utiliser la commande

timerThread = threading.Thread(target=foo)
timerThread.daemon = True
timerThread.start()

Answer 3

Peut-être que le module de programmation répondra à vos besoins.

Vous pouvez également envisager d'utiliser un Objet temporisé .

Answer 4

Ceci insérera un sommeil de 10 secondes entre chaque appel à foo() ce qui correspond à peu près à ce que vous avez demandé si l'appel se termine rapidement.

import time

while True:
    foo()
    time.sleep(10)

Pour faire d'autres choses pendant que votre foo() est appelé dans un thread d'arrière-plan

import time
import sys
import threading

def foo():
    sys.stdout.write('({}) foo\n'.format(time.ctime()))

def foo_target():
    while True:
        foo()
        time.sleep(10)

t = threading.Thread(target=foo_target)
t.daemon = True
t.start()
print('doing other things...')

Answer 5

Voici une belle mise en œuvre utilisant la classe Thread : http://g-off.net/software/a-python-repeatable-threadingtimer-class

le code ci-dessous est un peu plus rapide et sale :

from threading import Timer
from time import sleep

def hello():
    print "hello, world"
    t = Timer(3,hello)
    t.start()

t = Timer(3, hello)
t.start() # after 3 seconds, "hello, world" will be printed

# timer will wake up ever 3 seconds, while we do something else
while True:
    print "do something else"
    sleep(10)