parametre threading timer

**guenaule** · 03/03/2008, 20h54

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

**dividee** · 03/03/2008, 21h46

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def gabarit(unstr):
    print unstr, time.clock()

Et s'il te plaît, utilise la balise [code] ! Merci Guigui_ !

**tyrtamos** · 04/03/2008, 08h13

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

**guenaule** · 04/03/2008, 18h24

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

**tyrtamos** · 04/03/2008, 19h37

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**guenaule** · 04/03/2008, 22h44

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

**Rhadopsy** · 06/08/2018, 14h27

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

**tyrtamos** · 06/08/2018, 15h56

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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")

**hotcryx** · 07/08/2018, 11h12

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

https://docs.python.org/2.4/lib/timer-objects.html

**tyrtamos** · 07/08/2018, 14h47

Bonjour,

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".

**Rhadopsy** · 07/08/2018, 15h32

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

Du coup, le mieux ne serait il pas d'utiliser un attribut du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**tyrtamos** · 07/08/2018, 16h14

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.

**wiztricks** · 07/08/2018, 16h22

Salut,

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

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

**Rhadopsy** · 08/08/2018, 09h51

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?)

**hotcryx** · 08/08/2018, 10h24

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

**tyrtamos** · 08/08/2018, 11h17

Envoyé par hotcryx

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

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...

**Rhadopsy** · 08/08/2018, 11h54

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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()

**wiztricks** · 08/08/2018, 14h22

Salut,

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

**Rhadopsy** · 08/08/2018, 14h54

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.

**wiztricks** · 08/08/2018, 15h32

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

parametre threading timer

Python

Discussions similaires

Partager

Partager