Temps imparti

Réponse acceptée !
un dernier trouvé sur internet

import threading as TH, time as TI

class Timer:
    def __init__(self, n, f, *args, **kargs):
        """Appelle la fonction/classe f toutes les n secondes,
        les arguments optionnels sont transmis à f"""
        if type(n) is not int:
            raise TypeError("n doit être entier")
        if n < 1:
            raise ValueError("Délai invalide (minimum 1s)")
        if not callable(f):
            raise TypeError("f ne peut pas être appelé")
        self._f = f
        self._f_args = args
        self._f_kargs = kargs
        self._n = n
        self.lance = False
        self.threads = []

    def _appel(self, id):
        self._f(*self._f_args, **self._f_kargs)

    def _boucle(self):
        while not self._fin:
            th = TH.Thread(target = self._appel, args = (len(self.threads),))
            th.start()
            self.threads.append(th)
            TI.sleep(self._n)
        for t in self.threads:
            t.join()

    def Go(self):
        """Lance le timer"""
        if not self.lance:
            self._fin = False
            self.thread = TH.Thread(target = self._boucle)
            self.thread.start()
            self.lance = True

    def Stop(self):
        """Arrete le timer"""
        if self.lance:
            self._fin = True
            self.running = False

if __name__ == '__main__':
    x = 1
    def f():
        global x
        print '\t' + `x`
        x += 1

    T = Timer(3, f)
    T.Go()

    try:
        i = 1
        while True:
            print i
            i += 1
            TI.sleep(1)
    except KeyboardInterrupt:
        pass

    T.Stop()