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


980

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.

Réponses:


1724

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

58
cependant, cela calcule le temps réel (y compris le temps utilisé par d'autres programmes), de sorte que cela semble prendre plus de temps lorsque votre ordinateur est occupé à faire d'autres choses
newacct

35
sous Windows, faites la même chose, mais utilisez time.clock () au lieu de time.time (). Vous obtiendrez une précision légèrement meilleure.
Corey Goldberg

33
Je recommande de faire round(time.time() - start_time, 2)(ou la décimale que vous voulez), je récupérais des nombres scientifiques comme 1.24e-5.
ThorSummoner

16
@ThorSummoner: vous voulez probablement '%.2f'au lieu d' round()ici.
jfs

10
Il y a un gros défaut dans cette méthode. Si l'heure du système change pendant l'exécution du programme (comme la synchronisation avec le serveur de temps), cette méthode ne fonctionnera pas ou pourrait même casser le code (durée négative ...)
Gilad

210

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 .


8
Il s'agit d'une véritable solution propre qui fonctionne également si vous appuyez sur Ctrl-C pour arrêter le programme.
sorin

excellente solution Je vais certainement l'utiliser et créer un décorateur de synchronisation pour identifier les fonctions de goulot d'étranglement
c24b

9
Pour Python 3, ajoutez from functools import reduceen haut et mettez des crochets autour de chaque instruction d'impression. Fonctionne très bien!
PowerApp101

2
@ PowerApp101 - Merci - La réponse de Nicojo fournit une version compatible Py3 de ce module.
PaulMcG

4
Remarque: time.clock () est "Obsolète depuis la version 3.3: Le comportement de cette fonction dépend de la plate-forme: utilisez plutôt perf_counter () [avec le temps dormi] ou process_time () [sans le temps dormi], selon vos besoins, pour avoir un comportement bien défini. "
mab

175

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

donc si je lance un autre widget, par exemple dans l'application QT, comment calculer le temps mis par ce widget pour apparaître?
Ciasto piekarz

1
Pour le cas du widget, si vous lancez à partir d'un programme Python, utilisez la réponse acceptée par rogeriopvl.
steveha

mais cela ne semble pas donner le temps en min: en secondes ça finit par un nombre flottant !!
Ciasto piekarz

3
Oui, cela donne un certain nombre de secondes. Vous pouvez convertir en min: secondes si vous le souhaitez. Regardez la réponse de Paul McGuire et sa secondsToStr()fonction.
steveha

68

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


1
J'ai trouvé timedelta(seconds=t).total_seconds()utile.
nu everest

Pouvez-vous expliquer ce que font ces fonctions? qu'est-ce que s dans la commande log? qu'est-ce que l'atexit?
SumNeuron

@SumNeuron, en bref, ces fonctions affichent le temps d'exécution du programme avec lequel vous l'utilisez. s est le premier argument à consigner et doit être une chaîne. log est une fonction qui imprime les informations de chronométrage. atexit est un module python qui vous permet d'enregistrer des fonctions à appeler à la sortie du programme.
Nicojo

@Nicojo Très utile. J'ai une question sur comment puis-je utiliser ce code pour tester par exemple le temps pour une exécution en boucle. supposons que j'ai une fonction comprenant une boucle, et je veux obtenir le temps passé par cette boucle
moudi

@moudi La meilleure réponse à cette question est votre meilleur pari. Réglez simplement l'heure de début juste avant la boucle et calculez le temps écoulé à la sortie de la boucle.
Nicojo

67
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"


14
time.time () est mieux utilisé sur * nix. time.clock () est mieux utilisé sous Windows.
Corey Goldberg

Je crois que cela ne peut pas être utilisé pour calculer "uniquement le temps utilisé par ce processus" car il utilise l'heure système et sera effectué par d'autres processus système? Corrigez-moi si je me trompe à ce sujet :)
AnnanFay

6
Remarque: time.clock () est "Obsolète depuis la version 3.3: Le comportement de cette fonction dépend de la plate-forme: utilisez plutôt perf_counter () [avec time sleeped] ou process_time () [sans time sleeped], selon vos besoins, pour avoir un comportement bien défini. "
mab

55

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

1
@phansen: vous pouvez utiliser timedelta(seconds=time.monotonic()-start)ici (ou time.time()si l'intervalle est long ). Ne soustrayez pas les objets naïfs datetime qui représentent l'heure locale; l'heure locale n'est pas monotone
jfs

OK, tu veux dire comme start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time). J'espère que vous avez raison, mais vous devez également le formater à votre retour datetime.timedelta(0, 0, 76). De plus, il semble que la méthode monotone n'ait été ajoutée qu'en Python 3.
metakermit

Ah ok. Je vois que vous pouvez le passer str()pour le rendre "humain". Je mettrai à jour la réponse, merci.
Metakermit

53

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}

@jacwah Comment additionnez-vous le temps total?
Chuck

@Chuck La première ligne dit X function calls in Y CPU seconds. Si vous voulez une horloge murale, utilisez l'une des autres réponses ici.
jacwah

28

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

18

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)

1
Commencez peut-être par la conclusion "Use time.process_time ()" (ou similaire)?
Peter Mortensen

17

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

Ne devrait pas être cette partie sous la finallypartie?
Alper

12

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)    

1
tout en bas ici, on trouve la réponse la plus saine («sain» signifiant en s'appuyant autant que possible sur les éléments intégrés et donc le moins tapant).
ijoseph

8
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)


8

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?


7

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

7

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.

5

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 .


OP mentionne explicitement timeitdans la question. La question est de savoir comment il peut être utilisé ici (ou devrait-il être utilisé ici et quelles sont les alternatives). Voici une réponse possible .
jfs

5

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))]

5

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'

5

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.


@DarrenZou consultez plus de documents et de sources ici
hans

Puis-je obtenir ces valeurs dans une variable?
PepeElMago33

Oui, utilisez main.interval.
hans

3

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.


3

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)

timeitest la meilleure réponse IMO pour de nombreux cas.
Marc

3

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

Et si vous voulez chronométrer une section du code qui ne peut pas être mise dans une chaîne?
Daniel Stracaboško

@daniel Vous pouvez créer une nouvelle question. Si vous postez le lien ici, je pourrai peut-être vous aider.
CONvid19

2

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")

2

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)

2

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

2

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:

entrez la description de l'image ici


1

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

1

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")

0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.