Konfiguration av Python-initialisering

PyInitConfig C API

Tillagd i version 3.14.

Python kan initialiseras med Py_InitializeFromInitConfig().

Funktionen Py_RunMain() kan användas för att skriva ett anpassat Python-program.

Se även Initialization, Finalization, and Threads.

Se även

PEP 741 ”Python Configuration C API”.

Exempel

Exempel på anpassat Python som alltid körs med Python Development Mode aktiverat; returnerar -1 vid fel:

int init_python(void)
{
    PyInitConfig *config = PyInitConfig_Create();
    if (config == NULL) {
        printf("PYTHON INIT ERROR: minnesallokering misslyckades\n");
        return -1;
    }

    // Aktivera Pythons utvecklingsläge
    if (PyInitConfig_SetInt(config, "dev_mode", 1) < 0) {
        gå till fel;
    }

    // Initiera Python med konfigurationen
    if (Py_InitializeFromInitConfig(config) < 0) {
        goto fel;
    }
    PyInitConfig_Free(config);
    return 0;

fel:
    {
        // Visa felmeddelandet.
        //
        // Denna ovanliga stil med hakparenteser används eftersom man inte kan få
        // goto-mål pekar på variabeldeklarationer.
        const char *err_msg;
        (void)PyInitConfig_GetError(config, &err_msg);
        printf("PYTHON INIT ERROR: %s\n", err_msg);
        PyInitConfig_Free(config);
        return -1;
    }
}

Skapa konfiguration

struct PyInitConfig

Ogenomskinlig struktur för att konfigurera Python-initialiseringen.

PyInitConfig *PyInitConfig_Create(void)

Skapa en ny initieringskonfiguration med hjälp av Isolated Configuration standardvärden.

Den måste frigöras genom PyInitConfig_Free().

Returnerar NULL om minnesallokeringen misslyckas.

void PyInitConfig_Free(PyInitConfig *config)

Frigör minne för initialiseringskonfigurationen config.

Om config är NULL utförs ingen åtgärd.

Felhantering

int PyInitConfig_GetError(PyInitConfig *config, const char **err_msg)

Få felmeddelandet config.

• Ställ in *err_msg och returnera 1 om ett fel har ställts in.

• Sätt *err_msg till NULL och returnera annars 0.

Ett felmeddelande är en UTF-8-kodad sträng.

Om config har en utgångskod, formatera utgångskoden som ett felmeddelande.

Felmeddelandet förblir giltigt tills en annan PyInitConfig -funktion anropas med config. Den som anropar behöver inte återställa felmeddelandet.

int PyInitConfig_GetExitCode(PyInitConfig *config, int *exitcode)

Hämta utgångskoden för config.

• Ställ in *exitcode och returnera 1 om config har en exitkod inställd.

• Returnerar 0 om config inte har någon exitkod inställd.

Endast funktionen Py_InitializeFromInitConfig() kan ange en utgångskod om alternativet parse_argv inte är noll.

En utgångskod kan anges när tolkningen av kommandoraden misslyckades (utgångskod 2) eller när ett kommandoradsalternativ begär att kommandoradshjälpen ska visas (utgångskod 0).

Få alternativ

Parametern name för konfigurationsalternativet måste vara en UTF-8-kodad sträng med nollavgränsning som inte är NULL. Se Konfigurationsalternativ.

int PyInitConfig_HasOption(PyInitConfig *config, const char *name)

Testa om konfigurationen har ett alternativ som heter namn.

Returnerar 1 om alternativet finns, eller returnerar 0 annars.

int PyInitConfig_GetInt(PyInitConfig *config, const char *name, int64_t *value)

Hämta ett konfigurationsalternativ för heltal.

• Ställ in *värde och returnera 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

int PyInitConfig_GetStr(PyInitConfig *config, const char *name, char **value)

Hämta ett konfigurationsalternativ för en sträng som en nollavslutad UTF-8-kodad sträng.

• Ställ in *värde och returnera 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

*value kan sättas till NULL om alternativet är en valfri sträng och alternativet inte är inställt.

Vid framgång måste strängen släppas med free(value) om den inte är NULL.

int PyInitConfig_GetStrList(PyInitConfig *config, const char *name, size_t *length, char ***items)

Hämta ett konfigurationsalternativ i en stränglista som en array av nollavslutade UTF-8-kodade strängar.

• Ställ in *length och *value, och returnera 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

Vid framgång måste stränglistan släppas med PyInitConfig_FreeStrList(length, items).

void PyInitConfig_FreeStrList(size_t length, char **items)

Frigör minne för en stränglista som skapats av PyInitConfig_GetStrList().

Ställ in alternativ

Parametern name för konfigurationsalternativet måste vara en UTF-8-kodad sträng med nollavgränsning som inte är NULL. Se Konfigurationsalternativ.

Vissa konfigurationsalternativ har bieffekter på andra alternativ. Denna logik implementeras endast när Py_InitializeFromInitConfig() anropas, inte av ”Set”-funktionerna nedan. Att till exempel sätta dev_mode till 1 sätter inte faulthandler till 1.

int PyInitConfig_SetInt(PyInitConfig *config, const char *name, int64_t value)

Ställ in ett konfigurationsalternativ för heltal.

• Returnerar 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

int PyInitConfig_SetStr(PyInitConfig *config, const char *name, const char *value)

Ställ in ett konfigurationsalternativ för en sträng från en nollavslutad UTF-8-kodad sträng. Strängen kopieras.

• Returnerar 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

int PyInitConfig_SetStrList(PyInitConfig *config, const char *name, size_t length, char *const *items)

Ange ett konfigurationsalternativ för en stränglista från en array med nollavslutade UTF-8-kodade strängar. Stränglistan kopieras.

• Returnerar 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

Modul

int PyInitConfig_AddModule(PyInitConfig *config, const char *name, PyObject *(*initfunc)(void))

Lägg till en inbyggd tilläggsmodul i tabellen över inbyggda moduler.

Den nya modulen kan importeras med namnet name och använder funktionen initfunc som initialiseringsfunktion som anropas vid första importförsöket.

• Returnerar 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

Om Python initialiseras flera gånger måste PyInitConfig_AddModule() anropas vid varje Python-initialisering.

Liknar funktionen PyImport_AppendInittab().

Initialisera Python

int Py_InitializeFromInitConfig(PyInitConfig *config)

Initiera Python från initieringskonfigurationen.

• Returnerar 0 vid framgång.

• Ange ett fel i config och returnera -1 vid fel.

• Ange en utgångskod i config och returnera -1 om Python vill avsluta.

Se PyInitConfig_GetExitcode() för utgångskodsfallet.

Alternativ för konfiguration

