| char *name) | 
['*'] so that the return value is the named module rather
  than the top-level package containing it as would otherwise be the
  case.  (Unfortunately, this has an additional side effect when
  name in fact specifies a subpackage instead of a submodule:
  the submodules specified in the package's __all__ variable
  are 
  loaded.)  Return
  a new reference to the imported module, or NULL with an exception
  set on failure.  Before Python 2.4, the module may still be created in
  the failure case -- examine sys.modules to find out.  Starting
  with Python 2.4, a failing import of a module no longer leaves the
  module in sys.modules.
  
Changed in version 2.4:
failing imports remove incomplete module objects.
  
| char *name, PyObject *globals, PyObject *locals, PyObject *fromlist) | 
The return value is a new reference to the imported module or top-level package, or NULL with an exception set on failure (before Python 2.4, the module may still be created in this case). Like for __import__(), the return value when a submodule of a package was requested is normally the top-level package, unless a non-empty fromlist was given. Changed in version 2.4: failing imports remove incomplete module objects.
| PyObject *name) | 
__builtins__ of the current globals.  This means
  that the import is done using whatever import hooks are installed in
  the current environment, e.g. by rexec
  or ihooks.
| PyObject *m) | 
| char *name) | 
package.module.
  First check the modules dictionary if there's one there, and if not,
  create a new one and insert it in the modules dictionary.
  Return NULL with an exception set on failure.
  Note:
This function does not load or import the module; if the
  module wasn't already loaded, you will get an empty module object.
  Use PyImport_ImportModule() or one of its variants to
  import a module.  Package structures implied by a dotted name for
  name are not created if not already present.
| char *name, PyObject *co) | 
package.module) and
  a code object read from a Python bytecode file or obtained from the
  built-in function compile(), load
  the module.  Return a new reference to the module object, or NULL
  with an exception set if an error occurred.  Before Python 2.4, the module
  could still be created in error cases.  Starting with Python 2.4,
  name is removed from sys.modules in error cases, and even
  if name was already in sys.modules on entry to
  PyImport_ExecCodeModule().  Leaving incompletely initialized
  modules in sys.modules is dangerous, as imports of such modules
  have no way to know that the module object is an unknown (and probably
  damaged with respect to the module author's intents) state.
This function will reload the module if it was already imported. See PyImport_ReloadModule() for the intended way to reload a module.
If name points to a dotted name of the
  form package.module, any package structures not already
  created will still not be created.
Changed in version 2.4:
name is removed from sys.modules in error cases.
| ) | 
| ) | 
sys.modules).  Note that this is a per-interpreter
  variable.
| ) | 
| ) | 
| ) | 
| char *, char *) | 
| char *, char *) | 
| char *name) | 
1 for success,
  0 if the module is not found, and -1 with an exception
  set if the initialization failed.  To access the imported module on
  a successful load, use PyImport_ImportModule().  (Note
  the misnomer -- this function would reload the module if it was
  already imported.)
struct _frozen {
    char *name;
    unsigned char *code;
    int size;
};
| char *name, void (*initfunc)(void)) | 
-1 if the
  table could not be extended.  The new module can be imported by the
  name name, and uses the function initfunc as the
  initialization function called on the first attempted import.  This
  should be called before Py_Initialize().
struct _inittab {
    char *name;
    void (*initfunc)(void);
};
| struct _inittab *newtab) | 
0 on success or
  -1 if insufficient memory could be allocated to extend the
  internal table.  In the event of failure, no modules are added to
  the internal table.  This should be called before
  Py_Initialize().
See About this document... for information on suggesting changes.