Python: How to load a module twice?

Is there a way to load a module twice in the same python session?

To fill this question with an example: Here is a开发者_如何学编程 module:

Mod.py

x = 0

Now I would like to import that module twice, like creating two instances of a class to have actually two copies of x.

To already answer the questions in the comments, "why anyone would want to do that if they could just create a class with x as a variable":

You are correct, but there exists some huge amount of source that would have to be rewritten, and loading a module twice would be a quick fix^^.

Yes, you can load a module twice:

import mod
import sys
del sys.modules["mod"]
import mod as mod2

Now, mod and mod2 are two instances of the same module.

That said, I doubt this is ever useful. Use classes instead -- eventually it will be less work.

Edit: In Python 2.x, you can also use the following code to "manually" import a module:

import imp

def my_import(name):
    file, pathname, description = imp.find_module(name)
    code = compile(file.read(), pathname, "exec", dont_inherit=True)
    file.close()
    module = imp.new_module(name)
    exec code in module.__dict__
    return module

This solution might be more flexible than the first one. You no longer have to "fight" the import mechanism since you are (partly) rolling your own one. (Note that this implementation doesn't set the __file__, __path__ and __package__ attributes of the module -- if these are needed, just add code to set them.)

Deleting an entry from sys.modules will not necessarily work (e.g. it will fail when importing recurly twice, if you want to work with multiple recurly accounts in the same app etc.)

Another way to accomplish this is:

>>> import importlib
>>> spec = importlib.util.find_spec(module_name)
>>> instance_one = importlib.util.module_from_spec(spec)
>>> instance_two = importlib.util.module_from_spec(spec)
>>> instance_one == instance_two
False

You could use the __import__ function.

module1 = __import__("module")
module2 = __import__("module")

Edit: As it turns out, this does not import two separate versions of the module, instead module1 and module2 will point to the same object, as pointed out by Sven.