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.