¿Cómo obtengo el tiempo de ejecución de un programa Python?


980

Tengo un programa de línea de comandos en Python que tarda un poco en terminar. Quiero saber el tiempo exacto que lleva terminar de correr.

He mirado el timeitmódulo, pero parece que es solo para pequeños fragmentos de código. Quiero cronometrar todo el programa.

Respuestas:


1722

La forma más simple en Python:

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

Esto supone que su programa tarda al menos una décima de segundo en ejecutarse.

Huellas dactilares:

--- 0.764891862869 seconds ---

58
Esto calcula el tiempo real, aunque (incluyendo el tiempo utilizado por otros programas) por lo que se parecerá a tomar más tiempo cuando el equipo está ocupado haciendo otras cosas
newacct

35
en Windows, haga lo mismo, pero use time.clock () en lugar de time.time (). Obtendrá una precisión ligeramente mejor.
Corey Goldberg

33
Recomiendo hacer round(time.time() - start_time, 2)(o cualquier decimal que desee), estaba obteniendo números científicos como 1.24e-5.
ThorSummoner

16
@ThorSummoner: probablemente quieras en '%.2f'lugar de round()aquí.
jfs

10
Hay un gran defecto en este método. Si la hora del sistema cambia mientras el programa se está ejecutando (como la sincronización con el servidor horario), entonces este método no funcionará o incluso podría romper el código (duración negativa ...)
Gilad

210

Pongo este timing.pymódulo en mi propio site-packagesdirectorio, y solo inserto import timingen la parte superior de mi módulo:

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

También puedo llamar timing.logdesde mi programa si hay etapas significativas dentro del programa que quiero mostrar. Pero solo incluir import timingimprimirá los tiempos de inicio y finalización, y el tiempo transcurrido general. (Perdone mi oscura secondsToStrfunción, solo formatea un número de segundos de coma flotante a hh: mm: ss.sss).

Nota: Una versión de Python 3 del código anterior se puede encontrar aquí o aquí .


8
Esta es una solución realmente limpia que también funciona si presiona Ctrl-C para detener el programa.
sorin

gran solución Definitivamente lo
usaré

99
Para Python 3, agregue from functools import reduceen la parte superior y ponga corchetes alrededor de cada declaración de impresión. ¡Funciona genial!
PowerApp101

2
@ PowerApp101 - Gracias - La respuesta de Nicojo proporciona una versión amigable para Py3 de este módulo.
PaulMcG

44
Nota: time.clock () está "Desaprobado desde la versión 3.3: el comportamiento de esta función depende de la plataforma: utilice perf_counter () [con tiempo de espera] o process_time () [sin tiempo de espera] en su lugar, según sus requisitos, para tener un comportamiento bien definido ".
mab

175

En Linux o Unix:

$ time python yourprogram.py

En Windows, vea esta pregunta de StackOverflow: ¿Cómo mido el tiempo de ejecución de un comando en la línea de comandos de Windows?

Para una salida más detallada,

$ 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

así que si estoy iniciando otro widget, ejemplo en la aplicación QT, ¿cómo calculamos el tiempo que tarda ese widget en aparecer?
Ciasto piekarz

1
Para el caso del widget, si está iniciando desde un programa Python, use la respuesta aceptada por rogeriopvl.
steveha

pero eso no parece dar tiempo en minutos: ¡segundos, termina siendo un número flotante!
Ciasto piekarz

3
Sí, da una cantidad de segundos. Puede convertir a min: segundos si lo desea. Mire la respuesta de Paul McGuire y su secondsToStr()función.
steveha

68

Realmente me gusta la respuesta de Paul McGuire , pero uso Python 3. Entonces, para aquellos que estén interesados: aquí hay una modificación de su respuesta que funciona con Python 3 en * nix (imagino, en Windows, que clock()debería usarse en lugar 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 encuentra esto útil, aún debe votar su respuesta en lugar de esta, ya que hizo la mayor parte del trabajo;).


1
Me ha parecido timedelta(seconds=t).total_seconds()útil.
nu everest

¿Puedes explicar qué hacen estas funciones? ¿Qué hay en el comando de registro? ¿Qué es atexit?
SumNeuron

@SumNeuron, en resumen, estas funciones imprimen el tiempo de ejecución del programa con el que lo usa. s es el primer argumento para iniciar sesión, y debe ser una cadena. log es una función que imprime la información de sincronización. atexit es un módulo de python que le permite registrar funciones a las que se llamará al salir del programa.
Nicojo

@Nicojo Muy útil. Tengo una pregunta sobre cómo puedo usar este código para probar, por ejemplo, el tiempo para una ejecución de bucle. supongamos que tengo una función que incluye un bucle, y quiero obtener el tiempo dedicado por este bucle
moudi

@moudi La mejor respuesta a esta pregunta es tu mejor apuesta. Simplemente configure el tiempo de inicio justo antes del ciclo y calcule el tiempo transcurrido a la salida del ciclo.
Nicojo

67
import time

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

