cómo medir el tiempo de ejecución de los algoritmos en python

Posibles duplicados:
Precisión en el tiempo de las funciones en Python
medir con precisión el tiempo que toma la función python

¿Cómo puedo medir y comparar los tiempos de ejecución de mis algoritmos escritos en python? También me indica un buen sitio / foro de algoritmos como stackoverflow, si puede.

No estoy 100% seguro de lo que se entiende por “tiempos de ejecución de mis algoritmos escritos en python”, por lo que pensé que podría intentar ofrecer una visión más amplia de algunas de las posibles respuestas.

  • Los algoritmos no tienen tiempos de ejecución ; Las implementaciones pueden cronometrarse, pero un algoritmo es un enfoque abstracto para hacer algo. La parte más común y con frecuencia la parte más valiosa de optimizar un progtwig es analizar el algoritmo , por lo general, mediante el análisis asintótico y calcular la gran complejidad de O en el tiempo, el espacio, el uso del disco, etc.

    Una computadora realmente no puede hacer este paso por ti. Esto requiere hacer los cálculos para descubrir cómo funciona algo. Optimizar este lado de las cosas es el componente principal para tener un rendimiento escalable.

  • Puedes cronometrar tu implementación específica. La mejor manera de hacer esto en Python es usar timeit . La forma en que más parece querer ser usado es hacer un módulo con una función que encapsule lo que desea llamar y llamarlo desde la línea de comandos con python -m timeit ...

    Utilizar timeit para comparar varios fragmentos de código cuando se realiza la microoptimización, pero a menudo no es la herramienta correcta que desea para comparar dos algoritmos diferentes. Es común que lo que desea sea un análisis asintótico, pero es posible que desee tipos de análisis más complicados.

  • Tienes que saber a qué hora . La mayoría de los fragmentos no vale la pena mejorar. Necesita realizar cambios donde realmente cuentan, especialmente cuando está realizando una microoptimización y no está mejorando la complejidad asintótica de su algoritmo.

    Si cuadruplicas la velocidad de una función en la que tu código pasa el 1% del tiempo, no es una aceleración real. Si realiza un aumento de velocidad del 20% en una función en la que su progtwig pasa el 50% del tiempo, tendrá una ganancia real.

    Para determinar el tiempo empleado por un progtwig Python real, use las utilidades de creación de perfiles stdlib . Esto le indicará en qué parte del progtwig está gastando su código en un progtwig de ejemplo.

El módulo timeit es útil para esto y está incluido en la distribución estándar de Python.

Ejemplo:

 import timeit timeit.Timer('for i in xrange(10): oct(i)').timeit() 

Para pequeños algoritmos puede usar el módulo timeit de la documentación de python:

 def test(): "Stupid test function" L = [] for i in range(100): L.append(i) if __name__=='__main__': from timeit import Timer t = Timer("test()", "from __main__ import test") print t.timeit() 

Con menos precisión pero todavía válido, puedes usar el tiempo del módulo de esta manera:

 from time import time t0 = time() call_mifuntion_vers_1() t1 = time() call_mifunction_vers_2() t2 = time() print 'function vers1 takes %f' %(t1-t0) print 'function vers2 takes %f' %(t2-t1) 

Usar un decorador para medir el tiempo de ejecución de las funciones puede ser útil. Hay un ejemplo en http://www.zopyx.com/blog/a-python-decorator-for-measuring-the-execution-time-of-methods .

A continuación, pegué descaradamente el código del sitio mencionado anteriormente para que el ejemplo exista en SO en caso de que el sitio se borre de la red.

 import time def timeit(method): def timed(*args, **kw): ts = time.time() result = method(*args, **kw) te = time.time() print '%r (%r, %r) %2.2f sec' % \ (method.__name__, args, kw, te-ts) return result return timed class Foo(object): @timeit def foo(self, a=2, b=3): time.sleep(0.2) @timeit def f1(): time.sleep(1) print 'f1' @timeit def f2(a): time.sleep(2) print 'f2',a @timeit def f3(a, *args, **kw): time.sleep(0.3) print 'f3', args, kw f1() f2(42) f3(42, 43, foo=2) Foo().foo() 

// Juan

El lenguaje de progtwigción no importa; La medición de la complejidad del tiempo de ejecución de un algoritmo funciona de la misma manera, independientemente del idioma. El análisis de algoritmos de Stanford en Google Code University es un muy buen recurso para enseñarse a sí mismo cómo analizar la complejidad de los algoritmos y el código en tiempo de ejecución.

Si todo lo que desea hacer es medir el tiempo transcurrido que una función o sección del código tardó en ejecutarse en Python, entonces puede usar los módulos timeit o time , según el tiempo que deba ejecutarse el código.