Mesurer le temps écoulé en python

Question

Est-il un moyen simple / module correctement mesurer le temps écoulé en python? Je sais que je peux simplement vous appelez time.time() deux fois et prendre la différence, mais qui donnera des résultats erronés si l'heure du système est modifié. D'accord, cela n'arrive pas très souvent, mais elle indique que je suis en mesure de quelque chose de mal.

À l'aide de time.time() pour mesurer des durées est incroyablement rond-point, quand vous pensez à ce sujet. Vous prenez la différence des deux temps absolu des mesures qui sont construits à partir de la durée des mesures (effectuées par des timers) et connu absolue fois (manuellement ou via ntp), qui ne vous intéresse pas du tout.

Alors, est-il un moyen d'interroger ce "timer temps" directement? J'imagine qu'il peut être représenté comme une milliseconde ou une valeur qui n'a pas de sens absolu de la représentation (et donc n'a pas besoin d'être ajusté avec le système de temps). En cherchant un peu, il semble que c'est exactement ce qu' System.nanoTime() n'en Java, mais je n'ai pas trouver un correspondant de la fonction Python, même si elle devrait (matériel technique) d'être plus facile à donner que time.time().

Edit: Pour éviter la confusion et de l'adresse de réponses ci-dessous: Ce n'est pas sur les modifications d'heure d'été, et je ne veux pas le temps CPU soit - je veux écoulé le temps physique. Il n'a pas besoin d'être très fin, et même pas particulièrement précis. Il ne devrait pas me donner négative durées, ou des durées qui sont de plusieurs ordres de grandeur (au-dessus de la granularité), juste parce que quelqu'un a décidé de régler l'horloge du système à une valeur différente. Voici ce que le Python docs dire à propos de 'temps.time()':

"Alors que cette fonction renvoie normalement non décroissante des valeurs, elle peut retourner une valeur inférieure à un précédent appel si l'horloge système a été mis en arrière entre les deux appels"

C'est exactement ce que je veux éviter, car elle peut conduire à des choses étranges comme des valeurs négatives dans les calculs de temps. Je peux contourner cela pour l'instant, mais je crois que c'est une bonne idée pour apprendre à utiliser les solutions appropriées lorsque cela est possible, depuis la kludges va revenir à vous mordre un jour.

Edit2: Certaines recherches démontrent que vous pouvez obtenir un système indépendant du temps de mesure comme je veux dans Windows en utilisant GetTickCount64 () sous Linux, vous pouvez l'obtenir dans la valeur de retour de fois(). Cependant, je n'arrive toujours pas à trouver un module qui fournit cette fonctionnalité en Python.

Answer 1

Pour la mesure de PROCESSEUR écoulé le temps, regardez le temps.clock(). C'est l'équivalent de Linux fois()l' utilisateur champ de temps.

Pour l'analyse comparative, l'utilisation timeit.

Le module datetime, qui fait partie de Python 2.3+, a aussi de la 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 le système de changements de temps (de DS -> ST) il suffit de cocher l'objet renvoyé par datetime.Sans doute, l'heure du système pourrait avoir un petit réglage à partir d'un NTP de référence de réglage. Cela devrait être de chargement pivote, et les corrections sont appliquées progressivement, mais ntp synchronisation des beats peut avoir un effet très faible (millisec ou microsec), les références temporelles.

Vous pouvez également référence Alex Martelli C de la fonction si vous voulez quelque chose de cette résolution. Je ne voudrais pas aller trop loin que de réinventer la roue. L'heure précise est plus fondamental et le plus moderne de l'OS de faire un assez bon travail.

Modifier

Basé sur vos précisions, il semble que vous ayez besoin d'un simple side vérifier si l'horloge système a changé. Il suffit de comparer à un match amical, local serveur ntp:

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 * '\0'
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 exact de millisecondes sur Internet et a la représentation de la résolution de la résolution de 2-32 secondes (233 picosecondes). Devrait être assez bon?

