script - ¿Cómo descargo(recargo) un módulo de Python?

lista de modulos de python

Question

Tengo un servidor Python de larga duración y me gustaría poder actualizar un servicio sin reiniciar el servidor. ¿Cuál es la mejor manera de hacer esto?

if foo.py has changed:
unimport foo <-- How do I do this?
import foo
myfoo = foo.Foo()

Answer 1

2018-02-01

1. El módulo foo debe importar con éxito por adelantado.
2. from importlib import reload , reload(foo)

31.5. importlib - La implementación de la importación - Documentación de Python 3.6.4

Answer 2

Aquellos que están usando python 3 y recargan desde importlib.

Si tiene problemas, parece que el módulo no se vuelve a cargar ... Esto se debe a que necesita algún tiempo para volver a compilar PyC (hasta 60 seg). Escribo esta sugerencia para saber si ha experimentado este tipo de problema.

Answer 3

El siguiente código le permite la compatibilidad con Python 2/3:

try:
reload
except NameError:
# Python 3
from imp import reload

Puede usarlo como reload() en ambas versiones, lo que simplifica las cosas.

Answer 4

En Python 3.0–3.3 imp.reload(module) : imp.reload(module)

El BDFL ha answered esta pregunta.

Sin embargo, imp fue desaprobado en 3.4, a favor de importlib (gracias @Stefan! ).

Creo que , por lo tanto, ahora usaría importlib.reload(module) , aunque no estoy seguro.

Answer 5

Enthought Traits tiene un módulo que funciona bastante bien para esto. https://traits.readthedocs.org/en/4.3.0/_modules/traits/util/refresh.html

Volverá a cargar cualquier módulo que se haya cambiado y actualizará otros módulos y objetos de instancia que lo estén utilizando. No funciona la mayor parte del tiempo con los métodos __very_private__ , y puede ahogarse con la herencia de clases, pero me ahorra __very_private__ tiempo de tener que reiniciar la aplicación del host al escribir guis PyQt, o cosas que se ejecutan dentro de programas como Maya o Nuke. . No funciona tal vez el 20-30% del tiempo, pero sigue siendo increíblemente útil.

El paquete de Enthought no vuelve a cargar los archivos en el momento en que cambian, debe llamarlo explícitamente, pero eso no debería ser tan difícil de implementar si realmente lo necesita.

Answer 6

Esta es la forma moderna de recargar un módulo:

from importlib import reload

Simplemente escriba reload(MODULE_NAME) , reemplazando MODULE_NAME con el nombre del módulo que desea recargar.

Por ejemplo, reload(math) recargará la función matemática.

Answer 7

La operación de unload puede realizar fácilmente de la siguiente manera:

import pythonlib
del pythonlib

Ya no tendrás nada relacionado con esa biblioteca.

Answer 8

La respuesta aceptada no maneja el caso de X import Y. Este código lo maneja y el caso de importación estándar también:

def importOrReload(module_name, *names):
import sys
if module_name in sys.modules:
reload(sys.modules[module_name])
else:
__import__(module_name, fromlist=names)
for name in names:
globals()[name] = getattr(sys.modules[module_name], name)
# use instead of: from dfly_parser import parseMessages
importOrReload("dfly_parser", "parseMessages")

En el caso de la recarga, reasignamos los nombres de nivel superior a los valores almacenados en el módulo recién recargado, que los actualiza.

Answer 9

Otra forma podría ser importar el módulo en una función. De esta manera cuando la función completa el módulo se recolecta la basura.

Answer 10

Otra opción. Vea que el importlib.reload predeterminado de Python solo reimportará la biblioteca pasada como un argumento. No volverá a cargar las bibliotecas que importa tu lib. Si ha cambiado muchos archivos y tiene que importar un paquete algo complejo, debe hacer una recarga profunda .

Si tiene instalado IPython o Jupyter , puede usar una función para volver a cargar todas las librerías:

from IPython.lib.deepreload import reload as dreload
dreload(foo)

Si no tienes Jupyter, instálalo con este comando en tu shell:

pip3 install jupyter

Answer 11

Para Python 2 use la función incorporada reload() :

reload(module)

Para Python 2 y 3.2–3.3 use reload from module imp :

import imp
imp.reload(module)

Pero imp está obsoleto desde la versión 3.4 a favor de importlib , así que use:

import importlib
importlib.reload(module)

o

from importlib import reload
reload(module)

Answer 12

Para aquellos como yo que quieren descargar todos los módulos (cuando se ejecutan en el intérprete de Python bajo Emacs ):

 for mod in sys.modules.values():
reload(mod)

Más información está en la pyunit.sourceforge.net/notes/reloading.html .

Answer 13

Para mí, para el caso de Abaqus, es la forma en que funciona. Imagina que tu archivo es Class_VerticesEdges.py

sys.path.append(''D:/.../My Pythons'')
if ''Class_VerticesEdges'' in sys.modules:
del sys.modules[''Class_VerticesEdges'']
print ''old module Class_VerticesEdges deleted''
from Class_VerticesEdges import *
reload(sys.modules[''Class_VerticesEdges''])

Answer 14

Puede ser especialmente difícil eliminar un módulo si no es Python puro.

Aquí hay alguna información de: ¿Cómo elimino realmente un módulo importado?

Puede usar sys.getrefcount () para averiguar el número real de referencias.

>>> import sys, empty, os
>>> sys.getrefcount(sys)
9
>>> sys.getrefcount(os)
6
>>> sys.getrefcount(empty)
3

Los números mayores de 3 indican que será difícil deshacerse del módulo. El módulo "vacío" (que no contiene nada) de cosecha propia debe ser recolectado después de la basura

>>> del sys.modules["empty"]
>>> del empty

como la tercera referencia es un artefacto de la función getrefcount ().

Answer 15

Puede volver a cargar un módulo cuando ya se haya importado utilizando la función incorporada de reload :

from importlib import reload # Python 3.4+ only.
import foo
while True:
# Do some things.
if is_changed(foo):
foo = reload(foo)

En Python 3, la reload se movió al módulo imp . En 3.4, imp fue desaprobado a favor de importlib , y se agregó reload a este último. Cuando apunte a 3 o más tarde, haga referencia al módulo apropiado cuando llame a reload o importe.

Creo que esto es lo que quieres. Los servidores web como el servidor de desarrollo de Django usan esto para que pueda ver los efectos de los cambios en su código sin reiniciar el proceso del servidor.

Para citar de los documentos:

El código de los módulos de Python se vuelve a compilar y el código a nivel de módulo se vuelve a ejecutar, definiendo un nuevo conjunto de objetos que están vinculados a nombres en el diccionario del módulo. La función de inicio de los módulos de extensión no se llama una segunda vez. Al igual que con todos los demás objetos en Python, los objetos antiguos solo se reclaman después de que sus recuentos de referencia caigan a cero. Los nombres en el espacio de nombres del módulo se actualizan para apuntar a cualquier objeto nuevo o modificado. Otras referencias a los objetos antiguos (como los nombres externos al módulo) no rebotan para referirse a los nuevos objetos y deben actualizarse en cada espacio de nombres donde ocurran, si así se desea.

Como anotó en su pregunta, tendrá que reconstruir los objetos Foo si la clase Foo reside en el módulo foo .

Answer 16

Si no está en un servidor, pero está desarrollando y necesita volver a cargar un módulo con frecuencia, aquí tiene un buen consejo.

Primero, asegúrese de que está utilizando el excelente shell IPython , del proyecto de Jupyter Notebook. Después de instalar Jupyter, puedes iniciarlo con ipython , o jupyter console , o incluso mejor, jupyter qtconsole , que te dará una bonita consola coloreada con finalización de código en cualquier sistema operativo.

Ahora en tu shell, escribe:

%load_ext autoreload
%autoreload 2

Ahora, cada vez que ejecute su script, sus módulos se volverán a cargar.

Más allá de los 2 , hay otras opciones de la magia de carga automática :

%autoreload
Reload all modules (except those excluded by %aimport) automatically now.
%autoreload 0
Disable automatic reloading.
%autoreload 1
Reload all modules imported with %aimport every time before executing the Python code typed.
%autoreload 2
Reload all modules (except those excluded by %aimport) every time before
executing the Python code typed.

Answer 17

Tengo muchos problemas al intentar recargar algo dentro de Sublime Text, pero finalmente pude escribir esta utilidad para recargar módulos en Sublime Text basado en el código que sublime_plugin.py usa para recargar módulos.

Esto a continuación le permite volver a cargar módulos desde rutas con espacios en sus nombres, luego, después de la carga, puede importar como lo hace normalmente.

def reload_module(full_module_name):
"""
Assuming the folder `full_module_name` is a folder inside some
folder on the python sys.path, for example, sys.path as `C:/`, and
you are inside the folder `C:/Path With Spaces` on the file
`C:/Path With Spaces/main.py` and want to re-import some files on
the folder `C:/Path With Spaces/tests`
@param full_module_name the relative full path to the module file
you want to reload from a folder on the
python `sys.path`
"""
import imp
import sys
import importlib
if full_module_name in sys.modules:
module_object = sys.modules[full_module_name]
module_object = imp.reload( module_object )
else:
importlib.import_module( full_module_name )
def run_tests():
print( "/n/n" )
reload_module( "Path With Spaces.tests.semantic_linefeed_unit_tests" )
reload_module( "Path With Spaces.tests.semantic_linefeed_manual_tests" )
from .tests import semantic_linefeed_unit_tests
from .tests import semantic_linefeed_manual_tests
semantic_linefeed_unit_tests.run_unit_tests()
semantic_linefeed_manual_tests.run_manual_tests()
if __name__ == "__main__":
run_tests()

Si ejecuta por primera vez, esto debería cargar el módulo, pero si más tarde puede volver a run_tests() el método / función run_tests() , volverá a cargar los archivos de prueba. Con Sublime Text ( Python 3.3.6 ) esto sucede mucho porque su intérprete nunca se cierra (a menos que reinicie Sublime Text, es decir, el intérprete de Python3.3 ).

Answer 18

reload(module) , pero solo si es completamente independiente. Si algo más tiene una referencia al módulo (o cualquier objeto que pertenezca al módulo), entonces obtendrá errores sutiles y curiosos causados ​​por el código antiguo que isinstance más tiempo de lo que esperaba, y cosas como la isinstance no funciona en diferentes versiones de El mismo código.

Si tiene dependencias unidireccionales, también debe volver a cargar todos los módulos que dependen del módulo recargado para deshacerse de todas las referencias al código anterior. Y luego recargue los módulos que dependen de los módulos recargados, recursivamente.

Si tiene dependencias circulares, lo cual es muy común, por ejemplo, cuando se trata de volver a cargar un paquete, debe descargar todos los módulos del grupo de una sola vez. No puede hacer esto con reload() porque reimportará cada módulo antes de que sus dependencias se hayan actualizado, permitiendo que las referencias antiguas se introduzcan en nuevos módulos.

La única forma de hacerlo en este caso es hackear sys.modules , lo cual no es compatible. Tendría que revisar y eliminar cada entrada de sys.modules que deseaba volver a cargar en la próxima importación, y también eliminar las entradas cuyos valores son None para tratar un problema de implementación relacionado con el almacenamiento en caché de importaciones relativas fallidas. No es terriblemente agradable, pero siempre que tenga un conjunto de dependencias totalmente autónomo que no deje referencias fuera de su base de código, es viable.

Probablemente sea mejor reiniciar el servidor. :-)

Answer 19

if ''myModule'' in sys.modules:
del sys.modules["myModule"]