Comment obtenir le temps d'exécution d'un programme Python?

J'ai un programme en ligne de commande en Python qui prend un certain temps pour terminer. Je veux savoir le temps exact qu'il faut pour terminer la course.

J'ai regardé le timeitmodule, mais il semble que ce ne soit que pour de petits extraits de code. Je veux chronométrer tout le programme.

La manière la plus simple en Python:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

Cela suppose que votre programme prend au moins un dixième de seconde pour s'exécuter.

Tirages:

--- 0.764891862869 seconds ---

Je mets ce timing.pymodule dans mon propre site-packagesrépertoire, et j'insère juste import timingen haut de mon module:

import atexit
from time import clock

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print line
    print secondsToStr(clock()), '-', s
    if elapsed:
        print "Elapsed time:", elapsed
    print line
    print

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

start = clock()
atexit.register(endlog)
log("Start Program")

Je peux également appeler timing.logdepuis mon programme s'il y a des étapes importantes dans le programme que je veux montrer. Mais le simple fait d' import timingimprimer les heures de début et de fin et le temps total écoulé. (Pardonnez ma secondsToStrfonction obscure , il formate juste un nombre à virgule flottante de secondes au format hh: mm: ss.sss.)

Remarque: Une version Python 3 du code ci-dessus peut être trouvée ici ou ici .

Sous Linux ou Unix:

$ time python yourprogram.py

Sous Windows, consultez cette question StackOverflow: comment mesurer le temps d'exécution d'une commande sur la ligne de commande Windows?

Pour une sortie plus détaillée,

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

J'aime vraiment la réponse de Paul McGuire , mais j'utilise Python 3. Donc pour ceux qui sont intéressés: voici une modification de sa réponse qui fonctionne avec Python 3 sur * nix (j'imagine, sous Windows, qui clock()devrait être utilisé à la place de time()):

#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta

def secondsToStr(elapsed=None):
    if elapsed is None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    else:
        return str(timedelta(seconds=elapsed))

def log(s, elapsed=None):
    line = "="*40
    print(line)
    print(secondsToStr(), '-', s)
    if elapsed:
        print("Elapsed time:", elapsed)
    print(line)
    print()

def endlog():
    end = time()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

start = time()
atexit.register(endlog)
log("Start Program")

Si vous trouvez cela utile, vous devriez toujours voter pour sa réponse au lieu de celle-ci, car il a fait la plupart du travail;).

import time

start_time = time.clock()
main()
print time.clock() - start_time, "seconds"

time.clock()renvoie le temps processeur, ce qui nous permet de calculer uniquement le temps utilisé par ce processus (sous Unix quand même). La documentation indique "dans tous les cas, c'est la fonction à utiliser pour comparer les algorithmes Python ou de synchronisation"

J'aime la sortie datetimefournie par le module, où les objets delta temporels affichent les jours, les heures, les minutes, etc. selon les besoins d'une manière lisible par l'homme.

Par exemple:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Exemple de sortie, par exemple

Duration: 0:00:08.309267

ou

Duration: 1 day, 1:51:24.269711

Comme l'a mentionné JF Sebastian, cette approche peut rencontrer des cas délicats avec l'heure locale, il est donc plus sûr d'utiliser:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))

Vous pouvez utiliser le profileur Python cProfile pour mesurer le temps CPU et en plus combien de temps est passé à l'intérieur de chaque fonction et combien de fois chaque fonction est appelée. Ceci est très utile si vous souhaitez améliorer les performances de votre script sans savoir par où commencer. Cette réponse à une autre question Stack Overflow est plutôt bonne. Il est toujours bon de jeter un œil à la documentation aussi.

Voici un exemple de profilage d'un script à l'aide de cProfile à partir d'une ligne de commande:

$ python -m cProfile euler048.py

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}

Encore mieux pour Linux: time

$ time -v python rhtest2.py

    Command being timed: "python rhtest2.py"
    User time (seconds): 4.13
    System time (seconds): 0.07
    Percent of CPU this job got: 91%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 15
    Minor (reclaiming a frame) page faults: 5095
    Voluntary context switches: 27
    Involuntary context switches: 279
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

time.clock ()

Déconseillé depuis la version 3.3: Le comportement de cette fonction dépend de la plateforme: utilisez plutôt perf_counter () ou process_time () , selon vos besoins, pour avoir un comportement bien défini.

time.perf_counter ()

Renvoie la valeur (en secondes fractionnelles) d'un compteur de performances, c'est-à-dire une horloge avec la résolution disponible la plus élevée pour mesurer une courte durée. Il ne comprend le temps écoulé pendant le sommeil et est l' échelle du système.

time.process_time ()

Renvoie la valeur (en secondes fractionnaires) de la somme du temps CPU système et utilisateur du processus en cours. Il n'inclut pas le temps écoulé pendant le sommeil.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)

