Tiempo que tarda una importación en Python

Question

Quiero saber cuánto tiempo tarda una importación tanto en los módulos integrados como en los definidos por el usuario.

Answer 1

Puede probar esta runnning

$ time python -c "import math" 

Sin embargo, lo que haría que esta ayuda? La importación solo ocurre una vez y casi nunca será un cuello de botella. Importar el mismo módulo una y otra vez no será mucho más lento que importarlo una vez, ya que Python rastrea qué módulos ya se han importado.

¿Qué estás tratando de lograr?

Answer 2

uso de perfiles: http://docs.python.org/library/profile.html

De todos modos, las importaciones se almacenan en caché.

Answer 3

Uso cprofile:

python -m cProfile yourscript.py 

Answer 4

probado en Windows en Python 2.4 - usted puede hacerlo por uno mismo.

>>> import time 

>>> ## Built-in module 
>>> def testTime(): 
     now = time.clock() # use time.time() on unix-based systems 
     import math 
     print time.clock() - now 

>>> testTime() 
7.54285810167e-006 



>>> ## My own module 
>>> def testTime(): 
     now = time.clock() 
     import myBuiltInModule # Not its actual name ;-) 
     print time.clock() - now 

>>> testTime() 
0.00253174635324 
>>> testTime() 
3.70158777141e-006 

Así que hay una gran diferencia entre los módulos en caché y los traídos desde cero. Para ilustrar esto, podemos volver a cargar el módulo:

>>> def testTime(): 
     now = time.clock() 
     reload(myBuiltInModule) 
     print time.clock() - now 


>>> testTime() 
0.00250017809526 

Answer 5

Para averiguar cuánto tiempo tarda una importación, la forma más sencilla es probablemente utilizando el timeit module ..

>>> import timeit 
>>> t = timeit.Timer('import urllib') 
>>> t.timeit(number = 1000000) 
0.98621106147766113 

Así importar urllib 1 millón de veces, se tomó poco menos de un segundo (en un MacBook Pro) ..

Tengo un script principal que importa otra modules.I necesita para calcular la cantidad de tiempo que tarda

Si quiere decir el tiempo total de ejecución del script, en Linux/OS X/Cygwin, puede ejecutar la secuencia de comandos con el comando time, por ejemplo:

$ time python myscript.py 

real 0m0.046s 
user 0m0.024s 
sys  0m0.020s 

(recuerde que incluye todo el intérprete de Python tiempo de inicio, así como el tiempo de ejecución del código real, aunque es bastante cantidad trivial)

Otra forma es posiblemente más útil para perfilar el guión:

en lugar de ejecutar el código con

$ python myscript.py 

..you use ..

$ python -m cProfile myscript.py 
     1059 function calls in 0.015 CPU seconds 

    Ordered by: standard name 

    ncalls tottime percall cumtime percall filename:lineno(function) 
     1 0.000 0.000 0.000 0.000 <string>:1(<module>) 
     1 0.002 0.002 0.015 0.015 myscript.py:1(<module>) 
    [...] 

no encuentro la salida de línea de comandos muy fácil de leer, por lo que casi siempre utilizo gprof2dot, lo que convierte la información de perfil en un gráfico bastante graphviz:

$ python -m cProfile -o myscript.prof myscript.py 
$ python gprof2dot.py -o myscript.dot -f pstats myscript.prof 
$ dot -Tpng -o profile.png prof_runtest.dot -Gbgcolor=black 

Example output (1429x1896px PNG)

Answer 6

Una forma de importar perfiles es utilizar el módulo profile_imports utilizado en bzr source code:

# put those two lines at the top of your script 
import profile_imports 
profile_imports.install() 

# display the results 
profile_imports.log_stack_info(sys.stderr) 

Además de darle el tiempo para las importaciones, esto también calcula el tiempo para compilar expresiones regulares, que a menudo es una causa importante de desaceleración en las importaciones.

Answer 7

Me encontré con este problema perfilando una gran aplicación heredada con un tiempo de inicio de varios segundos. Es relativamente simple reemplazar el importador incorporado con algo que haga algún perfil. A continuación se muestra una forma de mostrar hacky aproximadamente la duración de cada módulo se tarda en ejecutar:

import os 
import sys 
import time 


class ImportEventNode(object): 
    def __init__(self, name, start_time, children=None, end_time=None): 
     self.name = name 
     self.start_time = start_time 
     self.children = [] if children is None else children 
     self.end_time = end_time 

    def __repr__(self): 
     return 'ImportEventNode({self.name}, {self.start_time}, children={self.children}, end_time={self.end_time})'.format(self=self) 

    @property 
    def total_time(self): 
     return self.end_time - self.start_time 

    @property 
    def net_time(self): 
     return self.total_time - sum(child.total_time for child in self.children) 


root_node = cur_node = None 

all_nodes = [] 
old_import = __import__ 
def __import__(*args, **kwargs): 
    global root_node, cur_node 
    name = args[0] 
    if name not in sys.modules: 
     t0 = time.time() 
     if root_node is None: 
      root_node = prev_node = cur_node = lcur_node = ImportEventNode(args[0], t0) 
     else: 
      prev_node = cur_node 
      cur_node = lcur_node = ImportEventNode(name, t0) 
      prev_node.children.append(cur_node) 
     try: 
      ret = old_import(*args, **kwargs) 
     finally: 
      lcur_node.end_time = time.time() 
     all_nodes.append(lcur_node) 
     cur_node = prev_node 
     return ret 
    else: 
     return old_import(*args, **kwargs) 


__builtins__.__import__ = __import__ 

se ejecuta en un ejemplo sencillo, así es como se ve en scipy.stats importadores:

:import scipy.stats 
: 
:nodes = sorted(all_nodes, key=(lambda x: x.net_time), reverse=True) 
:for node in nodes[:10]: 
: print(node.name, node.net_time) 
: 
:<EOF> 
('pkg_resources', 0.08431100845336914) 
('', 0.05861020088195801) 
('decomp_schur', 0.016885995864868164) 
('PIL', 0.0143890380859375) 
('scipy.stats', 0.010602712631225586) 
('pkg_resources._vendor.packaging.specifiers', 0.007072925567626953) 
('add_newdocs', 0.00637507438659668) 
('mtrand', 0.005497932434082031) 
('scipy.sparse.linalg', 0.005171060562133789) 
('scipy.linalg', 0.004471778869628906)