parametre threading timer

Version imprimable

bonjour,

je voudrais utiliser la fonctionnalité timer du module threading
mais je n'arrive pas a passer des arguments a la classe

un exemple est montre sur le site mais sans passage de parametre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class MyTimer:
    def __init__(self, tempo, target, args= [], kwargs={}):
        self._target = target
        self._args = args
        self._kwargs = kwargs
        self._tempo = tempo
 
 
    def _run(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
        self._target(*self._args, **self._kwargs)
 
    def start(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
 
    def stop(self):
        self._timer.cancel()
 
def gabarit():
     print unstr, time.clock()
 
 
Te=0.5
a = MyTimer(Te,gabarit,["MyTimer"])
 
 
a.start()
time.sleep(5.5)
print "Timer arrete"
a.stop()
time.sleep(2.0)

:oops:

03/03/2008, 21h46
dividee
Je ne sais pas si j'ai bien compris ce que tu veux, mais il me semble qu'il manque simplement le paramètre unstr à la fonction gabarit pour que cet exemple soit fonctionnel:
Code:

1 2 def gabarit(unstr): print unstr, time.clock()
Et s'il te plaît, utilise la balise [code] ! Merci Guigui_ !
04/03/2008, 08h13
tyrtamos

Bonjour,

Je ne comprend pas bien ce que tu veux faire, mais tu devrais regarder directement le code source du module threading.py qui se trouve dans lib. Le code concernant Timer est d'une vingtaine de lignes, et il est très intéressant. On y apprend, par exemple, que threading.Timer est une fonction, et pas une classe. C'est cette fonction qui appelle la classe threading ._Timer. Tu pourras voir aussi comment les arguments passés à la fonction threading.Timer (au delà de tempo et target) finissent par être transmis à la fonction target. Et pour un besoin plus complexe, tu devrais pouvoir créer une classe dérivée de threading._Timer, ou t'inspirer du code pour faire ta propre classe.

Tyrtamos
04/03/2008, 18h24
guenaule

timer threading

En fait,

je voudrais appeler une fonction tous les 50 ms, laquelle effectue
un traitement mathematique et stocke tous les pas de calcul dans
un csv.
j'ai vu que la classe timer du module threading possede deux arguments (args et kwargs), mais je n'ai pas pu passer mes parametres
a la fonction.

je vais essayer de comprendre la librairie en interne,
pour voir ce que je peux faire
04/03/2008, 19h37
tyrtamos
Voilà un petit code simplet qui montre la transmission des arguments.

Au lancement, le programme principal initialise le timer, le lance et attend qu'il ait terminé (join()).

Le timer attend 5 secondes et lance le calcul avec les 2 arguments fournis présentés sous forme de tuple.

Le timer se termine alors, ce qui permet au programme principal de poursuivre et d'afficher le résultat.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 import threading result=0 def calcul(x,y): global result result=x*y c=threading.Timer(5,calcul,(2,3)) c.start() c.join() print result
Les arguments passés ici sous forme d'un tuple peuvent être suivis par des arguments nommés, présentés alors sous forme d'un dictionnaire.

Tyrtamos

merci

merci tyrtamos,

tu m'as donné des idées,
du coup j'ai repris mon exemple ci_dessus, et j'ai ajouté
une phase d'init, on peut ainsi initialiser les parametres au premier
lancement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import csv
import threading
import time
 
 
class MyTimer:
    def __init__(self, tempo, target, args= [], kwargs={}):
        self._target = target
        self._args = args
        self._kwargs = kwargs
        self._tempo = tempo
        self.record_data  = []
        self.state  = "INIT"
 
 
    def _run(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
        self.state = self._target(self.state,*self._args, **self._kwargs)
 
    def start(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
 
    def stop(self):
        self._timer.cancel()
 
    def display(self):
        print self.record_data
 
 
 
def calcul(state,x,y):
 
    if state == "INIT":
        result = x+y+8
        state  = "RUN"
    else:
        result = x+y+7
    print result
    return state
 
 
 
 
 
 
 
## main
 
Te=0.05
input = 2
a = MyTimer(Te,calcul,(2,3))
 
 
a.start()
time.sleep(2)
print "Timer arrete"
print a.display():D
a.stop()
time.sleep(2.0)

Bonjour,

Je m'excuse de déterrer le topic (Et quel déterrage !) Mais mon problème concerne plus ou moins la même fonction, je souhaite pouvoir remettre a 0 mon timer, mais la fonction stop() ne fait rien, le temps continue à s'écouler, le but final est de créer une pointeuse informatique, donc avec un switch ON - OFF, tout fonctionne mais j'arrive pas à : soit tuer le thread, soit a remettre le timer du thread a 0 (et le stopper quand le switch est a off), voici le code :

timer.py
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class MonTimer: def __init__(self, tempo, target, args = [], kwargs = {}): self._target = target self._args = args self._kwargs = kwargs self._tempo = tempo def _run(self): self._timer = threading.Timer(self._tempo, self._run) self._timer.start() self._target(*self._args, **self._kwargs) def start(self): self._timer = threading.Timer(self._tempo, self._run) self._timer.start() def stop(self): self._timer.cancel() self._timer. def affiche(unstr): print(unstr, time.clock())
views.py
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 monTimer = MonTimer(1.0, MonTimer.affiche, ["MonTimer"]) def timer(request): etat = request.GET.get('active', None) if (etat): monTimer.start() else: time.sleep(1.0) monTimer.stop() data = { 'currentTime': time.strftime('%H : %M : %S', time.gmtime(time.clock())) } return JsonResponse(data)

Bonjour,

En ce qui me concerne, je place souvent le Timer à l'intérieur d'un thread pour avoir un plus grand contrôle sur lui, et en particulier pour l'arrêter.

Voilà un petit code de test en guise de source d'inspiration:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# -*- coding: utf-8 -*-
# Python 3
 
import threading
from time import sleep 
 
#############################################################################
def test():
    print("fonction test")
    sleep(3600) # attente 1h!
 
#############################################################################
class MonTimer(threading.Thread):
 
    #========================================================================
    def __init__(self, duree, fonction, args=[], kwargs={}):
        super().__init__()
 
        self.duree = duree
        self.fonction = fonction
        self.args = args
        self.kwargs = kwargs
 
    #========================================================================
    def run(self):
        self.timer = threading.Timer(self.duree, self.fonction, self.args, self.kwargs)
        self.timer.start()
        self.timer.join() # tant que le timer est actif, le thread est bloqué ici
 
    #========================================================================
    def stop(self):
        """pour arrêter sur demande
        """
        if self.timer.isAlive():
            self.timer.cancel()  # pour terminer le timer s'il est actif
            print("stop demandé")    
 
 
montimer = MonTimer(0, test)
montimer.setDaemon(True)
montimer.start()
sleep(1)
while True:
    rep = input("Stop? (o/n)")
    if rep=="o":
        montimer.stop()
        break
print("fin")

07/08/2018, 11h12
hotcryx

Vieille doc de Python, je n'ai pas trouvé pour la 3.7:

https://docs.python.org/2.4/lib/timer-objects.html
07/08/2018, 14h47
tyrtamos

Bonjour,

Citation:

Envoyé par hotcryx

Vieille doc de Python, je n'ai pas trouvé pour la 3.7

La voilà:

https://docs.python.org/3/library/th...#timer-objects

La doc de Python est facile à trouver quand on passe par le site officiel de Python: https://www.python.org/, puis par le menu "Documentation".

Merci tyrtamos, j'ai une question, la fonction time.clock() ne s’arrête t-elle pas quand j'utilise la fonction timer.cancel() ? J'ai beau essayer, je n'arrive pas à arrêter le temps :roll: Du coup, le mieux ne serait il pas d'utiliser un attribut du style
Code:

1 2 3 4 5 6 7 8 9 def __init__(self, duree, fonction, args=[], kwargs={}): super().__init__() self.duree = duree self.fonction = fonction self.args = args self.kwargs = kwargs self._count = 0
Avec self._count qui sera la variable "temps" finalement? Le but rechercher est de pouvoir stopper le temps ou de redémarrer de 0 lors de l'appuie sur un bouton

07/08/2018, 16h14
tyrtamos

Citation:

Envoyé par Rhadopsy

J'ai beau essayer, je n'arrive pas à arrêter le temps

As-tu essayé mon code? Il arrête le timer quand tu donnes "o" à la question en console. Ça devrait te donner la méthode pour adapter à ton programme.

Sinon, à mon avis, clock n'est pas influencé par le timer qui est dans un thread. On devrait pouvoir faire un petit test pour vérifier.

A noter cependant qu'il faut bien lire la doc de la version de Python qu'on utilise:

- clock n'a pas un fonctionnement identique sur tous les OS.

- clock est déprécié depuis la version 3.3: il faut maintenant utiliser plutôt perf_counter() ou process_time(). Voir: https://docs.python.org/3/library/time.html#time.clock.
07/08/2018, 16h22
wiztricks

Salut,

Citation:

Envoyé par Rhadopsy

la fonction time.clock() ne s’arrête t-elle pas quand j'utilise la fonction timer.cancel() ? J'ai beau essayer, je n'arrive pas à arrêter le temps :roll:

time.clock retourne le temps système: vous ne pouvez pas l'arrêter.
Après la question serait plutôt de clarifier peut être ce que vous voulez faire car threading.Timer n'est peut être pas le plus adapté voire intéressant pour résoudre votre problème (mais encore faut-il le connaître).

- W
08/08/2018, 09h51
Rhadopsy

C'est bien ce qu'il me semblait, je voudrai uniquement avoir un compteur de temps avec un bouton ON/OFF, ou le OFF remet à 0 le compteur et ON lance un compteur à partir de 0. Il faut que l'état reste permanent, même après déconnexion de la session utilisateur. A voir dans quoi sera stocké la valeur de l'état du compteur (cookie? enregistrement dans la bdd? autre?)
08/08/2018, 10h24
hotcryx

Citation:

Envoyé par tyrtamos

Bonjour,

La voilà:

https://docs.python.org/3/library/th...#timer-objects

La doc de Python est facile à trouver quand on passe par le site officiel de Python: https://www.python.org/, puis par le menu "Documentation".

je trouve leur site mal foutu, un search devrait donner le résultat direct.
En fait il faut savoir que Timer est dans Thread pour le retrouver :roll:
08/08/2018, 11h17
tyrtamos

Citation:

Envoyé par hotcryx

En fait il faut savoir que Timer est dans Thread pour le retrouver :roll:

Bien sûr que non: une fois dans la page générale de la doc, on a une petite zone de recherche en haut à droite. Le mot "timer" affiche tout de suite le module "threading" en 1ère ligne!

Il y a aussi un "general index" qui nous apprend que Timer se trouve dans les modules "threading" et "timeit".

Et avec une recherche générale Google, les mots "documentation python 3 Timer" amènent le module "threading" de Python 3.7 en 2ème ligne.

Il y a tellement de choses dans internet qu'il est important de savoir comment chercher...

En revenant sur mon problème, j'ai encore une question, j'arrive bien maintenant à faire comme je le souhaite, mais pourquoi au grand pourquoi, quand la fonction stop() est appelé, je peux encore utiliser des attributs du thread? Il est pas censé ne plus exister? Par exemple, sur le code que je vais joindre, j'appelle la fonction stop(), et ensuite l'attribut count du thread monTimer, et il continue à s'incrémenter, j'aurai préféré une grosse erreur bien rouge.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# -*- coding: utf-8 -*-
# Python 3
 
import threading
from time import sleep, perf_counter
 
 
#############################################################################
def test():
    print("fonction test")
    sleep(3600)  # attente 1h!
 
def boucle(montimer):
    while True:
        sleep(1)
        montimer.count = montimer.count + 1
        nb_sec = montimer.count
        print(nb_sec)
        if nb_sec == 10:
            montimer.stop()
            rep = input("Restart? (o/n)")
            if rep == "o":
                creerNouveauThread()
            else:
                print("fin")
                pass
 
def creerNouveauThread():
    montimer = MonTimer(0, test)
    montimer.setDaemon(True)
    montimer.start()
    boucle(montimer)
 
#############################################################################
class MonTimer(threading.Thread):
 
    # ========================================================================
    def __init__(self, duree, fonction, args=[], kwargs={}):
        super().__init__()
 
        self.duree = duree
        self.fonction = fonction
        self.args = args
        self.kwargs = kwargs
        self.count = 0
 
    # ========================================================================
    def run(self):
        self.timer = threading.Timer(self.duree, self.fonction, self.args, self.kwargs)
        self.timer.start()
        self.timer.join()  # tant que le timer est actif, le thread est bloqué ici
 
    # ========================================================================
    def stop(self):
        """pour arrêter sur demande
        """
        if self.timer.isAlive():
            self.timer.cancel()  # pour terminer le timer s'il est actif
            print("stop demandé")
 
creerNouveauThread()

08/08/2018, 14h22
wiztricks

Salut,

Citation:

Envoyé par Rhadopsy

j'aurai préféré une grosse erreur bien rouge.

Tant que votre code a une syntaxe correcte, Python n'a pas de raison de lever une erreur.
Par contre, si vous ne voulez toujours pas expliquer ce que vous voulez faire, je ne passerai pas du temps à essayer d'imaginer le problème que vous cherchez à résoudre en essayant de décortiquer le code que vous avez écrit: il fait trop mal aux yeux.

- W
08/08/2018, 14h54
Rhadopsy

Je l'ai dit deux fois, la troisième la bonne? Je veux faire un chronomètre avec un switch ON/OFF en thread, avec l'état ON ou OFF de stocké en cookie ou sur serveur. J'ai encore du mal avec la notion de thread, comment manipuler l'attribut "count" que j'ai ajouté, ou le tuer quand j'en ai plus besoin.
08/08/2018, 15h32
wiztricks

Citation:

Envoyé par Rhadopsy

Je l'ai dit deux fois, la troisième la bonne? Je veux faire un chronomètre avec un switch ON/OFF en thread, avec l'état ON ou OFF de stocké en cookie ou sur serveur. J'ai encore du mal avec la notion de thread, comment manipuler l'attribut "count" que j'ai ajouté, ou le tuer quand j'en ai plus besoin.

Un chronomètre mesure une durée entre son démarrage et son arrêt.
Si vous voulez coder çà en Python, une class Chronomètre avec une méthode "stop" et pouvoir récupérer sa valeur suffit. Vous pouvez y ajouter un état "ON"/"OFF" pour savoir s'il compte encore.
Qu'est ce qu'ajouteraient les threads là dedans puisque de toutes façons, la "valeur du compteur" sera une durée écoulée depuis le démarrage jusqu'à l'instant t ou lorsqu'il a été arrêté?

- W

Edit : Je crois que c'est bon
Edit 2 : Ou pas

J'ai bien suivi tes conseils et te remercie, le thread time ne sert à rien, certe, du coup je ne l'utilise plus. Je veux faire des threads car je souhaite pouvoir naviguer sur le site internet mais que le chronomètre tourne toujours. J'ai encore un dernier problème, je n'arrive pas à modifier l'état de l'objet chronomètre mis en thread pour qu'il s’arrête de compter. Peut tu m'indiquer la raison? Le code mis à jour :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 import sys import time from threading import Thread class Chronometre(Thread): def __init__(self, duree, etat): Thread.__init__(self) self._etat = etat self._duree = duree self.seconde = 0 def run(self): while self._etat: time.sleep(self._duree) self.seconde += 1 sys.stdout.write(str(self.seconde)) def change_etat(self, etat): self._etat = etat def affiche_etat(self): return (self._etat) chrono = Chronometre(1, True) chrono.start() chrono.join() time.sleep(5) chrono.change_etat(False)

08/08/2018, 17h22
Rhadopsy

C'est bon, j'ai reussi à gerer le truc grace a threading.Event
08/08/2018, 17h40
wiztricks

Citation:

Envoyé par Rhadopsy

je n'arrive pas à modifier l'état de l'objet chronomètre mis en thread pour qu'il s’arrête de compter.

Dans votre code, c'est la dernière ligne qui change l'état.... Mais on n'y arrivera qu'après le retour du .join(), i.e. jamais.

Citation:

Envoyé par Rhadopsy

J'ai bien suivi tes conseils et te remercie, le thread time ne sert à rien, certe, du coup je ne l'utilise plus. Je veux faire des threads car je souhaite pouvoir naviguer sur le site internet mais que le chronomètre tourne toujours

Le thread ne sert à rien puisque "compter toujours", c'est retourner la différence entre time.time() et l'instant du démarrage... Vous avez donc juste besoin de stocker l'instant du démarrage et l'état (on compte encore ou pas).

- W