Utilisez simplement le timeitmodule. Il fonctionne avec Python 2 et Python 3.

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+str(execution_time)) # It returns time in seconds

Il revient en quelques secondes et vous pouvez avoir votre temps d'exécution. C'est simple, mais vous devez les écrire dans la fonction principale w qui démarre l'exécution du programme. Si vous souhaitez obtenir le temps d'exécution même lorsque vous obtenez une erreur, apportez-y votre paramètre "Démarrer" et calculez-le comme suit:

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + str(execution_time))

L'extrait suivant imprime le temps écoulé dans un joli <HH:MM:SS>format lisible par l'homme .

import time
from datetime import timedelta

start_time = time.time()

#
# Perform lots of computations.
#

elapsed_time_secs = time.time() - start_time

msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

print(msg)    

from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)

Dans IPython , "timeit" n'importe quel script:

def foo():
    %run bar.py
timeit foo()

J'ai regardé le module timeit, mais il semble que ce ne soit que pour de petits extraits de code. Je veux chronométrer tout le programme.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Il exécute la your_module.main()fonction une fois et imprime le temps écoulé à l'aide de la time.time()fonction de minuterie.

Pour émuler /usr/bin/timeen Python, voir sous-processus Python avec / usr / bin / time: comment capturer les informations de synchronisation mais ignorer toutes les autres sorties? .

Pour mesurer le temps CPU (par exemple, ne pas inclure le temps pendant time.sleep()) pour chaque fonction, vous pouvez utiliser le profilemodule ( cProfilesur Python 2):

$ python3 -mprofile your_module.py

Vous pouvez passer -pà la timeitcommande ci-dessus si vous souhaitez utiliser le même temporisateur que celui profileutilisé par le module.

Voir Comment pouvez-vous profiler un script Python?

J'ai aussi aimé la réponse de Paul McGuire et j'ai trouvé un formulaire de gestionnaire de contexte qui correspondait mieux à mes besoins.

import datetime as dt
import timeit