Alternativ	PyConfig/PyPreConfig-medlem	Typ	Synlighet
"allocator"	allokator	int	Endast läs
"argv"	argv	list[str]	Offentlig
"base_exec_prefix"	base_exec_prefix	str	Offentlig
"base_executable"	base_executable	str	Offentlig
"base_prefix"	base_prefix	str	Offentlig
"buffered_stdio"	buffered_stdio	bool	Endast läs
"bytes_warning"	bytes_warning	int	Offentlig
"check_hash_pycs_mode"	check_hash_pycs_mode	str	Endast läs
"code_debug_ranges"	code_debug_ranges	bool	Endast läs
"coerce_c_locale"	coerce_c_locale	bool	Endast läs
"coerce_c_locale_warn"	coerce_c_locale_warn	bool	Endast läs
"configure_c_stdio"	configure_c_stdio	bool	Endast läs
"configure_locale"	configure_locale	bool	Endast läs
"cpu_count"	cpu_count	int	Offentlig
"dev_mode"	dev_mode	bool	Endast läs
"dump_refs"	dump_refs	bool	Endast läs
"dump_refs_file"	dump_refs_file	str	Endast läs
"exec_prefix"	exec_prefix	str	Offentlig
"executable"	exekverbar	str	Offentlig
"faulthandler"	faulthandler	bool	Endast läs
"filesystem_encoding"	filesystem_encoding	str	Endast läs
"filesystem_errors"	filesystem_errors	str	Endast läs
"hash_seed"	hash_seed	int	Endast läs
"home"	hem	str	Endast läs
"import_time"	import_time	int	Endast läs
"inspect"	inspektera	bool	Offentlig
"install_signal_handlers"	install_signal_handlers	bool	Endast läs
"int_max_str_digits"	int_max_str_digits	int	Offentlig
"interactive"	interaktiv	bool	Offentlig
”isolerad”	isolerad	bool	Endast läs
"legacy_windows_fs_encoding"	legacy_windows_fs_encoding	bool	Endast läs
"legacy_windows_stdio"	legacy_windows_stdio	bool	Endast läs
"malloc_stats"	malloc_stats	bool	Endast läs
"module_search_paths"	modul_search_paths	list[str]	Offentlig
"optimization_level"	optimization_level	int	Offentlig
"orig_argv"	orig_argv	list[str]	Endast läs
"parse_argv"	parse_argv	bool	Endast läs
"parser_debug"	parser_debug	bool	Offentlig
"pathconfig_warnings"	pathconfig_warnings	bool	Endast läs
"perf_profiling"	perf_profiling	bool	Endast läs
"platlibdir"	platlibdir	str	Offentlig
"prefix"	prefix	str	Offentlig
"program_name"	program_namn	str	Endast läs
"pycache_prefix"	pycache_prefix	str	Offentlig
”tyst”	quiet	bool	Offentlig
"run_command"	run_command	str	Endast läs
"run_filename"	run_filename	str	Endast läs
"run_module"	run_module	str	Endast läs
"run_presite"	run_presite	str	Endast läs
"safe_path"	safe_path	bool	Endast läs
"show_ref_count"	show_ref_count	bool	Endast läs
"site_import"	site_import	bool	Endast läs
"skip_source_first_line"	skip_source_first_line	bool	Endast läs
"stdio_encoding"	stdio_encoding	str	Endast läs
"stdio_errors"	stdio_errors	str	Endast läs
"stdlib_dir"	stdlib_dir	str	Offentlig
"tracemalloc"	tracemalloc	int	Endast läs
"use_environment"	use_environment	bool	Offentlig
"use_frozen_modules"	använd_frozen_modules	bool	Endast läs
"use_hash_seed"	använd_hash_seed	bool	Endast läs
"use_system_logger"	use_system_logger	bool	Endast läs
"user_site_directory"	användare_site_directory	bool	Endast läs
"utf8_mode"	utf8_mode	bool	Endast läs
"verbose"	verbose	int	Offentlig
"warn_default_encoding"	warn_default_encoding	bool	Endast läs
"warnoptions"	warnoptions	list[str]	Offentlig
"write_bytecode"	write_bytecode	bool	Offentlig
"xoptions"	xoptions	dict[str, str]	Offentlig
"_pystats"	_pystats	bool	Endast läs

Synlighet:

• Allmän: Kan hämtas med PyConfig_Get() och ställas in med PyConfig_Set().

• Skrivskyddad: Kan hämtas med PyConfig_Get(), men kan inte ställas in med PyConfig_Set().

Python-konfigurations-API för körtid

Vid körning är det möjligt att hämta och ställa in konfigurationsalternativ med hjälp av funktionerna PyConfig_Get() och PyConfig_Set().

Parametern name för konfigurationsalternativet måste vara en UTF-8-kodad sträng med nollavgränsning som inte är NULL. Se Konfigurationsalternativ.

Vissa alternativ läses från sys-attributen. Till exempel läses alternativet "argv" från sys.argv.

PyObject *PyConfig_Get(const char *name)

Hämta det aktuella runtime-värdet för ett konfigurationsalternativ som ett Python-objekt.

• Returnerar en ny referens vid framgång.

• Ställ in ett undantag och returnera NULL vid fel.

Objekttypen beror på konfigurationsalternativet. Den kan vara:

• bool

• int

• str

• list[str]

• dict[str, str]

Den som anropar måste ha en attached thread state. Funktionen kan inte anropas före Python-initialisering eller efter Python-finalisering.

Tillagd i version 3.14.

int PyConfig_GetInt(const char *name, int *value)

Liknar PyConfig_Get(), men får värdet som en C int.

• Returnerar 0 vid framgång.

• Ställ in ett undantag och returnera -1 vid fel.

Tillagd i version 3.14.

PyObject *PyConfig_Names(void)

Hämta alla namn på konfigurationsalternativ som ett frozenset.

• Returnerar en ny referens vid framgång.

• Ställ in ett undantag och returnera NULL vid fel.

Den som anropar måste ha en attached thread state. Funktionen kan inte anropas före Python-initialisering eller efter Python-finalisering.

Tillagd i version 3.14.

int PyConfig_Set(const char *name, PyObject *value)

Ställ in det aktuella runtime-värdet för ett konfigurationsalternativ.

• Skapar ett ValueError om det inte finns något alternativ namn.

• Skapar ett ValueError om värde är ett ogiltigt värde.

• Skapar ett ValueError om alternativet är skrivskyddat (kan inte ställas in).

• Skapar ett TypeError om värde inte har rätt typ.

Den som anropar måste ha en attached thread state. Funktionen kan inte anropas före Python-initialisering eller efter Python-finalisering.

Utlöser en auditing-händelse cpython.PyConfig_Set med argumenten name, value.

Tillagd i version 3.14.

PyConfig C API

Tillagd i version 3.8.

Python kan initialiseras med Py_InitializeFromConfig() och PyConfig-strukturen. Den kan förinitialiseras med Py_PreInitialize() och strukturen PyPreConfig.

Det finns två typer av konfigurering:

• Python Configuration kan användas för att bygga en anpassad Python som beter sig som den vanliga Python. Till exempel används miljövariabler och kommandoradsargument för att konfigurera Python.

• Isolated Configuration kan användas för att bädda in Python i en applikation. Den isolerar Python från systemet. Till exempel ignoreras miljövariabler, LC_CTYPE locale lämnas oförändrad och ingen signalhanterare registreras.

Funktionen Py_RunMain() kan användas för att skriva ett anpassat Python-program.

Se även Initialization, Finalization, and Threads.

Se även

PEP 587 ”Python Initialization Configuration”.

Exempel

Exempel på anpassad Python som alltid körs i isolerat läge:

int main(int argc, char **argv)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);
    config.isolated = 1;

    /* Avkoda kommandoradsargument.
       Förinitialisera Python implicit (i isolerat läge). */
    status = PyConfig_SetBytesArgv(&config, argc, argv);
    if (PyStatus_Exception(status)) {
        goto undantag;
    }

    status = Py_InitializeFromConfig(&config);
    if (PyStatus_Exception(status)) {
        gå till undantaget;
    }
    PyConfig_Clear(&config);

    return Py_RunMain();

