New in version 3.8.
Structures:
Functions:
PyConfig_Clear()
PyConfig_InitIsolatedConfig()
PyConfig_InitPythonConfig()
PyConfig_Read()
PyConfig_SetArgv()
PyConfig_SetBytesArgv()
PyConfig_SetBytesString()
PyConfig_SetString()
PyConfig_SetWideStringList()
PyPreConfig_InitIsolatedConfig()
PyPreConfig_InitPythonConfig()
PyStatus_Error()
PyStatus_Exception()
PyStatus_Exit()
PyStatus_IsError()
PyStatus_IsExit()
PyStatus_NoMemory()
PyStatus_Ok()
PyWideStringList_Append()
PyWideStringList_Insert()
Py_ExitStatusException()
Py_InitializeFromConfig()
Py_PreInitialize()
Py_PreInitializeFromArgs()
Py_PreInitializeFromBytesArgs()
Py_RunMain()
Py_GetArgcArgv()
The preconfiguration (PyPreConfig
type) is stored in
_PyRuntime.preconfig
and the configuration (PyConfig
type) is stored in
PyInterpreterState.config
.
See also Initialization, Finalization, and Threads.
PyWideStringList
List of wchar_t*
strings.
If length is non-zero, items must be non-NULL
and all strings must be
non-NULL
.
Methods:
PyWideStringList_Append
(PyWideStringList *list, const wchar_t *item)Append item to list.
Python must be preinitialized to call this function.
PyWideStringList_Insert
(PyWideStringList *list, Py_ssize_t index, const wchar_t *item)Insert item into list at index.
If index is greater than or equal to list length, append item to list.
index must be greater than or equal to 0.
Python must be preinitialized to call this function.
Structure fields:
length
List length.
items
List items.
PyStatus
Structure to store an initialization function status: success, error or exit.
For an error, it can store the C function name which created the error.
Structure fields:
exitcode
Exit code. Argument passed to exit()
.
err_msg
Error message.
func
Name of the function which created an error, can be NULL
.
Functions to create a status:
PyStatus_Ok
(void)Success.
PyStatus_Error
(const char *err_msg)Initialization error with a message.
PyStatus_NoMemory
(void)Memory allocation failure (out of memory).
PyStatus_Exit
(int exitcode)Exit Python with the specified exit code.
Functions to handle a status:
PyStatus_Exception
(PyStatus status)Is the status an error or an exit? If true, the exception must be
handled; by calling Py_ExitStatusException()
for example.
PyStatus_IsError
(PyStatus status)Is the result an error?
PyStatus_IsExit
(PyStatus status)Is the result an exit?
Py_ExitStatusException
(PyStatus status)Call exit(exitcode)
if status is an exit. Print the error
message and exit with a non-zero exit code if status is an error. Must
only be called if PyStatus_Exception(status)
is non-zero.
Note
Internally, Python uses macros which set PyStatus.func
,
whereas functions to create a status set func
to NULL
.
Example:
PyStatus alloc(void **ptr, size_t size)
{
*ptr = PyMem_RawMalloc(size);
if (*ptr == NULL) {
return PyStatus_NoMemory();
}
return PyStatus_Ok();
}
int main(int argc, char **argv)
{
void *ptr;
PyStatus status = alloc(&ptr, 16);
if (PyStatus_Exception(status)) {
Py_ExitStatusException(status);
}
PyMem_Free(ptr);
return 0;
}
PyPreConfig
Structure used to preinitialize Python:
Set the Python memory allocator
Configure the LC_CTYPE locale
Set the UTF-8 mode
Function to initialize a preconfiguration:
PyPreConfig_InitPythonConfig
(PyPreConfig *preconfig)Initialize the preconfiguration with Python Configuration.
PyPreConfig_InitIsolatedConfig
(PyPreConfig *preconfig)Initialize the preconfiguration with Isolated Configuration.
Structure fields:
allocator
Name of the memory allocator:
PYMEM_ALLOCATOR_NOT_SET
(0
): don’t change memory allocators
(use defaults)
PYMEM_ALLOCATOR_DEFAULT
(1
): default memory allocators
PYMEM_ALLOCATOR_DEBUG
(2
): default memory allocators with
debug hooks
PYMEM_ALLOCATOR_MALLOC
(3
): force usage of malloc()
PYMEM_ALLOCATOR_MALLOC_DEBUG
(4
): force usage of
malloc()
with debug hooks
PYMEM_ALLOCATOR_PYMALLOC
(5
): Python pymalloc memory
allocator
PYMEM_ALLOCATOR_PYMALLOC_DEBUG
(6
): Python pymalloc
memory allocator with debug hooks
PYMEM_ALLOCATOR_PYMALLOC
and PYMEM_ALLOCATOR_PYMALLOC_DEBUG
are not supported if Python is configured using --without-pymalloc
See Memory Management.
configure_locale
Set the LC_CTYPE locale to the user preferred locale? If equals to 0, set
coerce_c_locale
and coerce_c_locale_warn
to 0.
coerce_c_locale
If equals to 2, coerce the C locale; if equals to 1, read the LC_CTYPE locale to decide if it should be coerced.
coerce_c_locale_warn
If non-zero, emit a warning if the C locale is coerced.
dev_mode
See PyConfig.dev_mode
.
isolated
See PyConfig.isolated
.
legacy_windows_fs_encoding
(Windows only)If non-zero, disable UTF-8 Mode, set the Python filesystem encoding to
mbcs
, set the filesystem error handler to replace
.
Only available on Windows. #ifdef MS_WINDOWS
macro can be used for
Windows specific code.
parse_argv
If non-zero, Py_PreInitializeFromArgs()
and
Py_PreInitializeFromBytesArgs()
parse their argv
argument the
same way the regular Python parses command line arguments: see
Command Line Arguments.
use_environment
utf8_mode
If non-zero, enable the UTF-8 mode.
Functions to preinitialize Python:
Py_PreInitialize
(const PyPreConfig *preconfig)Py_PreInitializeFromBytesArgs
(const PyPreConfig *preconfig, int argc, char * const *argv)Py_PreInitializeFromArgs
(const PyPreConfig *preconfig, int argc, wchar_t * const * argv)The caller is responsible to handle exceptions (error or exit) using
PyStatus_Exception()
and Py_ExitStatusException()
.
For Python Configuration
(PyPreConfig_InitPythonConfig()
), if Python is initialized with
command line arguments, the command line arguments must also be passed to
preinitialize Python, since they have an effect on the pre-configuration
like encodings. For example, the -X utf8
command line option
enables the UTF-8 Mode.
PyMem_SetAllocator()
can be called after Py_PreInitialize()
and
before Py_InitializeFromConfig()
to install a custom memory allocator.
It can be called before Py_PreInitialize()
if
PyPreConfig.allocator
is set to PYMEM_ALLOCATOR_NOT_SET
.
Python memory allocation functions like PyMem_RawMalloc()
must not be
used before Python preinitialization, whereas calling directly malloc()
and
free()
is always safe. Py_DecodeLocale()
must not be called before
the preinitialization.
Example using the preinitialization to enable the UTF-8 Mode:
PyStatus status;
PyPreConfig preconfig;
PyPreConfig_InitPythonConfig(&preconfig);
preconfig.utf8_mode = 1;
status = Py_PreInitialize(&preconfig);
if (PyStatus_Exception(status)) {
Py_ExitStatusException(status);
}
/* at this point, Python will speak UTF-8 */
Py_Initialize();
/* ... use Python API here ... */
Py_Finalize();
PyConfig
Structure containing most parameters to configure Python.
Structure methods:
PyConfig_InitPythonConfig
(PyConfig *config)Initialize configuration with Python Configuration.
PyConfig_InitIsolatedConfig
(PyConfig *config)Initialize configuration with Isolated Configuration.
PyConfig_SetString
(PyConfig *config, wchar_t * const *config_str, const wchar_t *str)Copy the wide character string str into *config_str
.
Preinitialize Python if needed.
PyConfig_SetBytesString
(PyConfig *config, wchar_t * const *config_str, const char *str)Decode str using Py_DecodeLocale()
and set the result into *config_str
.
Preinitialize Python if needed.
PyConfig_SetArgv
(PyConfig *config, int argc, wchar_t * const *argv)Set command line arguments from wide character strings.
Preinitialize Python if needed.
PyConfig_SetBytesArgv
(PyConfig *config, int argc, char * const *argv)Set command line arguments: decode bytes using Py_DecodeLocale()
.
Preinitialize Python if needed.
PyConfig_SetWideStringList
(PyConfig *config, PyWideStringList *list, Py_ssize_t length, wchar_t **items)Set the list of wide strings list to length and items.
Preinitialize Python if needed.
PyConfig_Read
(PyConfig *config)Read all Python configuration.
Fields which are already initialized are left unchanged.
Preinitialize Python if needed.
PyConfig_Clear
(PyConfig *config)Release configuration memory.
Most PyConfig
methods preinitialize Python if needed. In that case, the
Python preinitialization configuration in based on the PyConfig
.
If configuration fields which are in common with PyPreConfig
are
tuned, they must be set before calling a PyConfig
method:
Moreover, if PyConfig_SetArgv()
or PyConfig_SetBytesArgv()
is used, this method must be called first, before other methods, since the
preinitialization configuration depends on command line arguments (if
parse_argv
is non-zero).
The caller of these methods is responsible to handle exceptions (error or
exit) using PyStatus_Exception()
and Py_ExitStatusException()
.
Structure fields:
argv
Command line arguments, sys.argv
. See
parse_argv
to parse argv
the
same way the regular Python parses Python command line arguments. If
argv
is empty, an empty string is added to ensure
that sys.argv
always exists and is never empty.
base_exec_prefix
base_executable
sys._base_executable
: __PYVENV_LAUNCHER__
environment
variable value, or copy of PyConfig.executable
.
base_prefix
platlibdir
sys.platlibdir
: platform library directory name, set at configure time
by --with-platlibdir
, overrideable by the PYTHONPLATLIBDIR
environment variable.
New in version 3.9.
buffered_stdio
If equals to 0, enable unbuffered mode, making the stdout and stderr streams unbuffered.
stdin is always opened in buffered mode.
bytes_warning
If equals to 1, issue a warning when comparing bytes
or
bytearray
with str
, or comparing bytes
with
int
. If equal or greater to 2, raise a BytesWarning
exception.
check_hash_pycs_mode
Control the validation behavior of hash-based .pyc
files (see
PEP 552): --check-hash-based-pycs
command line option value.
Valid values: always
, never
and default
.
The default value is: default
.
configure_c_stdio
If non-zero, configure C standard streams (stdio
, stdout
,
stdout
). For example, set their mode to O_BINARY
on Windows.
dev_mode
If non-zero, enable the Python Development Mode.
dump_refs
If non-zero, dump all objects which are still alive at exit.
Py_TRACE_REFS
macro must be defined in build.
exec_prefix
executable
faulthandler
If non-zero, call faulthandler.enable()
at startup.
filesystem_encoding
Filesystem encoding, sys.getfilesystemencoding()
.
filesystem_errors
Filesystem encoding errors, sys.getfilesystemencodeerrors()
.
hash_seed
use_hash_seed
Randomized hash function seed.
If use_hash_seed
is zero, a seed is chosen randomly
at Pythonstartup, and hash_seed
is ignored.
home
Python home directory.
Initialized from PYTHONHOME
environment variable value by
default.
import_time
If non-zero, profile import time.
inspect
Enter interactive mode after executing a script or a command.
install_signal_handlers
Install signal handlers?
interactive
Interactive mode.
isolated
If greater than 0, enable isolated mode:
sys.path
contains neither the script’s directory (computed from
argv[0]
or the current directory) nor the user’s site-packages
directory.
Python REPL doesn’t import readline
nor enable default readline
configuration on interactive prompts.
Set use_environment
and
user_site_directory
to 0.
legacy_windows_stdio
If non-zero, use io.FileIO
instead of
io.WindowsConsoleIO
for sys.stdin
, sys.stdout
and sys.stderr
.
Only available on Windows. #ifdef MS_WINDOWS
macro can be used for
Windows specific code.
malloc_stats
If non-zero, dump statistics on Python pymalloc memory allocator at exit.
The option is ignored if Python is built using --without-pymalloc
.
pythonpath_env
Module search paths as a string separated by DELIM
(os.path.pathsep
).
Initialized from PYTHONPATH
environment variable value by
default.
module_search_paths
module_search_paths_set
sys.path
. If module_search_paths_set
is
equal to 0, the module_search_paths
is overridden
by the function calculating the Path Configuration.
optimization_level
Compilation optimization level:
0: Peephole optimizer (and __debug__
is set to True
)
1: Remove assertions, set __debug__
to False
2: Strip docstrings
parse_argv
If non-zero, parse argv
the same way the regular
Python command line arguments, and strip Python arguments from
argv
: see Command Line Arguments.
parser_debug
If non-zero, turn on parser debugging output (for expert only, depending on compilation options).
pathconfig_warnings
If equal to 0, suppress warnings when calculating the Path
Configuration (Unix only, Windows does not log any
warning). Otherwise, warnings are written into stderr
.
prefix
program_name
Program name. Used to initialize executable
, and in
early error messages.
pycache_prefix
sys.pycache_prefix
: .pyc
cache prefix.
If NULL
, sys.pycache_prefix
is set to None
.
quiet
Quiet mode. For example, don’t display the copyright and version messages in interactive mode.
run_command
python3 -c COMMAND
argument. Used by Py_RunMain()
.
run_filename
python3 FILENAME
argument. Used by Py_RunMain()
.
run_module
python3 -m MODULE
argument. Used by Py_RunMain()
.
show_ref_count
Show total reference count at exit?
Set to 1 by -X showrefcount
command line option.
Need a debug build of Python (Py_REF_DEBUG
macro must be defined).
site_import
Import the site
module at startup?
skip_source_first_line
Skip the first line of the source?
stdio_encoding
stdio_errors
Encoding and encoding errors of sys.stdin
, sys.stdout
and
sys.stderr
.
tracemalloc
If non-zero, call tracemalloc.start()
at startup.
use_environment
If greater than 0, use environment variables.
user_site_directory
If non-zero, add user site directory to sys.path
.
verbose
If non-zero, enable verbose mode.
warnoptions
sys.warnoptions
: options of the warnings
module to build
warnings filters: lowest to highest priority.
The warnings
module adds sys.warnoptions
in the reverse
order: the last PyConfig.warnoptions
item becomes the first
item of warnings.filters
which is checked first (highest
priority).
write_bytecode
If non-zero, write .pyc
files.
sys.dont_write_bytecode
is initialized to the inverted value of
write_bytecode
.
xoptions
_use_peg_parser
Enable PEG parser? Default: 1.
Set to 0 by -X oldparser
and PYTHONOLDPARSER
.
See also PEP 617.
Deprecated since version 3.9, will be removed in version 3.10.
If parse_argv
is non-zero, argv
arguments are parsed the same
way the regular Python parses command line arguments, and Python
arguments are stripped from argv
: see Command Line Arguments.
The xoptions
options are parsed to set other options: see -X
option.
Changed in version 3.9: The show_alloc_count
field has been removed.
Function to initialize Python:
Py_InitializeFromConfig
(const PyConfig *config)The caller is responsible to handle exceptions (error or exit) using
PyStatus_Exception()
and Py_ExitStatusException()
.
If PyImport_FrozenModules
, PyImport_AppendInittab()
or
PyImport_ExtendInittab()
are used, they must be set or called after Python
preinitialization and before the Python initialization.
Example setting the program name:
void init_python(void)
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);
/* Set the program name. Implicitly preinitialize Python. */
status = PyConfig_SetString(&config, &config.program_name,
L"/path/to/my_program");
if (PyStatus_Exception(status)) {
goto fail;
}
status = Py_InitializeFromConfig(&config);
if (PyStatus_Exception(status)) {
goto fail;
}
PyConfig_Clear(&config);
return;
fail:
PyConfig_Clear(&config);
Py_ExitStatusException(status);
}
More complete example modifying the default configuration, read the configuration, and then override some parameters:
PyStatus init_python(const char *program_name)
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);
/* Set the program name before reading the configuration
(decode byte string from the locale encoding).
Implicitly preinitialize Python. */
status = PyConfig_SetBytesString(&config, &config.program_name,
program_name);
if (PyStatus_Exception(status)) {
goto done;
}
/* Read all configuration at once */
status = PyConfig_Read(&config);
if (PyStatus_Exception(status)) {
goto done;
}
/* Append our custom search path to sys.path */
status = PyWideStringList_Append(&config.module_search_paths,
L"/path/to/more/modules");
if (PyStatus_Exception(status)) {
goto done;
}
/* Override executable computed by PyConfig_Read() */
status = PyConfig_SetString(&config, &config.executable,
L"/path/to/my_executable");
if (PyStatus_Exception(status)) {
goto done;
}
status = Py_InitializeFromConfig(&config);
done:
PyConfig_Clear(&config);
return status;
}
PyPreConfig_InitIsolatedConfig()
and
PyConfig_InitIsolatedConfig()
functions create a configuration to
isolate Python from the system. For example, to embed Python into an
application.
This configuration ignores global configuration variables, environments
variables, command line arguments (PyConfig.argv
is not parsed)
and user site directory. The C standard streams (ex: stdout
) and the
LC_CTYPE locale are left unchanged. Signal handlers are not installed.
Configuration files are still used with this configuration. Set the Path Configuration (“output fields”) to ignore these configuration files and avoid the function computing the default path configuration.
PyPreConfig_InitPythonConfig()
and PyConfig_InitPythonConfig()
functions create a configuration to build a customized Python which behaves as
the regular Python.
Environments variables and command line arguments are used to configure Python, whereas global configuration variables are ignored.
This function enables C locale coercion (PEP 538) and UTF-8 Mode
(PEP 540) depending on the LC_CTYPE locale, PYTHONUTF8
and
PYTHONCOERCECLOCALE
environment variables.
Example of customized Python always running in isolated mode:
int main(int argc, char **argv)
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);
config.isolated = 1;
/* Decode command line arguments.
Implicitly preinitialize Python (in isolated mode). */
status = PyConfig_SetBytesArgv(&config, argc, argv);
if (PyStatus_Exception(status)) {
goto fail;
}
status = Py_InitializeFromConfig(&config);
if (PyStatus_Exception(status)) {
goto fail;
}
PyConfig_Clear(&config);
return Py_RunMain();
fail:
PyConfig_Clear(&config);
if (PyStatus_IsExit(status)) {
return status.exitcode;
}
/* Display the error message and exit the process with
non-zero exit code */
Py_ExitStatusException(status);
}
PyConfig
contains multiple fields for the path configuration:
PyConfig.home
PyConfig.platlibdir
PyConfig.pathconfig_warnings
PyConfig.program_name
PyConfig.pythonpath_env
PATH
environment variable to get the program full path (from PyConfig.program_name
)__PYVENV_LAUNCHER__
environment variableIf at least one “output field” is not set, Python calculates the path
configuration to fill unset fields. If
module_search_paths_set
is equal to 0,
module_search_paths
is overridden and
module_search_paths_set
is set to 1.
It is possible to completely ignore the function calculating the default
path configuration by setting explicitly all path configuration output
fields listed above. A string is considered as set even if it is non-empty.
module_search_paths
is considered as set if
module_search_paths_set
is set to 1. In this case, path
configuration input fields are ignored as well.
Set pathconfig_warnings
to 0 to suppress warnings when
calculating the path configuration (Unix only, Windows does not log any warning).
If base_prefix
or base_exec_prefix
fields are not set, they inherit their value from prefix
and exec_prefix
respectively.
Py_RunMain()
and Py_Main()
modify sys.path
:
run_filename
is set and is a directory which contains a __main__.py
script, prepend run_filename
to sys.path
.isolated
is zero:
run_module
is set, prepend the current directory to sys.path
. Do nothing if the current directory cannot be read.run_filename
is set, prepend the directory of the filename to sys.path
.sys.path
.If site_import
is non-zero, sys.path
can be
modified by the site
module. If
user_site_directory
is non-zero and the user’s
site-package directory exists, the site
module appends the user’s
site-package directory to sys.path
.
The following configuration files are used by the path configuration:
pyvenv.cfg
python._pth
(Windows only)pybuilddir.txt
(Unix only)The __PYVENV_LAUNCHER__
environment variable is used to set
PyConfig.base_executable
Py_RunMain
(void)Execute the command (PyConfig.run_command
), the script
(PyConfig.run_filename
) or the module
(PyConfig.run_module
) specified on the command line or in the
configuration.
By default and when if -i
option is used, run the REPL.
Finally, finalizes Python and returns an exit status that can be passed to
the exit()
function.
See Python Configuration for an example of
customized Python always running in isolated mode using
Py_RunMain()
.
Py_GetArgcArgv
(int *argc, wchar_t ***argv)
This section is a private provisional API introducing multi-phase initialization, the core feature of the PEP 432:
importlib
;sys
module initialization (ex: create sys.stdout
and sys.path
);faulthandler
and tracemalloc
;site
module;Private provisional API:
PyConfig._init_main
: if set to 0, Py_InitializeFromConfig()
stops at the “Core” initialization phase.PyConfig._isolated_interpreter
: if non-zero, disallow threads, subprocesses and fork._Py_InitializeMain
(void)No module is imported during the “Core” phase and the importlib
module is
not configured: the Path Configuration is only
applied during the “Main” phase. It may allow to customize Python in Python to
override or tune the Path Configuration, maybe
install a custom sys.meta_path
importer or an import hook, etc.
It may become possible to calculatin the Path Configuration in Python, after the Core phase and before the Main phase, which is one of the PEP 432 motivation.
The “Core” phase is not properly defined: what should be and what should not be available at this phase is not specified yet. The API is marked as private and provisional: the API can be modified or even be removed anytime until a proper public API is designed.
Example running Python code between “Core” and “Main” initialization phases:
void init_python(void)
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);
config._init_main = 0;
/* ... customize 'config' configuration ... */
status = Py_InitializeFromConfig(&config);
PyConfig_Clear(&config);
if (PyStatus_Exception(status)) {
Py_ExitStatusException(status);
}
/* Use sys.stderr because sys.stdout is only created
by _Py_InitializeMain() */
int res = PyRun_SimpleString(
"import sys; "
"print('Run Python code before _Py_InitializeMain', "
"file=sys.stderr)");
if (res < 0) {
exit(1);
}
/* ... put more configuration code here ... */
status = _Py_InitializeMain();
if (PyStatus_Exception(status)) {
Py_ExitStatusException(status);
}
}