time.clock()devuelve el tiempo del procesador, lo que nos permite calcular solo el tiempo utilizado por este proceso (en Unix de todos modos). La documentación dice "en cualquier caso, esta es la función que se debe usar para evaluar los algoritmos de sincronización o de Python"


14
time.time () se usa mejor en * nix. time.clock () se usa mejor en Windows.
Corey Goldberg el

Creo que esto no se puede usar para calcular "solo el tiempo utilizado por este proceso" porque usa la hora del sistema y se verá afectado por otros procesos del sistema. Corrígeme si me equivoco acerca de esto :)
AnnanFay

66
Nota: time.clock () está "Desaprobado desde la versión 3.3: el comportamiento de esta función depende de la plataforma: utilice perf_counter () [con tiempo de espera] o process_time () [sin tiempo de espera] en su lugar, según sus requisitos, para tener un comportamiento bien definido ".
mab

55

Me gusta la salida datetimeque proporciona el módulo, donde los objetos delta de tiempo muestran días, horas, minutos, etc., según sea necesario de una manera legible para los humanos.

Por ejemplo:

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

Salida de muestra, p. Ej.

Duration: 0:00:08.309267

o

Duration: 1 day, 1:51:24.269711

Como JF Sebastian mencionó, este enfoque podría encontrar algunos casos difíciles con la hora local, por lo que es más seguro usarlo:

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

1
@phansen: podría usar timedelta(seconds=time.monotonic()-start)aquí (o time.time()si el intervalo es grande). No reste los objetos ingenuos de fecha y hora que representan la hora local; la hora local no es monótona
jfs

OK, quieres decir como start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time). Confío en que tienes razón, pero también debes formatearlo cuando regreses datetime.timedelta(0, 0, 76). Además, parece que el método monotónico solo se agregó en Python 3.
metakermit

Ah ok. Veo que puedes pasarlo str()para hacerlo "humano". Actualizaré la respuesta, gracias.
metakermit

53

Puede usar el perfil de perfil de Python cProfile para medir el tiempo de CPU y, además, cuánto tiempo pasa dentro de cada función y cuántas veces se llama a cada función. Esto es muy útil si desea mejorar el rendimiento de su script sin saber por dónde comenzar. Esta respuesta a otra pregunta de Stack Overflow es bastante buena. Siempre es bueno echar un vistazo en la documentación también.

Aquí hay un ejemplo de cómo perfilar un script usando cProfile desde una línea de comando:

$ 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 ¿Cómo sumas el tiempo total?
Chuck el

@Chuck La primera línea dice X function calls in Y CPU seconds. Si desea la hora del reloj de pared, use una de las otras respuestas aquí.
jacwah

28

Aún mejor para 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 ()

En desuso desde la versión 3.3: el comportamiento de esta función depende de la plataforma: utilice perf_counter () o process_time () en su lugar, según sus requisitos, para tener un comportamiento bien definido.

time.perf_counter ()

Devuelve el valor (en segundos fraccionarios) de un contador de rendimiento, es decir, un reloj con la resolución más alta disponible para medir una corta duración. Que no incluye el tiempo transcurrido durante el sueño y es para todo el sistema.

time.process_time ()

Devuelve el valor (en fracciones de segundo) de la suma del sistema y el tiempo de CPU del usuario del proceso actual. Que no incluye el tiempo transcurrido durante el sueño.

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

1
¿Quizás comenzar con la conclusión, "Use time.process_time ()" (o similar)?
Peter Mortensen

17

Solo usa el timeitmódulo. Funciona con Python 2 y 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

Regresa en segundos y puede tener su tiempo de ejecución. Es simple, pero debe escribirlos en la función principal que inicia la ejecución del programa. Si desea obtener el tiempo de ejecución incluso cuando obtiene un error, tome su parámetro "Inicio" y calcule allí como:

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

¿No debería ser esa parte bajo finallyparte?
Alper

12

El siguiente fragmento imprime el tiempo transcurrido en un agradable <HH:MM:SS>formato legible por humanos .

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
todo el camino hasta aquí se encuentra la respuesta más sensata ('sensato' significa confiar lo más posible en las incorporaciones y, por lo tanto, en escribir menos).
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

He examinado el módulo timeit, pero parece que es solo para pequeños fragmentos de código. Quiero cronometrar todo el programa.

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

Ejecuta la your_module.main()función una vez e imprime el tiempo transcurrido usandotime.time() función como temporizador.

Para emular /usr/bin/timeen Python, vea Subproceso de Python con / usr / bin / time: ¿cómo capturar información de temporización pero ignorar todos los demás resultados? .

Para medir el tiempo de CPU (por ejemplo, no incluya el tiempo durante time.sleep()) para cada función, puede usar el profilemódulo ( cProfileen Python 2):

$ python3 -mprofile your_module.py

Puede pasar -pal timeitcomando anterior si desea usar el mismo temporizador que el profilemódulo.

Consulte ¿Cómo puede perfilar un script de Python?


7

También me gustó la respuesta de Paul McGuire y se me ocurrió un formulario de administrador de contexto que se adaptaba mejor a mis necesidades.

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