undantag:
    PyConfig_Clear(&config);
    if (PyStatus_IsExit(status)) {
        return status.exitcode;
    }
    /* Visa felmeddelandet och avsluta processen med en
       med en utgångskod som inte är noll */
    Py_ExitStatusException(status);
}

PyWideStringList

type PyWideStringList

Lista över strängar av typen wchar_t*.

Om length inte är noll måste items vara något annat än NULL och alla strängar måste vara något annat än NULL.

Metoder:

PyStatus PyWideStringList_Append(PyWideStringList *list, const wchar_t *item)

Lägg till item till list.

Python måste vara förinitialiserat för att denna funktion ska kunna anropas.

PyStatus PyWideStringList_Insert(PyWideStringList *list, Py_ssize_t index, const wchar_t *item)

Infoga objekt i lista vid index.

Om index är större än eller lika med list längd, lägg till item till list.

index måste vara större än eller lika med 0.

Python måste vara förinitialiserat för att denna funktion ska kunna anropas.

Strukturfält:

Py_ssize_t length

Listans längd.

wchar_t **items

Lista objekt.

PyStatus

type PyStatus

Struktur för att lagra en initialiseringsfunktions status: success, error eller exit.

För ett fel kan det lagra namnet på den C-funktion som skapade felet.

Strukturfält:

int exitcode

Exit-kod. Argument som skickas till exit().

const char *err_msg

Felmeddelande.

const char *func

Namn på den funktion som skapade ett fel, kan vara NULL.

Funktioner för att skapa en status:

PyStatus PyStatus_Ok(void)

Lyckades.

PyStatus PyStatus_Error(const char *err_msg)

Initialiseringsfel med ett meddelande.

err_msg får inte vara NULL.

PyStatus PyStatus_NoMemory(void)

Fel i minnesallokeringen (minnet är slut).

PyStatus PyStatus_Exit(int exitcode)

Avsluta Python med den angivna exit-koden.

Funktioner för att hantera en status:

int PyStatus_Exception(PyStatus status)

Är statusen ett fel eller en exit? Om true måste undantaget hanteras, t.ex. genom att anropa Py_ExitStatusException().

int PyStatus_IsError(PyStatus status)

Är resultatet ett fel?

int PyStatus_IsExit(PyStatus status)

Är resultatet en exit?

void Py_ExitStatusException(PyStatus status)

Anropa exit(exitcode) om status är en exit. Skriv ut felmeddelandet och avsluta med en utgångskod som inte är noll om status är ett fel. Får endast anropas om PyStatus_Exception(status) inte är noll.

Anteckning

Internt använder Python makron som sätter PyStatus.func, medan funktioner för att skapa en status sätter func till NULL.

Exempel:

PyStatus alloc(void **ptr, size_t size)
{
    *ptr = PyMem_RawMalloc(size);
    om (*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

type PyPreConfig

Struktur som används för att förinitialisera Python.

Funktion för att initiera en förkonfiguration:

void PyPreConfig_InitPythonConfig(PyPreConfig *preconfig)

Initiera förkonfigurationen med Python Configuration.

void PyPreConfig_InitIsolatedConfig(PyPreConfig *preconfig)

Initiera förkonfigurationen med Isolated Configuration.

Strukturfält:

int allocator

Namn på Pythons minnesallokatorer:

• PYMEM_ALLOCATOR_NOT_SET (0): ändra inte minnesallokatorer (använd standardvärden).

• PYMEM_ALLOCATOR_DEFAULT (1): standard minnesallokatorer.

• PYMEM_ALLOCATOR_DEBUG (2): default memory allocators with debug hooks.

• PYMEM_ALLOCATOR_MALLOC (3): använd malloc() från C-biblioteket.

• PYMEM_ALLOCATOR_MALLOC_DEBUG (4): tvinga fram användning av malloc() med debug hooks.

• PYMEM_ALLOCATOR_PYMALLOC (5): Python pymalloc memory allocator.

• PYMEM_ALLOCATOR_PYMALLOC_DEBUG (6): Python pymalloc memory allocator med debug hooks.

• PYMEM_ALLOCATOR_MIMALLOC (6): Använd mimalloc, en snabb malloc-ersättning.

• PYMEM_ALLOCATOR_MIMALLOC_DEBUG (7): Använd mimalloc, en snabb malloc-ersättning med debug-hooks.

PYMEM_ALLOCATOR_PYMALLOC och PYMEM_ALLOCATOR_PYMALLOC_DEBUG stöds inte om Python är konfigurerat med --without-pymalloc.

PYMEM_ALLOCATOR_MIMALLOC och PYMEM_ALLOCATOR_MIMALLOC_DEBUG stöds inte om Python är konfigurerad med --without-mimalloc eller om det underliggande atomära stödet inte är tillgängligt.

Se Memory Management.

Standard: PYMEM_ALLOCATOR_NOT_SET.

int configure_locale

Ställ in LC_CTYPE locale till den locale som användaren föredrar.

Om lika med 0, sätt medlemmarna coerce_c_locale och coerce_c_locale_warn till 0.

Se locale encoding.

Standard: 1 i Python-konfiguration, 0 i isolerad konfiguration.

int coerce_c_locale

Om lika med 2, tvinga fram C locale.

Om lika med 1, läs LC_CTYPE locale för att avgöra om den ska tvingas.

Se locale encoding.

Standard: -1 i Python-konfiguration, 0 i isolerad konfiguration.

int coerce_c_locale_warn

Om ej noll, avge en varning om C-landets språk är tvingat.

Standard: -1 i Python-konfiguration, 0 i isolerad konfiguration.

int dev_mode

Python Development Mode: se PyConfig.dev_mode.

Standard: -1 i Python-läge, 0 i isolerat läge.

int isolated

Isolerat läge: se PyConfig.isolated.

Standard: 0 i Python-läge, 1 i isolerat läge.

int legacy_windows_fs_encoding

Om ej noll:

• Sätt PyPreConfig.utf8_mode till 0,

• Sätt PyConfig.filesystem_encoding till "mbcs",

• Sätt PyConfig.filesystem_errors till "replace".

Initialiseras från miljövariabelns värde PYTHONLEGACYWINDOWSFSENCODING.

Endast tillgängligt på Windows. makrot #ifdef MS_WINDOWS kan användas för Windows-specifik kod.

Standard: 0.

int parse_argv

Om icke-noll, analyserar Py_PreInitializeFromArgs() och Py_PreInitializeFromBytesArgs() sina argv argument på samma sätt som vanliga Python analyserar kommandoradsargument: se Command Line Arguments.

Standard: 1 i Python-konfiguration, 0 i isolerad konfiguration.

int use_environment

Använda miljövariabler? Se PyConfig.use_environment.

Standard: 1 i Python-konfiguration och 0 i isolerad konfiguration.

int utf8_mode

Om värdet är annat än noll aktiveras Python UTF-8 Mode.

Sätts till 0 eller 1 med kommandoradsalternativet -X utf8 och miljövariabeln PYTHONUTF8.

Sätts också till 1 om LC_CTYPE locale är C eller POSIX.

Standard: -1 i Python-konfiguration och 0 i isolerad konfiguration.

Förinitiera Python med PyPreConfig

Förinitialisering av Python:

• Ange Pythons minnesallokatorer (PyPreConfig.allocator)

• Konfigurera LC_CTYPE-locale (locale encoding)

• Ställ in Python UTF-8 Mode (PyPreConfig.utf8_mode)

Den aktuella förkonfigurationen (av typen PyPreConfig) lagras i _PyRuntime.preconfig.

Funktioner för att förinitialisera Python:

PyStatus Py_PreInitialize(const PyPreConfig *preconfig)

Förinitiera Python från preconfig preconfiguration.

preconfig får inte vara NULL.

PyStatus Py_PreInitializeFromBytesArgs(const PyPreConfig *preconfig, int argc, char *const *argv)

Förinitiera Python från preconfig preconfiguration.

Analysera argv kommandoradsargument (bytessträngar) om parse_argv i preconfig är ung.

preconfig får inte vara NULL.

PyStatus Py_PreInitializeFromArgs(const PyPreConfig *preconfig, int argc, wchar_t *const *argv)

Förinitiera Python från preconfig preconfiguration.

Analysera argv kommandoradsargument (breda strängar) om parse_argv i preconfig är ung.

preconfig får inte vara NULL.

Anroparen ansvarar för att hantera undantag (error eller exit) med hjälp av PyStatus_Exception() och Py_ExitStatusException().

För Python Configuration (PyPreConfig_InitPythonConfig()), om Python initieras med kommandoradsargument, måste kommandoradsargumenten också skickas för att förinitialisera Python, eftersom de har en effekt på förkonfigurationen som kodningar. Till exempel aktiverar -X utf8 kommandoradsalternativet Python UTF-8 Mode.

PyMem_SetAllocator() kan anropas efter Py_PreInitialize() och före Py_InitializeFromConfig() för att installera en anpassad minnesallokator. Den kan anropas före Py_PreInitialize() om PyPreConfig.allocator är satt till PYMEM_ALLOCATOR_NOT_SET.

Python-minnesallokeringsfunktioner som PyMem_RawMalloc() får inte användas före Pythons förinitialisering, medan det alltid är säkert att anropa malloc() och free() direkt. Py_DecodeLocale() får inte anropas före Pythons förinitialisering.

Exempel på användning av förinitialisering för att aktivera Python 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);
}

