Mesure du temps écoulé En python

pour mesurer le temps CPU écoulé, regardez .horloge() . C'est l'équivalent du champ Temps utilisateur times() de Linux.

Pour l'analyse comparative, l'utilisation timeit .

le module datetime , qui fait partie de Python 2.3+ , a également le temps de microseconde si pris en charge par la plate-forme.

exemple:

>>> import datetime as dt
>>> n1=dt.datetime.now()
>>> n2=dt.datetime.now()
>>> (n2-n1).microseconds
678521
>>> (n2.microsecond-n1.microsecond)/1e6
0.678521
ie, it took me .678521 seconds to type the second n2= line -- slow
>>> n1.resolution
datetime.timedelta(0, 0, 1)
1/1e6 resolution is claimed.

si vous êtes préoccupé par les changements de temps système (à partir de DS -> ST), il suffit de vérifier l'objet retourné par datetime.On peut supposer que le temps du système pourrait avoir un petit ajustement à partir d'un ajustement de référence NTP . cela doit être modifié , et les corrections sont appliqué graduellement , mais NTP Sync beats peut avoir un effet avec de très petites références de temps (millisec ou microsec).

Vous pouvez également référence Alex Martelli C de la fonction si vous voulez quelque chose de cette résolution. Je n'irais pas trop loin pour réinventer la roue. Le temps exact est basique et la plupart des OS modernes font un assez bon travail.

Modifier

basé sur vos clarifications, il semble que vous avez besoin d'une simple vérification latérale si l'horloge du système a changé. Il suffit de comparer à un serveur ntp amical et local:

import socket
import struct
import time

ntp="pool.ntp.org"   # or whatever ntp server you have handy

client = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
data = '\x1b' + 47 * '"151910920"'
client.sendto( data, ( ntp, 123 ))
data, address = client.recvfrom( 1024 )
if data:
    print 'Response received from:', address
    t = struct.unpack( '!12I', data )[10]
    t -= 2208988800L #seconds since Epoch
    print '\tTime=%s' % time.ctime(t)

NTP est précis à des millisecondes sur Internet et a une résolution de représentation de résolution de 2-32 secondes (233 picosecondes). Devrait être assez bon?

soyez conscient que la structure de données NTP 64 bits débordera en 2036 et tous les 136 ans par la suite -- si vous voulez vraiment une solution robuste, mieux vérifier le débordement...

Python 3.3 a ajouté un minuterie monotonique dans la bibliothèque standard, ce qui fait exactement ce que je cherchais. Merci à Paddy3118 d'avoir souligné ceci dans " Comment puis-je obtenir des durées de temps monotones en python?" .

>>> import datetime
>>> t1=datetime.datetime.utcnow()
>>> t2=datetime.datetime.utcnow()
>>> t2-t1
datetime.timedelta(0, 8, 600000)

utilisant UTC évite ces périodes embarrassantes lorsque l'horloge change en raison de l'heure d'été.

quant à l'utilisation d'une méthode alternative plutôt que de soustraire deux horloges, sachez que L'OS contient effectivement une horloge qui est initialisée à partir d'une horloge matérielle dans le PC. Les implémentations modernes de systèmes D'exploitation maintiendront également cette horloge synchronisée avec une source officielle pour qu'elle ne dérive pas. C'est beaucoup plus précis que n'importe quel chronomètre le PC peut-être en cours d'exécution.

les fonctions d'exemple que vous déclarez dans votre édition sont deux choses complètement différentes:

1. Linux times () renvoie les temps de traitement en CPU millisecondes. L'équivalent de Python est le temps.horloge() ou os.times() .
2. Windows GetTickCount64() renvoie à la disponibilité du système.

bien que deux fonctions différentes, les deux (potentiellement) pourraient être utilisées pour révéler une horloge système qui avait un "rot" avec ces méthodes:

premier:

vous pouvez prendre à la fois un temps système avec time.time() et un temps CPU avec time.clock() . Étant donné que l'Heure de l'horloge murale sera toujours supérieure ou égale à L'heure CPU, éliminer toute mesure où l'intervalle entre les deux lectures time.time() est inférieur aux lectures de contrôle time.clock() appariées.

exemple:

t1=time.time()
t1check=time.clock()

# your timed event...    

t2=time.time()
t2check=time.clock()

if t2-t1 < t2check - t1check:
    print "Things are rotten in Denmark"
    # discard that sample
else:
    # do what you do with t2 - t1... 

la Deuxième:

obtenir le temps de fonctionnement du système est également prometteur si vous êtes préoccupé par l'horloge du système, car un utilisateur reset ne réinitialise pas le nombre de temps de fonctionnement dans la plupart des cas. (que je suis au courant...)

maintenant la question plus difficile: obtenir le système temps de fonctionnement d'une manière indépendante de plate-forme-en particulier sans frayer une nouvelle coquille-à la précision de la sous-seconde. Hmmm...

probablement le le meilleur pari est psutil . parcourant la source , ils utilisent uptime = GetTickCount() / 1000.00f; Pour Windows et sysctl "kern.boottime" pour BSD / OS X, etc. Malheureusement, il s'agit d'une résolution d'une seconde.

from datetime import datetime
start = datetime.now()
print 'hello'
end = datetime.now()
delta = end-start
print type(delta)
<type 'datetime.timedelta'>
import datetime
help(datetime.timedelta)
...elapsed seconds and microseconds...