Obtenir des ticks de minuterie en Python

Question

Je suis en train d'essayer de mesurer le temps d'un morceau de code. Le pseudocode ressemble à :

start = get_ticks()
do_long_code()
print "Cela a pris " + (get_ticks() - start) + " secondes."

Comment cela se présente-t-il en Python ?

Plus précisément, comment puis-je obtenir le nombre de ticks depuis minuit (ou la manière dont Python organise ce timing) ?

Answer 1

Dans le module time, il y a deux fonctions de minutage : time et clock. time vous donne le temps "mural", si c'est ce qui vous intéresse.

Cependant, la documentation de Python indique que clock devrait être utilisé pour les tests de performances. Notez que clock se comporte différemment sur des systèmes séparés :

• sous MS Windows, il utilise la fonction Win32 QueryPerformanceCounter(), avec "une résolution généralement meilleure qu'une microseconde". Cela n'a pas de signification spéciale, c'est juste un nombre (il commence à compter la première fois que vous appelez clock dans votre processus).

  # ms windows
  t0= time.clock()
  faire\_quelque\_chose()
  t= time.clock() - t0 # t est le temps écoulé en secondes (flottant)

• sous *nix, clock rapporte le temps CPU. Maintenant, c'est différent, et probablement la valeur que vous voulez, car votre programme demande rarement à lui tout seul du temps CPU (même si vous n'avez pas d'autres processus, le noyau utilise parfois du temps CPU de temps en temps). Donc, ce nombre, qui est généralement plus petit¹ que le temps mural (c'est-à-dire time.time() - t0), est plus significatif lors des tests de performances du code :

  # linux
  t0= time.clock()
  faire\_quelque\_chose()
  t= time.clock() - t0 # t est le temps CPU écoulé en secondes (flottant)

En dehors de tout cela, le module timeit a la classe Timer qui est censée utiliser ce qu'il y a de mieux pour effectuer des tests de performances à partir des fonctionnalités disponibles.

¹ à moins que le threading ne vienne perturber…

² Python ≥3.3 : il existe time.perf_counter() et time.process_time(). perf_counter est utilisé par le module timeit.

Answer 2

Ce dont vous avez besoin est la fonction time() du module time :

import time
start = time.time()
do_long_code()
print "Cela a pris", time.time() - start, "secondes."

Vous pouvez utiliser le module timeit pour plus d'options cependant.

Answer 3

Voici une solution que j'ai commencé à utiliser récemment:

class Timer:
    def __enter__(self):
        self.begin = now()

    def __exit__(self, type, value, traceback):
        print(format_delta(self.begin, now()))

Vous l'utilisez ainsi (Vous avez besoin d'au moins Python 2.5):

with Timer():
    do_long_code()

Quand votre code se termine, Timer imprime automatiquement le temps d'exécution. Génial! Si j'essaie rapidement de mesurer quelque chose dans l'interpréteur Python, c'est la méthode la plus simple à utiliser.

Et voici une implémentation d'exemple de 'now' et 'format_delta', mais n'hésitez pas à utiliser votre méthode de mesure et de formatage préférée.

import datetime

def now():
    return datetime.datetime.now()

# Imprime un des formats suivants*:
# 1,58 jours
# 2,98 heures
# 9,28 minutes # Pas encore ajouté, oups.
# 5,60 secondes
# 790 millisecondes
# *Sauf que je préfère les formats abrégés, donc j'imprime d, h, m, s, ou ms. 
def format_delta(start,end):

    # Temps en microsecondes
    un_jour = 86400000000
    une_heure = 3600000000
    une_seconde = 1000000
    un_millisecond = 1000

    delta = end - start

    build_time_us = delta.microseconds + delta.seconds * une_seconde + delta.days * un_jour

    jours = 0
    while build_time_us > un_jour:
        build_time_us -= un_jour
        jours += 1

    if jours > 0:
        time_str = "%.2fd" % ( jours + build_time_us / float(un_jour) )
    else:
        heures = 0
        while build_time_us > une_heure:
            build_time_us -= une_heure
            heures += 1
        if heures > 0:
            time_str = "%.2fh" % ( heures + build_time_us / float(une_heure) )
        else:
            secondes = 0
            while build_time_us > une_seconde:
                build_time_us -= une_seconde
                secondes += 1
            if secondes > 0:
                time_str = "%.2fs" % ( secondes + build_time_us / float(une_seconde) )
            else:
                ms = 0
                while build_time_us > un_millisecond:
                    build_time_us -= un_millisecond
                    ms += 1
                time_str = "%.2fms" % ( ms + build_time_us / float(un_millisecond) )
    return time_str

N'hésitez pas à me faire savoir si vous avez une méthode de formatage préférée, ou s'il existe une manière plus facile de faire tout cela!

Answer 4

import datetime

start = datetime.datetime.now()
do_long_code()
finish = datetime.datetime.now()
delta = finish - start
print delta.seconds

À partir de minuit :

import datetime

midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
maintenant = datetime.datetime.now()
delta = maintenant - midnight
print delta.seconds

Answer 5

Le module time en python vous donne accès à la fonction clock(), qui renvoie le temps en secondes sous forme de nombre à virgule flottante.

Les différents systèmes auront une précision différente en fonction de leur configuration d'horloge interne (ticks par seconde) mais elle est généralement d'au moins moins de 20 millisecondes, et dans certains cas meilleure que quelques microsecondes.

- Adam