/* vid denna punkt talar Python UTF-8 */

Py_Initialize();
/* ... använd Python API här ... */
Py_Finalize();

PyConfig

type PyConfig

Struktur som innehåller de flesta parametrar för att konfigurera Python.

När detta är gjort måste funktionen PyConfig_Clear() användas för att frigöra konfigurationsminnet.

Strukturmetoder:

void PyConfig_InitPythonConfig(PyConfig *config)

Initiera konfigurationen med Python Configuration.

void PyConfig_InitIsolatedConfig(PyConfig *config)

Initiera konfigurationen med Isolated Configuration.

PyStatus PyConfig_SetString(PyConfig *config, wchar_t *const *config_str, const wchar_t *str)

Kopiera den breda teckensträngen str till *config_str.

Preinitialize Python om det behövs.

PyStatus PyConfig_SetBytesString(PyConfig *config, wchar_t *const *config_str, const char *str)

Avkoda str med Py_DecodeLocale() och lägg in resultatet i *config_str.

Preinitialize Python om det behövs.

PyStatus PyConfig_SetArgv(PyConfig *config, int argc, wchar_t *const *argv)

Ange kommandoradsargument (argv member of config) från listan argv med breda teckensträngar.

Preinitialize Python om det behövs.

PyStatus PyConfig_SetBytesArgv(PyConfig *config, int argc, char *const *argv)

Ange kommandoradsargument (argv member of config) från listan argv med bytessträngar. Avkoda bytes med hjälp av Py_DecodeLocale().

Preinitialize Python om det behövs.

PyStatus PyConfig_SetWideStringList(PyConfig *config, PyWideStringList *list, Py_ssize_t length, wchar_t **items)

Ställ in listan med breda strängar list till length och items.

Preinitialize Python om det behövs.

PyStatus PyConfig_Read(PyConfig *config)

Läs alla Python-konfigurationer.

Fält som redan är initialiserade lämnas oförändrade.

Fält för path configuration beräknas eller ändras inte längre vid anrop av denna funktion, från och med Python 3.11.

Funktionen PyConfig_Read() analyserar bara PyConfig.argv-argument en gång: PyConfig.parse_argv sätts till 2 efter att argumenten har analyserats. Eftersom Python-argument tas bort från PyConfig.argv, skulle analys av argument två gånger innebära att programalternativen analyseras som Python-alternativ.

Preinitialize Python om det behövs.

Ändrad i version 3.10: Argumenten PyConfig.argv analyseras nu endast en gång, PyConfig.parse_argv sätts till 2 efter att argumenten har analyserats och argumenten analyseras endast om PyConfig.parse_argv är lika med 1.

Ändrad i version 3.11: PyConfig_Read() beräknar inte längre alla sökvägar, och därför kan fält som listas under Python Path Configuration inte längre uppdateras förrän Py_InitializeFromConfig() anropas.

void PyConfig_Clear(PyConfig *config)

Frigör konfigurationsminnet.

De flesta PyConfig-metoder preinitialize Python om det behövs. I så fall baseras Python-förinitialiseringskonfigurationen (PyPreConfig) på PyConfig. Om konfigurationsfält som är gemensamma med PyPreConfig justeras måste de ställas in innan en PyConfig -metod anropas:

• PyConfig.dev_mode

• PyConfig.isolated

• PyConfig.parse_argv

• PyConfig.use_environment

Dessutom, om PyConfig_SetArgv() eller PyConfig_SetBytesArgv() används, måste denna metod anropas före andra metoder, eftersom konfigurationen före initieringen beror på kommandoradsargument (om parse_argv inte är noll).

Den som anropar dessa metoder är ansvarig för att hantera undantag (fel eller exit) med hjälp av PyStatus_Exception() och Py_ExitStatusException().

Strukturfält:

PyWideStringList argv

Ställ in sys.argv kommandoradsargument baserat på argv. Dessa parametrar liknar de som skickas till programmets funktion main() med skillnaden att den första posten ska referera till skriptfilen som ska köras istället för den körbara filen som är värd för Python-tolken. Om det inte finns något skript som ska köras kan den första posten i argv vara en tom sträng.

Sätt parse_argv till 1 för att analysera argv på samma sätt som vanliga Python analyserar Python-kommandoradsargument och sedan ta bort Python-argument från argv.

Om argv är tom, läggs en tom sträng till för att säkerställa att sys.argv alltid existerar och aldrig är tom.

Standard: NULL.

Se även orig_argv-medlemmen.

int safe_path

Om den är lika med noll, lägger Py_RunMain() till en potentiellt osäker sökväg till sys.path vid uppstart:

• Om argv[0] är lika med L"-m" (python -m module), lägg till den aktuella arbetskatalogen.

• Om du kör ett skript (python script.py), lägg till skriptets katalog. Om det är en symbolisk länk, lös symboliska länkar.

• I annat fall (python -c code och python) läggs en tom sträng till, vilket innebär den aktuella arbetskatalogen.

Sätts till 1 med kommandoradsalternativet -P och miljövariabeln PYTHONSAFEPATH.

Standard: 0 i Python-konfiguration, 1 i isolerad konfiguration.

