This is a simplified interface to
PyImport_ImportModuleEx() below, leaving the
globals and locals arguments set to NULL. When the
name argument contains a dot (when it specifies a
submodule of a package), the fromlist argument is set to the
list ['*'] 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 (the module may still be
created in this case -- examine sys.modules to find out).
Import a module. This is best described by referring to the built-in
Python function __import__() as
the standard __import__() function calls this function
directly.
The return value is a new reference to the imported module or
top-level package, or NULL with an exception set on failure
(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.
This is a higher-level interface that calls the current ``import hook
function''. It invokes the __import__() function from the
__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 rexecor
ihooks
Reload a module. This is best described by referring to the built-in
Python function reload() as the standard
reload() function calls this function directly. Return a
new reference to the reloaded module, or NULL with an exception set
on failure (the module still exists in this case).
Return the module object corresponding to a module name. The
name argument may be of the form package.module). First
check the modules dictionary if there's one there, and if not, create
a new one and insert in in the modules dictionary.
Warning: 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.
Return NULL with an exception set on failure.
Given a module name (possibly of the form 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 (the module may still be created
in this case). (This function would reload the module if it was
already imported.)
Return the magic number for Python bytecode files (a.k.a.
.pyc and .pyo files). The magic number should be
present in the first four bytes of the bytecode file, in little-endian
byte order.
Load a frozen module named name. Return 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.)
This is the structure type definition for frozen module descriptors,
as generated by the freezeutility
(see Tools/freeze/ in the Python source distribution). Its
definition, found in Include/import.h, is:
This pointer is initialized to point to an array of struct
_frozen records, terminated by one whose members are all
NULL or zero. When a frozen module is imported, it is searched in
this table. Third-party code could play tricks with this to provide a
dynamically created collection of frozen modules.
Add a single module to the existing table of built-in modules. This
is a convenience wrapper around PyImport_ExtendInittab(),
returning -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().
Structure describing a single entry in the list of built-in modules.
Each of these structures gives the name and initialization function
for a module built into the interpreter. Programs which embed Python
may use an array of these structures in conjunction with
PyImport_ExtendInittab() to provide additional built-in
modules. The structure is defined in Include/import.h as:
Add a collection of modules to the table of built-in modules. The
newtab array must end with a sentinel entry which contains
NULL for the name field; failure to provide the sentinel
value can result in a memory fault. Returns 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().