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

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.

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

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

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

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

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"

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

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}

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

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)

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

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)    

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)

En IPython , "timeit" cualquier script:

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

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?

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

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.

Hay un timeitmódulo que se puede usar para medir el tiempo de ejecución del código Python.

Tiene documentación detallada y ejemplos en la documentación de Python, 26.6. timeit: mide el tiempo de ejecución de pequeños fragmentos de código .

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

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'

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.

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.

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)

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

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

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)

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

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:

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

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

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.