Tillagd i version 3.11.

wchar_t *base_exec_prefix

sys.base_exec_prefix.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.exec_prefix.

wchar_t *base_executable

Körbar Python-bas: sys._base_executable.

Ställs in av miljövariabeln __PYVENV_LAUNCHER__.

Ställ in från PyConfig.executable om NULL.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.executable.

wchar_t *base_prefix

sys.base_prefix.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.prefix.

int buffered_stdio

Om lika med 0 och configure_c_stdio är icke-noll, inaktivera buffring på C-strömmarna stdout och stderr.

Sätts till 0 med kommandoradsalternativet -u och miljövariabeln PYTHONUNBUFFERED.

stdin öppnas alltid i buffrat läge.

Standard: 1.

int bytes_warning

Om lika med 1, utfärda en varning när du jämför bytes eller bytearray med str, eller jämför bytes med int.

Om lika med eller större än 2, skapa ett BytesWarning undantag i dessa fall.

Ökas med kommandoradsalternativet -b.

Standard: 0.

int warn_default_encoding

Om ung, avge en EncodingWarning-varning när io.TextIOWrapper använder sin standardkodning. Se Opt-in-kodningVarning för detaljer.

Standard: 0.

Tillagd i version 3.10.

int code_debug_ranges

Om lika med 0, inaktiveras inkludering av slutrad och kolumnmappningar i kodobjekt. Inaktiverar också spårningsutskrift av carets till specifika felplatser.

Sätts till 0 av miljövariabeln PYTHONNODEBUGRANGES och av kommandoradsalternativet -X no_debug_ranges.

Standard: 1.

Tillagd i version 3.11.

wchar_t *check_hash_pycs_mode

Kontrollera valideringsbeteendet för hash-baserade .pyc -filer: värdet av kommandoradsalternativet --check-hash-based-pycs.

Giltiga värden:

• L"always": Hashar källfilen för ogiltigförklaring oavsett värdet på flaggan ”check_source”.

• L"never": Anta att hash-baserade pycs alltid är giltiga.

• L"default": Flaggan ”check_source” i hash-baserade pycs avgör ogiltighet.

Standard: L"default".

Se även PEP 552 ”Deterministic pycs”.

int configure_c_stdio

Om ej noll, konfigurera C-standardströmmar:

• I Windows ställer du in binärt läge (O_BINARY) på stdin, stdout och stderr.

• Om buffered_stdio är lika med noll, inaktiveras buffring av strömmarna stdin, stdout och stderr.

• Om interactive inte är noll, aktivera strömbuffring på stdin och stdout (endast stdout på Windows).

Standard: 1 i Python-konfiguration, 0 i isolerad konfiguration.

int dev_mode

Om värdet är annat än noll aktiveras Python Development Mode.

Sätts till 1 med alternativet -X dev och miljövariabeln PYTHONDEVMODE.

Standard: -1 i Python-läge, 0 i isolerat läge.

int dump_refs

Dumpa Python-referenser?

Om värdet inte är noll, dumpas alla objekt som fortfarande lever vid avslut.

Sätts till 1 av miljövariabeln PYTHONDUMPREFS.

Kräver en specialversion av Python med makrot Py_TRACE_REFS definierat: se configure --with-trace-refs option.

Standard: 0.

wchar_t *dump_refs_file

Filnamn där Python-referenser ska dumpas.

Ställs in av miljövariabeln PYTHONDUMPREFSFILE.

Standard: NULL.

Tillagd i version 3.11.

wchar_t *exec_prefix

Det platsspecifika katalogprefixet där de plattformsberoende Python-filerna installeras: sys.exec_prefix.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.base_exec_prefix.

wchar_t *executable

Den absoluta sökvägen till den körbara binärfilen för Python-tolken: sys.executable.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.base_executable.

int faulthandler

Aktivera Faulthandler?

Om ej noll, anropa faulthandler.enable() vid uppstart.

Sätts till 1 av -X faulthandler och miljövariabeln PYTHONFAULTHANDLER.

Standard: -1 i Python-läge, 0 i isolerat läge.

wchar_t *filesystem_encoding

Filsystemskodning: sys.getfilesystemencoding().

På macOS, Android och VxWorks: använd "utf-8" som standard.

På Windows: använd "utf-8" som standard, eller "mbcs" om legacy_windows_fs_encoding av PyPreConfig är icke-noll.

Standardkodning på andra plattformar:

• "utf-8" om PyPreConfig.utf8_mode inte är noll.

• "ascii" om Python upptäcker att nl_langinfo(CODESET) meddelar ASCII-kodning, medan funktionen mbstowcs() avkodar från en annan kodning (vanligtvis Latin1).

• "utf-8" om nl_langinfo(CODESET) returnerar en tom sträng.

• Annars används locale encoding: nl_langinfo(CODESET) resultat.

Vid Python-start normaliseras kodningsnamnet till Python-codec-namnet. Till exempel ersätts "ANSI_X3.4-1968" med "ascii".

Se även filesystem_errors member.

wchar_t *filesystem_errors

Filsystemsfelhanterare: sys.getfilesystemencodeerrors().

På Windows: använd "surrogatepass" som standard, eller "replace" om legacy_windows_fs_encoding av PyPreConfig inte är noll.

På andra plattformar: använd "surrogateescape" som standard.

Felhanterare som stöds:

• "strict"

• "surrogateescape"

• "surrogatepass" (stöds endast med UTF-8-kodning)

Se även medlemmen filesystem_encoding.

int use_frozen_modules

Om värdet är annat än noll, använd frysta moduler.

Ställs in av miljövariabeln PYTHON_FROZEN_MODULES.

Standard: 1 i en release-byggnad, eller 0 i en debug-byggnad.

unsigned long hash_seed

int use_hash_seed

Slumpmässigt utsäde för hashfunktion.

Om use_hash_seed är noll, väljs ett frö slumpmässigt vid Python-start och hash_seed ignoreras.

Ställs in av miljövariabeln PYTHONHASHSEED.

Standardvärde för use_hash_seed: -1 i Python-läge, 0 i isolerat läge.

wchar_t *home

Ange standardkatalogen för Python, det vill säga platsen där Pythons standardbibliotek finns (se PYTHONHOME).

Ställs in av miljövariabeln PYTHONHOME.

Standard: NULL.

Del av Python Path Configuration inmatning.

int import_time

Om 1, profilera importtiden. Om 2, inkludera ytterligare utdata som indikerar när en importerad modul redan har laddats.

Ställs in med alternativet -X importtime och miljövariabeln PYTHONPROFILEIMPORTTIME.

Standard: 0.

Ändrad i version 3.14: Lagt till stöd för import_time = 2

int inspect

Gå till interaktivt läge efter att du har kört ett skript eller ett kommando.

Om större än 0, aktivera inspect: när ett skript skickas som första argument eller alternativet -c används, gå till interaktivt läge efter att skriptet eller kommandot har exekverats, även om sys.stdin inte verkar vara en terminal.

Ökas med kommandoradsalternativet -i. Sätts till 1 om miljövariabeln PYTHONINSPECT inte är tom.

Standard: 0.

int install_signal_handlers

Installera Python-signalhanterare?

Standard: 1 i Python-läge, 0 i isolerat läge.

int interactive

Om större än 0, aktivera det interaktiva läget (REPL).

