Comparación: statement de importación vs función __import__

timeit mide el tiempo total de ejecución, pero la primera importación de un módulo, ya sea a través de import o __import__ , es más lenta que las posteriores, porque es la única que realiza la inicialización del módulo. Tiene que buscar en el sistema de archivos los archivos del módulo, cargar el código fuente del módulo (el más lento) o el bytecode creado anteriormente (lento pero un poco más rápido que analizar los archivos .py ) o la biblioteca compartida (para las extensiones C), ejecutar el código de inicialización, y almacenar el objeto de módulo en sys.modules . Las importaciones posteriores pueden omitir todo eso y recuperar el objeto de módulo de sys.modules .

Si invierte el orden los resultados serán diferentes:

 import timeit def test(module): t2 = timeit.timeit("{0} = __import__('{0}')".format(module)) t1 = timeit.timeit("import {}".format(module)) print("import statement: ", t1) print("__import__ function:", t2) print("t(statement) {} t(function)".format("<" if t1 < t2 else ">")) test('numpy') import statement: 0.4611093703134608 __import__ function: 1.275512785926014 t(statement) < t(function) 

La mejor manera de obtener resultados no sesgados es importarlo una vez y luego hacer los tiempos:

 import timeit def test(module): exec("import {}".format(module)) t2 = timeit.timeit("{0} = __import__('{0}')".format(module)) t1 = timeit.timeit("import {}".format(module)) print("import statement: ", t1) print("__import__ function:", t2) print("t(statement) {} t(function)".format("<" if t1 < t2 else ">")) test('numpy') import statement: 0.4826306561727307 __import__ function: 0.9192819125911029 t(statement) < t(function) 

Entonces, sí, la import siempre es más rápida que __import__ .

Recuerde que todos los módulos se almacenan en caché en sys.modules después de la primera importación, por lo que el tiempo …

De todos modos, mis resultados se ven así:

 #!/bin/bash itest() { echo -n "import $1: " python3 -m timeit "import $1" echo -n "__import__('$1'): " python3 -m timeit "__import__('$1')" } itest "sys" itest "math" itest "six" itest "PIL" 

• import sys : 0.481
• __import__('sys') : 0.586
• import math : 0.163
• __import__('math') : 0.247
• import six : 0.157
• __import__('six') : 0.273
• import PIL : 0.162
• __import__('PIL') : 0.265

¿Cuál es la razón detrás de esta diferencia en los tiempos de ejecución?

La statement de importación tiene un camino bastante sencillo para pasar. Conduce a IMPORT_NAME que llama a import_name e importa el módulo dado (si no se ha __import__ el nombre __import__ ):

 dis('import math') 1 0 LOAD_CONST 0 (0) 2 LOAD_CONST 1 (None) 4 IMPORT_NAME 0 (math) 6 STORE_NAME 0 (math) 8 LOAD_CONST 1 (None) 10 RETURN_VALUE 

__import__ , por otro lado, sigue los pasos de llamada a funciones genéricas que todas las funciones realizan a través de CALL_FUNCTION :

 dis('__import__(math)') 1 0 LOAD_NAME 0 (__import__) 2 LOAD_NAME 1 (math) 4 CALL_FUNCTION 1 6 RETURN_VALUE 

Claro, está integrado y es más rápido que las funciones normales de py, pero sigue siendo más lento que la statement de import con import_name .

Por eso, la diferencia de tiempo entre ellos es constante. Al usar el fragmento de código @MSeifert (que corrigió los tiempos injustos 🙂 y agregar otra impresión, puede ver esto:

 import timeit def test(module): exec("import {}".format(module)) t2 = timeit.timeit("{0} = __import__('{0}')".format(module)) t1 = timeit.timeit("import {}".format(module)) print("import statement: ", t1) print("__import__ function:", t2) print("t(statement) {} t(function)".format("<" if t1 < t2 else ">")) print('Diff: {}'.format(t2-t1)) for m in sys.builtin_module_names: test(m) 

En mi máquina, hay una diferencia constante de alrededor de 0,17 entre ellos (con una ligera variación que generalmente se espera)

_{* Vale la pena señalar que estos no son exactamente equivalentes. __import__ no hace ningún enlace de nombre como lo atestigua el bytecode.}