Sachez que le NTP 64 bits structure de données débordement en 2036, et tous les 136 ans par la suite , si vous voulez vraiment une solution robuste, amélioration de la vérification de débordement...

Answer 2

Ce que vous semblez être à la recherche d'une fonction monotone de la minuterie. Une fonction monotone de temps de référence ne saute pas ou revenir en arrière.

Il y a eu plusieurs tentatives pour mettre en place une plate-forme de monotomic horloge pour Python basé sur le système d'exploitation de référence de. (Windows, POSIX et BSD sont tout à fait différents) Voir les discussions et quelques tentatives monotone de temps dans cette SORTE de post.

Essentiellement, vous pouvez simplement utiliser os.fois():

os.fois() l'

De retour 5-n-uplet de nombres en virgule flottante indiquant cumulé (processeur ou autres) fois, en quelques secondes. Les éléments sont: du temps à l'utilisateur, le système de temps, les enfants de l'utilisateur de l'époque, un système de temps, et le temps réel écoulé depuis un point fixe dans le passé, dans cet ordre. Voir la page de manuel Unix fois(2) ou les Fenêtres correspondantes Plate-forme de la documentation de l'API. Sur Windows, seuls les deux premiers éléments sont remplis, les autres sont nuls.

Disponibilité: Unix, Windows

Mais cela ne veut pas remplir le nécessaire temps réel écoulé (le cinquième tuple) sur Windows.

Si vous avez besoin de support de Windows, envisager ctypes et vous pouvez appeler GetTickCount64() directement, comme cela a été fait dans cette recette.

Answer 3

Python 3.3 a ajouté un minuteur monotone dans la bibliothèque standard, qui fait exactement ce que je cherchais. Merci à Paddy3118 pour l'avoir signalé ici .

Answer 4

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

À l'aide de l'UTC évite ceux de gêner les périodes où l'horloge changements dus à l'heure d'été.

Comme pour l'utilisation d'une autre méthode plutôt que de la soustraction de deux horloges, sachez que le système d'exploitation ne contiennent en réalité une horloge qui est initialisé à partir d'une horloge matérielle dans le PC. Système d'exploitation moderne implémentations sera également garder cette horloge synchronisée avec certains de source officielle, afin de ne pas dériver. C'est beaucoup plus précis que n'importe quel intervalle de minuterie le PC peut être en cours d'exécution.

Answer 5

L'exemple des fonctions vous dites dans votre édition sont deux choses complètement différentes:

1. Linux temps() retourne le temps de traitement de la CPU millisecondes. Python est équivalent temps.clock() ou os.times().
2. Windows GetTickCount64() retourne la disponibilité du système.

Bien que les deux fonctions différentes, à la fois (peut-être) pourrait être utilisé pour révéler un système d'horloge qui avait un "rot" avec ces méthodes:

D'abord:

Vous pouvez prendre à la fois un système de temps avec time.time() et un temps CPU avec time.clock(). Depuis le temps horloge murale sera TOUJOURS supérieure ou égale à temps CPU, jeter la mesure où l'intervalle entre les deux time.time() lectures est inférieure à la jumelé time.clock() vérifier les lectures.

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

Deuxième:

Obtenir la disponibilité du système est également prometteuse si vous êtes préoccupé par l'horloge du système, puisque l'utilisateur réinitialisation ne s'applique pas le temps de disponibilité nombre de graduation dans la plupart des cas. (que je suis au courant...)

Maintenant le plus dur question: arriver à la disponibilité du système dans une plate-forme indépendante, surtout sans frai un nouveau shell -- au niveau de la sous précision d'une seconde. Hmmm...

Probablement le meilleur pari est psutil. La navigation sur la source, ils utilisent l' uptime = GetTickCount() / 1000.00f; pour Windows et sysctl "kern.boottime" de BSD / OS X, etc. Malheureusement, ce sont toutes les 1 seconde résolution.