Discussion :

[ju_bicycle]

Bonjour a tous
Alors voila, je souhaiterai avoir une base de temps précise (à la micro seconde prés), et utilisable quand je veux dans mon code.
J'avais pensé faire ceci:

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
 
class ThreadChrono(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.go      = 1
        self.jour    =0
        self.heure   =0
        self.minute  =0
        self.seconde =0
        self.milli   =0
        self.micro   =0
 
    def run(self):
        while self.go==1:
            self.milli=self.milli+1  
            if self.micro==1000:
                self.milli=self.milli+1
                self.micro==0
                if self.milli==1000:
                    self.seconde=self.seconde+1
                    self.milli=0
                    if self.seconde==60:
                        self.minute=self.minute+1
                        self.seconde=0
                        if self.minute==60:
                            self.heure=self.heure+1
                            self.minute=0
                            if self.heure==24:
                                self.jour=self.jour+1
                                self.heure=0   
            time.sleep(0.001) 
 
 
    def WhatTime(self):
        return "%s jour, %sh %sm %ss %sm %su "%(self.jour,self.heure,self.minute,self.seconde,self.milli,self.micro)

Bon c'est bête comme chou:
j'attends une micro seconde avec avec la fonction time.sleep(), puis j'incrémente mon compteur de micro-seconde. Quand celui ci atteint 1000, il est remis à 0 et le compteur des millisecondes est incrémenté de "1" et ainsi de suite.
La méthode WhatTime permet de récupérer l'état du compteur et le tout est placé dans un thread afin que ca puisse tourner en parallele du reste de l'appli

Le code fonctionne et ca tourne...Le seul probleme c'est que c'est clairmement pas assez rapide: cela génére une horloge presque 2 fois trop lente...
Quelqu'un a une idée pour un truc plus fonctionnel/efficace/élégant...etc?
Merciii

julien

[Antoine_935]

Le souci de ton code est que, en plus de ton sleep d'une µs, tu fais de nombreux tests et autres opérations. Mettons qu'elles prennent elles aussi 1µs, ça te fait 2µs entre chaque mise à jour.

Il en résulte que ton horloge est 2 fois trop lente.

La solution est, d'une part, de faire des sleeps plus longs, et d'autre part de décompter du temps de ton sleep le temps qu'ont pris les différents tests et opérations.

Réfère toi aux manuels de jeux videos à ce sujet, ils sont champions dans cet art de décompte. Ca leur sert à faire des framerates constants malgré les temps de calculs.
http://fivedots.coe.psu.ac.th/~ad/jg/ch1/index.html



Il faut savoir de plus que les ordinateurs ne sont pas faits pour ce genre de calcul extrèmement précis:
lorsque tu fais un sleep, il est possible que l'OS passe la main à un autre thread, laissant du coup le tiens en attente. Ca signifie que, malgré ta demande d'1µs de sleep, tu peux te retrouver avec facilement 50 fois plus.
Il y a 1000 autres raisons pour laquelle ce n'est pas absolument précis, donc ça ne le sera probablement jamais


Ce n'est donc pas sur des sleeps que tu devrais baser ton chronomètre, mais sur des ticks d'horloge (il me semble, réfère toi au lien)


Cela dit, pour simplifier ton problème, pourquoi ne pas simplement enregistrer l'heure de lancement du chrono, et faire, à chaque fois que tu as besoin de connaître le temps écoule, une simple soustraction ?

Code :

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

1
2
3
4
startTime = time()
 
# Le code tourne, et a soudain besoin du nombre de µs écoulées depuis le début
totalTime = time() - startTime

[ju_bicycle]

Bonjour,

Merci Antoine, en fait j'avais bien compris pourquoi mon chrono était trop lent, mais je ne savais pas comment faire pour éviter tout ce bouzin.

D'ailleur la fonction sleep, quand on regarde la doc officielle on nous dit "Bon bah elle fera peut etre un peu plus ou un peu moins que le temps que vous indiquez"...Bref, pas précis du tout de toute façon

Merci pour ton idée des ticks. C'est une vrai solution de hardeux ca (compter les coups d'horloges). Je m'y refererai au besoins, mais sinon j'ai trouver le module datetime, qui est trés efficace.
http://docs.python.org/library/datet...time.timedelta

et voici un petit exemple tout con pour voir comment ca marche, au cas ou des gens en aurait besoins:

Code :

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

1
2
Jour=datetime.datetime(2000,12,14)  #on est obligé de donner une date dans les arguments, mais ca n'a aucune incidence pour la suite
a=jour.today()   #jour.today() renvoie la date au moment ou on l'appelle au format Année,mois jour,heure,minute,seconde,microseconde

Le mieux c'est que ce format la est géré par python (via la méthode timedelta). Cela pouvant être totalement transparent pour l'utilisateur.

Par exemple, si un peu plus tard je définis:

Code :

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

1
2
b=jour.today()
print str(b-a)  #donne la différence entre les deux moments ou j'ai utilisé la méthode "today".

Voila , affaire classé