Ökas med kommandoradsalternativet -i.

Standard: 0.

int int_max_str_digits

Konfigurerar Längdsbegränsning för konvertering av heltalssträngar. Ett initialt värde på -1 innebär att värdet hämtas från kommandoraden eller miljön eller annars är standardvärdet 4300 (sys.int_info.default_max_str_digits). Ett värde på 0 inaktiverar begränsningen. Värden som är större än noll men mindre än 640 (sys.int_info.str_digits_check_threshold) stöds inte och leder till ett fel.

Konfigureras av kommandoradsflaggan -X int_max_str_digits eller miljövariabeln PYTHONINTMAXSTRDIGITS.

Standard: -1 i Python-läge. 4300 (sys.int_info.default_max_str_digits) i isolerat läge.

Tillagd i version 3.12.

int cpu_count

Om värdet för cpu_count inte är -1 så kommer det att åsidosätta returvärdena för os.cpu_count(), os.process_cpu_count(), och multiprocessing.cpu_count().

Konfigureras av kommandoradsflaggan -X cpu_count=n|default eller miljövariabeln PYTHON_CPU_COUNT.

Standard: -1.

Tillagd i version 3.13.

int isolated

Om större än 0, aktivera isolerat läge:

• Sätt safe_path till 1: lägg inte till en potentiellt osäker sökväg till sys.path vid Python-start, t.ex. den aktuella katalogen, skriptets katalog eller en tom sträng.

• Sätt use_environment till 0: ignorera PYTHON miljövariabler.

• Sätt user_site_directory till 0: lägg inte till användarkatalogen i sys.path.

• Python REPL importerar inte readline eller aktiverar standardkonfiguration för readline på interaktiva prompter.

Sätts till 1 med kommandoradsalternativet -I.

Standard: 0 i Python-läge, 1 i isolerat läge.

Se även Isolated Configuration och PyPreConfig.isolated.

int legacy_windows_stdio

Om den inte är noll, använd io.FileIO istället för io._WindowsConsoleIO för sys.stdin, sys.stdout och sys.stderr.

Sätts till 1 om miljövariabeln PYTHONLEGACYWINDOWSSTDIO är satt till en icke-tom sträng.

Endast tillgängligt på Windows. makrot #ifdef MS_WINDOWS kan användas för Windows-specifik kod.

Standard: 0.

Se även PEP 528 (Ändra Windows-konsolens kodning till UTF-8).

int malloc_stats

Om ej noll, dumpa statistik på Python pymalloc memory allocator vid avslut.

Sätts till 1 av miljövariabeln PYTHONMALLOCSTATS.

Alternativet ignoreras om Python är konfigurerad med alternativet --without-pymalloc.

Standard: 0.

wchar_t *platlibdir

Katalognamn för plattformsbibliotek: sys.platlibdir.

Ställs in av miljövariabeln PYTHONPLATLIBDIR.

Standard: värdet på makrot PLATLIBDIR som anges av configure --with-platlibdir option (standard: "lib", eller "DLLs" på Windows).

Del av Python Path Configuration inmatning.

Tillagd i version 3.9.

Ändrad i version 3.11: Detta makro används nu i Windows för att lokalisera standardbibliotekets tilläggsmoduler, vanligtvis under DLLs. Av kompatibilitetsskäl bör du dock notera att detta värde ignoreras för alla icke-standardiserade layouter, inklusive in-tree builds och virtuella miljöer.

wchar_t *pythonpath_env

Sökvägar för modul (sys.path) som en sträng separerad med DELIM (os.pathsep).

Ställs in av miljövariabeln PYTHONPATH.

Standard: NULL.

Del av Python Path Configuration inmatning.

PyWideStringList module_search_paths

int module_search_paths_set

Sökvägar för modul: sys.path.

Om module_search_paths_set är lika med 0, kommer Py_InitializeFromConfig() att ersätta module_search_paths och sätter module_search_paths_set till 1.

Standard: tom lista (module_search_paths) och 0 (module_search_paths_set).

Del av Python Path Configuration utdata.

int optimization_level

Nivå för kompileringsoptimering:

• 0: Peephole optimizer, ställ in __debug__ till True.

• 1: Nivå 0, ta bort påståenden, sätt __debug__ till False.

• 2: Nivå 1, remsa docstrings.

Ökas med kommandoradsalternativet -O. Sätts till värdet för miljövariabeln PYTHONOPTIMIZE.

Standard: 0.

PyWideStringList orig_argv

Listan över de ursprungliga kommandoradsargumenten som skickades till Python-körprogrammet: sys.orig_argv.

Om listan orig_argv är tom och argv inte är en lista som bara innehåller en tom sträng, kopierar PyConfig_Read() argv till orig_argv innan den modifierar argv (om parse_argv inte är noll).

Se även medlemmen argv och funktionen Py_GetArgcArgv().

Standard: tom lista.

Tillagd i version 3.10.

int parse_argv

Analysera kommandoradsargument?

Om lika med 1, analyseras argv på samma sätt som vanliga Python analyserar kommandoradsargument, och Python-argument tas bort från argv.

Funktionen PyConfig_Read() analyserar bara PyConfig.argv-argument en gång: PyConfig.parse_argv sätts till 2 efter att argumenten har analyserats. Eftersom Python-argument tas bort från PyConfig.argv, skulle analys av argument två gånger innebära att programalternativen analyseras som Python-alternativ.

Standard: 1 i Python-läge, 0 i isolerat läge.

Ändrad i version 3.10: Argumenten i PyConfig.argv analyseras nu endast om PyConfig.parse_argv är lika med 1.

int parser_debug

Felsökningsläge för parser. Om större än 0, aktivera felsökningsutmatning för parser (endast för experter, beroende på kompileringsalternativ).

Ökas med kommandoradsalternativet -d. Sätts till värdet för miljövariabeln PYTHONDEBUG.

Kräver en debug-version av Python (makrot Py_DEBUG måste vara definierat).

Standard: 0.

int pathconfig_warnings

Om ej noll, tillåts beräkning av sökvägskonfiguration att logga varningar i stderr. Om lika med 0, undertrycks dessa varningar.

Standard: 1 i Python-läge, 0 i isolerat läge.

Del av Python Path Configuration inmatning.

Ändrad i version 3.11: Gäller nu även på Windows.

wchar_t *prefix

Det platsspecifika katalogprefixet där de plattformsoberoende Python-filerna installeras: sys.prefix.

Standard: NULL.

Del av Python Path Configuration utdata.

Se även PyConfig.base_prefix.

wchar_t *program_name

Programnamn som används för att initiera executable och i tidiga felmeddelanden under Python-initialisering.

• På macOS, använd PYTHONEXECUTABLE miljövariabel om den är inställd.

• Om makrot WITH_NEXT_FRAMEWORK är definierat, använd __PYVENV_LAUNCHER__ miljövariabel om den är inställd.

• Använd argv[0] i argv om den finns tillgänglig och inte är tom.

• Annars använder du L"python" på Windows, eller L"python3" på andra plattformar.

Standard: NULL.

Del av Python Path Configuration inmatning.

wchar_t *pycache_prefix

Katalog där cachade .pyc -filer skrivs: sys.pycache_prefix.

Ställs in med kommandoradsalternativet -X pycache_prefix=PATH och miljövariabeln PYTHONPYCACHEPREFIX. Kommandoradsalternativet har företräde.

