Importing modules dynamically

First, let's look at how you normally import modules. The import module syntax looks in the search path for the
named module and imports it by name. You can even import multiple modules at once this way, with a
comma−separated list. You did this on the very first line of this chapter's script.
Example 16.13. Importing multiple modules at once
import sys, os, re, unittest
This imports four modules at once: sys (for system functions and access to the command line
parameters), os (for operating system functions like directory listings), re (for regular expressions), and
unittest (for unit testing).
Now let's do the same thing, but with dynamic imports.
Example 16.14. Importing modules dynamically
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
sys = __import__('sys')
os = __import__('os')
re = __import__('re')
unittest = __import__('unittest')
sys

os


The built−in __import__ function accomplishes the same goal as using the import statement, but
it's an actual function, and it takes a string as an argument.
The variable sys is now the sys module, just as if you had said import sys. The variable os is
now the os module, and so forth.
So __import__ imports a module, but takes a string argument to do it. In this case the module you imported was
just a hard−coded string, but it could just as easily be a variable, or the result of a function call. And the variable that
you assign the module to doesn't need to match the module name, either. You could import a series of modules and
assign them to a list.

Example 16.15. Importing a list of modules dynamically
>>> moduleNames = ['sys', 'os', 're', 'unittest']
>>> moduleNames
['sys', 'os', 're', 'unittest']
>>> modules = map(__import__, moduleNames)
>>> modules
[,
,
,
]
>>> modules[0].version
'2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)]'
>>> import sys
>>> sys.version
'2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)]'

moduleNames is just a list of strings. Nothing fancy, except that the strings happen to be names
of modules that you could import, if you wanted to.
Surprise, you wanted to import them, and you did, by mapping the __import__ function onto
the list. Remember, this takes each element of the list (moduleNames) and calls the function
(__import__) over and over, once with each element of the list, builds a list of the return
values, and returns the result.
So now from a list of strings, you've created a list of actual modules. (Your paths may be
different, depending on your operating system, where you installed Python, the phase of the
moon, etc.)
To drive home the point that these are real modules, let's look at some module attributes.
Remember, modules[0] is the sys module, so modules[0].version is sys.version.
All the other attributes and methods of these modules are also available. There's nothing magic
about the import statement, and there's nothing magic about modules. Modules are objects.
Everything is an object.