Para las personas de datos que usan Jupyter Notebook

En una celda, puede usar el %%timecomando mágico de Jupyter para medir el tiempo de ejecución:

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

Salida

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

Esto solo capturará el tiempo de ejecución de una celda en particular. Si desea capturar el tiempo de ejecución de todo el cuaderno (es decir, el programa), puede crear un nuevo cuaderno en el mismo directorio y en el nuevo cuaderno ejecutar todas las celdas:

Supongamos que se llama el cuaderno de arriba example_notebook.ipynb. En un cuaderno nuevo dentro del mismo directorio:

# 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

Salida

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


5

Utilice line_profiler .

line_profiler perfilará el tiempo que tardan en ejecutarse las líneas de código individuales. El generador de perfiles se implementa en C a través de Cython para reducir la sobrecarga de la creación de perfiles.

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

Los resultados serán:

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

Usé una función muy simple para cronometrar una parte de la ejecución del código:

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

Y para usarlo, simplemente llámelo antes del código a medir para recuperar el tiempo de la función, y luego llame a la función después del código con comentarios. El tiempo aparecerá delante de los comentarios. Por ejemplo:

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

Entonces la salida se verá así:

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

5

Estaba teniendo el mismo problema en muchos lugares, así que creé un paquete de conveniencia horology. Puede instalarlo pip install horologyy luego hacerlo de la manera elegante:

from horology import Timing

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

dará salida:

Important calculations: 12.43 ms

O incluso más simple (si tiene una función):

from horology import timed

@timed
def main():
    ...

dará salida:

main: 7.12 h

Se ocupa de unidades y redondeo. Funciona con python 3.6 o más reciente.


@DarrenZou, consulte más documentos y fuentes aquí
Hans

¿Puedo obtener esos valores en una variable?
PepeElMago33

Si, uso main.interval.
Hans

3

Esta es la respuesta de Paul McGuire que funciona para mí. Por si alguien tenía problemas para ejecutarlo.

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

Llame timing.main()desde su programa después de importar el archivo.


3

Timeit es una clase en Python utilizada para calcular el tiempo de ejecución de pequeños bloques de código.

Default_timer es un método en esta clase que se usa para medir el tiempo del reloj de pared, no el tiempo de ejecución de la CPU. Por lo tanto, otra ejecución del proceso podría interferir con esto. Por lo tanto, es útil para pequeños bloques de código.

Una muestra del código es la siguiente:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

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

timeites la mejor respuesta de la OMI para muchos casos.
Marc

3

Respuesta posterior, pero yo uso 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

  • Envuelva todo su código, incluidas las importaciones que pueda tener, dentro code_to_test.
  • number El argumento especifica la cantidad de veces que el código debe repetirse.
  • Manifestación

¿Y qué pasa si quieres cronometrar alguna sección del código que no se puede poner en una cadena?
Daniel Stracaboško

@daniel Puedes crear una nueva pregunta. Si publica el enlace aquí, puedo ayudarlo.
CONvid19

2

El tiempo de la medida de ejecución de un programa Python podría ser inconsistente dependiendo de:

  • El mismo programa se puede evaluar usando diferentes algoritmos
  • El tiempo de ejecución varía entre algoritmos.
  • El tiempo de ejecución varía entre implementaciones
  • El tiempo de ejecución varía entre computadoras
  • El tiempo de ejecución no es predecible basado en entradas pequeñas

Esto se debe a que la forma más efectiva es usar el "Orden de crecimiento" y aprender la notación "O" grande para hacerlo correctamente.

De todos modos, puede intentar evaluar el rendimiento de cualquier programa de Python en pasos específicos de conteo de máquinas por segundo utilizando este algoritmo simple: adapte esto al programa que desea evaluar

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

Lo haces simplemente en Python. No hay necesidad de hacerlo complicado.

import time

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

2

Similar a la respuesta de @rogeriopvl, agregué una ligera modificación para convertir a hora minuto segundos usando la misma biblioteca para trabajos de larga ejecución.

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

Salida de muestra

Time Taken: 00:00:08

2

Primero, instale el paquete amigable para humanos abriendo Símbolo del sistema (CMD) como administrador y escriba allí: pip install humanfriendly

Código:

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

Salida:

ingrese la descripción de la imagen aquí


1

Para usar la respuesta actualizada de metakermit para Python 2.7, necesitará el paquete monótono .

El código sería entonces el siguiente:

from datetime import timedelta
from monotonic import monotonic

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

1

Intenté y encontré la diferencia horaria usando los siguientes scripts.

import time

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

0

Si desea medir el tiempo en microsegundos, puede usar la siguiente versión, basada completamente en las respuestas de Paul McGuire y Nicojo : es el código Python 3. También le agregué algo de color:

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 () => función que imprime la información de temporización.

txt ==> primer argumento para iniciar sesión, y su cadena para marcar el tiempo.

atexit ==> Módulo de Python para registrar funciones a las que puede llamar cuando se cierra el programa.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.