Om NULL, sätts sys.pycache_prefix till None.

Standard: NULL.

int quiet

Tyst läge. Om större än 0, visa inte copyright och version vid Python-start i interaktivt läge.

Ökas med kommandoradsalternativet -q.

Standard: 0.

wchar_t *run_command

Värde för kommandoradsalternativet -c.

Används av Py_RunMain().

Standard: NULL.

wchar_t *run_filename

Filnamn som skickas på kommandoraden: efterföljande argument på kommandoraden utan -c eller -m. Den används av funktionen Py_RunMain().

Den ställs till exempel in på cript.py med kommandoraden python3 script.py arg.

Se även alternativet PyConfig.skip_source_first_line.

Standard: NULL.

wchar_t *run_module

Värde för kommandoradsalternativet -m.

Används av Py_RunMain().

Standard: NULL.

wchar_t *run_presite

package.module sökväg till modul som ska importeras innan site.py körs.

Ställs in med kommandoradsalternativet -X presite=package.module och miljövariabeln PYTHON_PRESITE. Kommandoradsalternativet har företräde.

Kräver en debug-version av Python (makrot Py_DEBUG måste vara definierat).

Standard: NULL.

int show_ref_count

Visa totalt antal referenser vid utgången (exklusive immortal-objekt)?

Sätts till 1 av -X showrefcount kommandoradsalternativ.

Kräver en debug-byggnad av Python (makrot Py_REF_DEBUG måste vara definierat).

Standard: 0.

int site_import

Importera modulen site vid uppstart?

Om värdet är noll inaktiveras importen av modulens webbplats och de webbplatsberoende manipulationerna av sys.path som den medför.

Inaktivera även dessa manipulationer om modulen site uttryckligen importeras senare (anropa site.main() om du vill att de ska utlösas).

Sätts till 0 med kommandoradsalternativet -S.

sys.flags.no_site är satt till det inverterade värdet av site_import.

Standard: 1.

int skip_source_first_line

Om värdet är annat än noll, hoppa över första raden i källan PyConfig.run_filename.

Det gör det möjligt att använda icke-Unix-former av #!cmd. Detta är endast avsett för ett DOS-specifikt hack.

Sätts till 1 med kommandoradsalternativet -x.

Standard: 0.

wchar_t *stdio_encoding

wchar_t *stdio_errors

Kodnings- och kodningsfel i sys.stdin, sys.stdout och sys.stderr (men sys.stderr använder alltid felhanteraren "backslashreplace").

Använd miljövariabeln PYTHONIOENCODING om den inte är tom.

Standardkodning:

• "UTF-8" om PyPreConfig.utf8_mode inte är noll.

• I annat fall används locale encoding.

Standard felhanterare:

• I Windows: använd "surrogateescape".

• "surrogateescape" om PyPreConfig.utf8_mode är icke-noll, eller om LC_CTYPE locale är ”C” eller ”POSIX”.

• "strict" annars.

Se även PyConfig.legacy_windows_stdio.

int tracemalloc

Aktivera tracemalloc?

Om ej noll, anropa tracemalloc.start() vid uppstart.

Ställs in av -X tracemalloc=N kommandoradsalternativ och av miljövariabeln PYTHONTRACEMALLOC.

Standard: -1 i Python-läge, 0 i isolerat läge.

int perf_profiling

Aktivera stöd för Linux-profiler perf?

Om lika med 1, aktiveras stöd för Linux-profileraren perf.

Om lika med 2, aktivera stöd för Linux perf profiler med DWARF JIT-stöd.

Sätts till 1 av -X perf kommandoradsalternativ och miljövariabeln PYTHONPERFSUPPORT.

Sätts till 2 med kommandoradsalternativet -X perf_jit och miljövariabeln PYTHON_PERF_JIT_SUPPORT.

Standard: -1.

Se även

Se Python-stöd för Linux-profileraren perf för mer information.

Tillagd i version 3.12.

wchar_t *stdlib_dir

Katalog över Pythons standardbibliotek.

Standard: NULL.

Tillagd i version 3.11.

int use_environment

Använd miljövariabler?

Om den är lika med noll ignoreras miljövariabler.

Sätts till 0 av miljövariabeln -E.

Standard: 1 i Python-konfiguration och 0 i isolerad konfiguration.

int use_system_logger

Om värdet inte är noll kommer stdout och stderr att omdirigeras till systemloggen.

Endast tillgängligt på macOS 10.12 och senare, och på iOS.

Standard: 0 (använd inte systemloggen) på macOS; 1 på iOS (använd systemloggen).

Tillagd i version 3.14.

int user_site_directory

Om värdet är annat än noll läggs användarens webbplatskatalog till i sys.path.

Sätts till 0 med kommandoradsalternativen -s och -I.

Sätts till 0 av miljövariabeln PYTHONNOUSERSITE.

Standard: 1 i Python-läge, 0 i isolerat läge.

int verbose

Verbose-läge. Om större än 0, skriv ut ett meddelande varje gång en modul importeras, som visar platsen (filnamn eller inbyggd modul) från vilken den laddas.

Om större än eller lika med 2, skrivs ett meddelande ut för varje fil som kontrolleras vid sökning efter en modul. Ger också information om modulrensning vid avslutning.

Ökas med kommandoradsalternativet -v.

Ställs in av värdet för miljövariabeln PYTHONVERBOSE.

Standard: 0.

PyWideStringList warnoptions

Alternativ för modulen warnings för att bygga varningsfilter, från lägsta till högsta prioritet: sys.warnoptions.

Modulen warnings lägger till sys.warnoptions i omvänd ordning: det sista PyConfig.warnoptions-objektet blir det första objektet i warnings.filters som kontrolleras först (högsta prioritet).

Kommandoradsalternativet -W lägger till sitt värde i warnoptions, det kan användas flera gånger.

Miljövariabeln PYTHONWARNINGS kan också användas för att lägga till varningsalternativ. Flera alternativ kan anges, åtskilda med kommatecken (,).

Standard: tom lista.

int write_bytecode

Om lika med 0, kommer Python inte att försöka skriva .pyc -filer vid import av källmoduler.

Sätts till 0 med kommandoradsalternativet -B och miljövariabeln PYTHONDONTWRITEBYTECODE.

sys.dont_write_bytecode initialiseras till det inverterade värdet av write_bytecode.

Standard: 1.

PyWideStringList xoptions

Värden för kommandoradsalternativen -X: sys._xoptions.

Standard: tom lista.

int _pystats

Om ej noll, skriv prestandastatistik när Python avslutas.

Behöver en speciell konstruktion med makrot Py_STATS: se --enable-pystats.

Standard: 0.

Om parse_argv inte är noll, analyseras argv-argument på samma sätt som vanliga Python analyserar kommandoradsargument, och Python-argument tas bort från argv.

Alternativen xoptions analyseras för att ange andra alternativ: se kommandoradsalternativet -X.

Ändrad i version 3.9: Fältet show_alloc_count har tagits bort.

Initialisering med PyConfig

Initialisering av tolken från en ifylld konfigurationsstruktur hanteras genom att anropa Py_InitializeFromConfig().

Anroparen ansvarar för att hantera undantag (error eller exit) med hjälp av PyStatus_Exception() och Py_ExitStatusException().