class TimingManager(object):
    """Context Manager used with the statement 'with' to time some execution.

    Example:

    with TimingManager() as t:
       # Code to time
    """

    clock = timeit.default_timer

    def __enter__(self):
        """
        """
        self.start = self.clock()
        self.log('\n=> Start Timing: {}')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        """
        self.endlog()

        return False

    def log(self, s, elapsed=None):
        """Log current time and elapsed time if present.
        :param s: Text to display, use '{}' to format the text with
            the current time.
        :param elapsed: Elapsed time to display. Dafault: None, no display.
        """
        print s.format(self._secondsToStr(self.clock()))

        if(elapsed is not None):
            print 'Elapsed time: {}\n'.format(elapsed)

    def endlog(self):
        """Log time for the end of execution with elapsed time.
        """
        self.log('=> End Timing: {}', self.now())

    def now(self):
        """Return current elapsed time as hh:mm:ss string.
        :return: String.
        """
        return str(dt.timedelta(seconds = self.clock() - self.start))

    def _secondsToStr(self, sec):
        """Convert timestamp to h:mm:ss string.
        :param sec: Timestamp.
        """
        return str(dt.datetime.fromtimestamp(sec))

Pour les utilisateurs de données utilisant Jupyter Notebook

Dans une cellule, vous pouvez utiliser la %%timecommande magique de Jupyter pour mesurer le temps d'exécution:

%%time
[ x**2 for x in range(10000)]

Production

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

Cela ne capturera que le temps d'exécution d'une cellule particulière. Si vous souhaitez capturer le temps d'exécution de tout le bloc-notes (c'est-à-dire le programme), vous pouvez créer un nouveau bloc-notes dans le même répertoire et dans le nouveau bloc-notes exécuter toutes les cellules:

Supposons que le carnet ci-dessus soit appelé example_notebook.ipynb. Dans un nouveau carnet dans le même répertoire:

# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb

# Run the example_notebook with -t flag for time
%run -t example_notebook

Production

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

Il existe un timeitmodule qui peut être utilisé pour chronométrer les temps d'exécution du code Python.

Il a une documentation détaillée et des exemples dans la documentation Python, 26.6. timeit - Mesurer le temps d'exécution de petits extraits de code .

Utilisez line_profiler .

line_profiler profilera le temps nécessaire à l'exécution de chaque ligne de code. Le profileur est implémenté en C via Cython afin de réduire les frais généraux de profilage.

from line_profiler import LineProfiler
import random

def do_stuff(numbers):
    s = sum(numbers)
    l = [numbers[i]/43 for i in range(len(numbers))]
    m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()

Les résultats seront:

Timer unit: 1e-06 s

Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           def do_stuff(numbers):
     5         1           10     10.0      1.5      s = sum(numbers)
     6         1          186    186.0     28.7      l = [numbers[i]/43 for i in range(len(numbers))]
     7         1          453    453.0     69.8      m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

J'ai utilisé une fonction très simple pour chronométrer une partie de l'exécution du code:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

Et pour l'utiliser, il suffit de l'appeler avant le code à mesurer pour récupérer le timing de la fonction, puis d'appeler la fonction après le code avec des commentaires. L'heure apparaîtra devant les commentaires. Par exemple:

t = timing()
train = pd.read_csv('train.csv',
                        dtype={
                            'id': str,
                            'vendor_id': str,
                            'pickup_datetime': str,
                            'dropoff_datetime': str,
                            'passenger_count': int,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': str,
                            'trip_duration': int,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Loaded {} rows data from 'train'".format(len(train)))

Ensuite, la sortie ressemblera à ceci:

[9.35s] Loaded 1458644 rows data from 'train'

J'avais le même problème dans de nombreux endroits, j'ai donc créé un package de commodité horology. Vous pouvez l'installer avec pip install horology, puis le faire de manière élégante:

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

affichera:

Important calculations: 12.43 ms

Ou encore plus simple (si vous avez une fonction):

from horology import timed

@timed
def main():
    ...

affichera:

main: 7.12 h

Il s'occupe des unités et des arrondis. Il fonctionne avec python 3.6 ou plus récent.

C'est la réponse de Paul McGuire qui fonctionne pour moi. Juste au cas où quelqu'un aurait du mal à gérer celui-ci.

import atexit
from time import clock

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print (line)
    print (secondsToStr(clock()), '-', s)
    if elapsed:
        print ("Elapsed time:", elapsed)
    print (line)

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

def main():
    start = clock()
    atexit.register(endlog)
    log("Start Program")

Appelez timing.main()depuis votre programme après avoir importé le fichier.

Timeit est une classe en Python utilisée pour calculer le temps d'exécution de petits blocs de code.

Default_timer est une méthode de cette classe qui est utilisée pour mesurer le timing de l'horloge murale, pas le temps d'exécution du CPU. Ainsi, l'exécution d'autres processus pourrait interférer avec cela. Il est donc utile pour les petits blocs de code.

Un exemple du code est le suivant:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Réponse plus tard, mais j'utilise timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

• Enveloppez tout votre code, y compris toutes les importations que vous pourriez avoir, à l'intérieur code_to_test.
• number L'argument spécifie le nombre de fois que le code doit se répéter.
• Démo

L'heure de la mesure d'exécution d'un programme Python peut être incohérente selon:

• Le même programme peut être évalué en utilisant différents algorithmes
• Le temps d'exécution varie selon les algorithmes
• Le temps d'exécution varie selon les implémentations
• Le temps d'exécution varie selon les ordinateurs
• Le temps de fonctionnement n'est pas prévisible sur la base de petites entrées

En effet, le moyen le plus efficace consiste à utiliser l '"Ordre de croissance" et à apprendre la grande notation "O" pour le faire correctement.

Quoi qu'il en soit, vous pouvez essayer d'évaluer les performances de n'importe quel programme Python dans des étapes de comptage de machine spécifiques par seconde en utilisant cet algorithme simple: adaptez-le au programme que vous souhaitez évaluer

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

Vous faites cela simplement en Python. Il n'est pas nécessaire de compliquer les choses.

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)

Semblable à la réponse de @rogeriopvl, j'ai ajouté une légère modification pour convertir en heure minute seconde en utilisant la même bibliothèque pour les travaux de longue durée.

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Exemple de sortie

Time Taken: 00:00:08

Tout d'abord, installez le package convivial en ouvrant l'invite de commande (CMD) en tant qu'administrateur et tapez-le - pip install humanfriendly

Code:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Production:

Pour utiliser la réponse mise à jour de metakermit pour Python 2.7, vous aurez besoin du package monotone .

Le code serait alors le suivant:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

J'ai essayé et trouvé la différence de temps en utilisant les scripts suivants.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

Si vous souhaitez mesurer le temps en microsecondes, vous pouvez utiliser la version suivante, basée entièrement sur les réponses de Paul McGuire et Nicojo - c'est du code Python 3. Je lui ai également ajouté de la couleur:

import atexit
from time import time
from datetime import timedelta, datetime


def seconds_to_str(elapsed=None):
    if elapsed is None:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    else:
        return str(timedelta(seconds=elapsed))


def log(txt, elapsed=None):
    colour_cyan = '\033[36m'
    colour_reset = '\033[0;0;39m'
    colour_red = '\033[31m'
    print('\n ' + colour_cyan + '  [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
    if elapsed:
        print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)


def end_log():
    end = time()
    elapsed = end-start
    log("End Program", seconds_to_str(elapsed))


start = time()
atexit.register(end_log)
log("Start Program")

log () => fonction qui imprime les informations de chronométrage.

txt ==> premier argument à consigner, et sa chaîne pour marquer le timing.

atexit ==> Module Python pour enregistrer les fonctions que vous pouvez appeler lorsque le programme se termine.