How to re import an updated package while in Python Interpreter? [duplicate]
Update for Python3: (quoted from the already-answered answer, since the last edit/comment here suggested a deprecated method)
In Python 3,
reloadwas moved to the
impmodule. In 3.4,
impwas deprecated in favor of
reloadwas added to the latter. When targeting 3 or later, either reference the appropriate module when calling
reloador import it.
- Python3 >= 3.4:
- Python3 < 3.4:
- Python2: continue below
reload builtin function:
- Python modules’ code is recompiled and the module-level code reexecuted, defining a new set of objects which are bound to names in the module’s dictionary. The init function of extension modules is not called a second time.
- As with all other objects in Python the old objects are only reclaimed after their reference counts drop to zero.
- The names in the module namespace are updated to point to any new or changed objects.
- Other references to the old objects (such as names external to the module) are not rebound to refer to the new objects and must be updated in each namespace where they occur if that is desired.
# Make a simple function that prints "version 1"shell1$ echo 'def x(): print "version 1"' > mymodule.py# Run the moduleshell2$ pythonimport mymodule mymodule.x()version 1# Change mymodule to print "version 2" (without exiting the python REPL)shell2$ echo 'def x(): print "version 2"' > mymodule.py# Back in that same python sessionreload(mymodule)<module 'mymodule' from 'mymodule.pyc'> mymodule.x()version 2
So, far I have been exiting and reentering the Interpreter because re importing the file again is not working for me.
Yes, just saying
import again gives you the existing copy of the module from
You can say
reload(module) to update
sys.modules and get a new copy of that single module, but if any other modules have a reference to the original module or any object from the original module, they will keep their old references and Very Confusing Things will happen.
So if you've got a module
a, which depends on module
b changes, you have to ‘reload b’ followed by ‘reload a’. If you've got two modules which depend on each other, which is extremely common when those modules are part of the same package, you can't reload them both: if you reload
p.a it'll get a reference to the old
p.b, and vice versa. The only way to do it is to unload them both at once by deleting their items from
sys.modules, before importing them again. This is icky and has some practical pitfalls to do with modules entries being None as a failed-relative-import marker.
And if you've got a module which passes references to its objects to system modules — for example it registers a codec, or adds a warnings handler — you're stuck; you can't reload the system module without confusing the rest of the Python environment.
In summary: for all but the simplest case of one self-contained module being loaded by one standalone script,
reload() is very tricky to get right; if, as you imply, you are using a ‘package’, you will probably be better off continuing to cycle the interpreter.