Om PyImport_FrozenModules(), PyImport_AppendInittab() eller PyImport_ExtendInittab() används, måste de anges eller anropas efter Pythons förinitialisering och före Pythons initialisering. Om Python initialiseras flera gånger måste PyImport_AppendInittab() eller PyImport_ExtendInittab() anropas före varje Python-initialisering.

Den aktuella konfigurationen (av typen PyConfig) lagras i PyInterpreterState.config.

Exempel på inställning av programnamn:

void init_python(void)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Ställ in programnamnet. Förinitialisera Python implicit. */
    status = PyConfig_SetString(&config, &config.program_name,
                                L"/stig/till/mitt_program");
    if (PyStatus_Exception(status)) {
        goto undantag;
    }

    status = Py_InitializeFromConfig(&config);
    if (PyStatus_Exception(status)) {
        gå till undantaget;
    }
    PyConfig_Clear(&config);
    returnera;

undantag:
    PyConfig_Clear(&config);
    Py_ExitStatusException(status);
}

Ett mer komplett exempel på hur man ändrar standardkonfigurationen, läser konfigurationen och sedan åsidosätter vissa parametrar. Observera att sedan 3.11 beräknas många parametrar inte förrän vid initialiseringen, och därför kan värdena inte läsas från konfigurationsstrukturen. Alla värden som ställts in innan initialize anropas kommer att lämnas oförändrade av initialization:

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;
    }

    /* Specify sys.path explicitly */
    /* If you want to modify the default set of paths, finish
       initialization first and then use PySys_GetObject("path") */
    config.module_search_paths_set = 1;
    status = PyWideStringList_Append(&config.module_search_paths,
                                     L"/path/to/stdlib");
    if (PyStatus_Exception(status)) {
        goto done;
    }
    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;
}

Isolerad konfiguration

funktionerna PyPreConfig_InitIsolatedConfig() och PyConfig_InitIsolatedConfig() skapar en konfiguration för att isolera Python från systemet. Till exempel för att bädda in Python i en applikation.

Denna konfiguration ignorerar globala konfigurationsvariabler, miljövariabler, kommandoradsargument (PyConfig.argv tolkas inte) och användarens webbplatskatalog. C-standardströmmarna (t.ex. stdout) och LC_CTYPE-lokalen lämnas oförändrade. Signalhanterare är inte installerade.

Konfigurationsfiler används fortfarande med den här konfigurationen för att bestämma sökvägar som inte är specificerade. Se till att PyConfig.home anges för att undvika att beräkna standardsökvägskonfigurationen.

Python-konfiguration

funktionerna PyPreConfig_InitPythonConfig() och PyConfig_InitPythonConfig() skapar en konfiguration för att bygga ett anpassat Python som beter sig som det vanliga Python.

Miljövariabler och kommandoradsargument används för att konfigurera Python, medan globala konfigurationsvariabler ignoreras.

Denna funktion aktiverar C locale coercion (PEP 538) och Python UTF-8 Mode (PEP 540) beroende på LC_CTYPE locale, PYTHONUTF8 och PYTHONCOERCECLOCALE miljövariabler.

Konfiguration av Python-sökväg

PyConfig innehåller flera fält för sökvägskonfigurationen:

• Ingångar för konfiguration av sökväg:

  • PyConfig.home

  • PyConfig.platlibdir

  • PyConfig.pathconfig_warnings

  • PyConfig.program_namn

  • PyConfig.pythonpath_env

  • aktuell arbetskatalog: för att få absoluta sökvägar

  • PATH miljövariabel för att få den fullständiga sökvägen till programmet (från PyConfig.program_name)

  • miljövariabeln PYVENV_LAUNCHER__

  • (Endast Windows) Programsökvägar i registret under ”SoftwarePythonPythonCoreX.YPythonPath” i HKEY_CURRENT_USER och HKEY_LOCAL_MACHINE (där X.Y är Python-versionen).

• Utmatningsfält för konfiguration av sökväg:

  • PyConfig.base_exec_prefix

  • PyConfig.base_executable

  • PyConfig.base_prefix

  • PyConfig.exec_prefix

  • PyConfig.executable

  • PyConfig.module_search_paths_set, PyConfig.module_search_paths

  • PyConfig.prefix

Om minst ett ”utdatafält” inte är inställt, beräknar Python sökvägskonfigurationen för att fylla oinställda fält. Om module_search_paths_set är lika med 0, åsidosätts module_search_paths och module_search_paths_set sätts till 1.

Det är möjligt att helt ignorera funktionen som beräknar standardsökvägskonfigurationen genom att uttryckligen ange alla utdatafält för sökvägskonfigurationen som anges ovan. En sträng anses vara inställd även om den inte är tom. module_search_paths betraktas som set om module_search_paths_set är satt till 1. I detta fall kommer module_search_paths att användas utan modifiering.

Sätt pathconfig_warnings till 0 för att undertrycka varningar vid beräkning av sökvägskonfigurationen (endast Unix, Windows loggar inte någon varning).

Om fälten base_prefix eller base_exec_prefix inte har angetts ärver de sina värden från prefix respektive exec_prefix.

Py_RunMain() och Py_Main() modifierar sys.path:

• Om run_filename är inställd och är en katalog som innehåller ett __main__.py -skript, prepend run_filename till sys.path.

• Om isolated är noll:

  • Om run_module är inställd, lägg till den aktuella katalogen i sys.path. Gör ingenting om den aktuella katalogen inte kan läsas.

  • Om run_filename är inställt, lägg till katalogen för filnamnet i sys.path.

  • I annat fall läggs en tom sträng till sys.path.

Om site_import inte är noll, kan sys.path ändras av modulen site. Om user_site_directory inte är noll och användarens katalog för site-paketet finns, lägger modulen site till användarens katalog för site-paketet till sys.path.

Följande konfigurationsfiler används av sökvägskonfigurationen:

• pyvenv.cfg

• filen ._pth (t.ex. python._pth)

• pybuilddir.txt (endast Unix)

Om en ._pth -fil finns:

• Sätt isolated till 1.

• Sätt use_environment till 0.

• Ställ in site_import till 0.

• Sätt safe_path till 1.

Om home inte är inställd och en pyvenv.cfg -fil finns i samma katalog som executable, eller dess överordnade, kommer prefix och exec_prefix att ställas in på den platsen. När detta händer behåller base_prefix och base_exec_prefix fortfarande sina värden och pekar på basinstallationen. Se Virtuella miljöer för mer information.

Miljövariabeln __PYVENV_LAUNCHER__ används för att ställa in PyConfig.base_executable.

Ändrad i version 3.14: prefix, och exec_prefix, är nu inställda på katalogen pyvenv.cfg. Detta gjordes tidigare av site, och påverkas därför av -S.

Py_GetArgcArgv()

void Py_GetArgcArgv(int *argc, wchar_t ***argv)

Hämta de ursprungliga kommandoradsargumenten, innan Python ändrade dem.

Se även PyConfig.orig_argv member.

Fördröjning av exekvering av huvudmodul

I vissa inbäddningsfall kan det vara önskvärt att skilja initialiseringen av tolken från exekveringen av huvudmodulen.

Denna separation kan uppnås genom att sätta PyConfig.run_command till den tomma strängen under initialiseringen (för att förhindra att tolken hamnar i den interaktiva prompten) och sedan köra den önskade huvudmodulskoden med __main__.__dict__ som globalt namnrymd.