# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Rafael Fontenelle , 2022
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-12-30 14:59+0000\n"
"PO-Revision-Date: 2022-11-05 17:21+0000\n"
"Last-Translator: Rafael Fontenelle , 2022\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/init.rst:8
msgid "Initialization, Finalization, and Threads"
msgstr " (initialization) (finalization)"

#: ../../c-api/init.rst:10
msgid "See also :ref:`Python Initialization Configuration `."
msgstr ":ref:`Python  ` "

#: ../../c-api/init.rst:15
msgid "Before Python Initialization"
msgstr "Python "

#: ../../c-api/init.rst:17
msgid ""
"In an application embedding  Python, the :c:func:`Py_Initialize` function "
"must be called before using any other Python/C API functions; with the "
"exception of a few functions and the :ref:`global configuration variables "
"`."
msgstr ""
"Python  Python/C API "
" :c:func:`Py_Initialize` "
" :ref:` ` "

#: ../../c-api/init.rst:22
msgid ""
"The following functions can be safely called before Python is initialized:"
msgstr " Python :"

#: ../../c-api/init.rst:24
msgid "Configuration functions:"
msgstr ":"

#: ../../c-api/init.rst:26
msgid ":c:func:`PyImport_AppendInittab`"
msgstr ":c:func:`PyImport_AppendInittab`"

#: ../../c-api/init.rst:27
msgid ":c:func:`PyImport_ExtendInittab`"
msgstr ":c:func:`PyImport_ExtendInittab`"

#: ../../c-api/init.rst:28
msgid ":c:func:`PyInitFrozenExtensions`"
msgstr ":c:func:`PyInitFrozenExtensions`"

#: ../../c-api/init.rst:29
msgid ":c:func:`PyMem_SetAllocator`"
msgstr ":c:func:`PyMem_SetAllocator`"

#: ../../c-api/init.rst:30
msgid ":c:func:`PyMem_SetupDebugHooks`"
msgstr ":c:func:`PyMem_SetupDebugHooks`"

#: ../../c-api/init.rst:31
msgid ":c:func:`PyObject_SetArenaAllocator`"
msgstr ":c:func:`PyObject_SetArenaAllocator`"

#: ../../c-api/init.rst:32
msgid ":c:func:`Py_SetPath`"
msgstr ":c:func:`Py_SetPath`"

#: ../../c-api/init.rst:33
msgid ":c:func:`Py_SetProgramName`"
msgstr ":c:func:`Py_SetProgramName`"

#: ../../c-api/init.rst:34
msgid ":c:func:`Py_SetPythonHome`"
msgstr ":c:func:`Py_SetPythonHome`"

#: ../../c-api/init.rst:35
msgid ":c:func:`Py_SetStandardStreamEncoding`"
msgstr ":c:func:`Py_SetStandardStreamEncoding`"

#: ../../c-api/init.rst:36
msgid ":c:func:`PySys_AddWarnOption`"
msgstr ":c:func:`PySys_AddWarnOption`"

#: ../../c-api/init.rst:37
msgid ":c:func:`PySys_AddXOption`"
msgstr ":c:func:`PySys_AddXOption`"

#: ../../c-api/init.rst:38
msgid ":c:func:`PySys_ResetWarnOptions`"
msgstr ":c:func:`PySys_ResetWarnOptions`"

#: ../../c-api/init.rst:40
msgid "Informative functions:"
msgstr ":"

#: ../../c-api/init.rst:42
msgid ":c:func:`Py_IsInitialized`"
msgstr ":c:func:`Py_IsInitialized`"

#: ../../c-api/init.rst:43
msgid ":c:func:`PyMem_GetAllocator`"
msgstr ":c:func:`PyMem_GetAllocator`"

#: ../../c-api/init.rst:44
msgid ":c:func:`PyObject_GetArenaAllocator`"
msgstr ":c:func:`PyObject_GetArenaAllocator`"

#: ../../c-api/init.rst:45
msgid ":c:func:`Py_GetBuildInfo`"
msgstr ":c:func:`Py_GetBuildInfo`"

#: ../../c-api/init.rst:46
msgid ":c:func:`Py_GetCompiler`"
msgstr ":c:func:`Py_GetCompiler`"

#: ../../c-api/init.rst:47
msgid ":c:func:`Py_GetCopyright`"
msgstr ":c:func:`Py_GetCopyright`"

#: ../../c-api/init.rst:48
msgid ":c:func:`Py_GetPlatform`"
msgstr ":c:func:`Py_GetPlatform`"

#: ../../c-api/init.rst:49
msgid ":c:func:`Py_GetVersion`"
msgstr ":c:func:`Py_GetVersion`"

#: ../../c-api/init.rst:51
msgid "Utilities:"
msgstr ":"

#: ../../c-api/init.rst:53
msgid ":c:func:`Py_DecodeLocale`"
msgstr ":c:func:`Py_DecodeLocale`"

#: ../../c-api/init.rst:55
msgid "Memory allocators:"
msgstr ":"

#: ../../c-api/init.rst:57
msgid ":c:func:`PyMem_RawMalloc`"
msgstr ":c:func:`PyMem_RawMalloc`"

#: ../../c-api/init.rst:58
msgid ":c:func:`PyMem_RawRealloc`"
msgstr ":c:func:`PyMem_RawRealloc`"

#: ../../c-api/init.rst:59
msgid ":c:func:`PyMem_RawCalloc`"
msgstr ":c:func:`PyMem_RawCalloc`"

#: ../../c-api/init.rst:60
msgid ":c:func:`PyMem_RawFree`"
msgstr ":c:func:`PyMem_RawFree`"

#: ../../c-api/init.rst:64
msgid ""
"The following functions **should not be called** before :c:func:"
"`Py_Initialize`: :c:func:`Py_EncodeLocale`, :c:func:`Py_GetPath`, :c:func:"
"`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, :c:func:"
"`Py_GetProgramFullPath`, :c:func:`Py_GetPythonHome`, :c:func:"
"`Py_GetProgramName` and :c:func:`PyEval_InitThreads`."
msgstr ""
" :c:func:`Py_Initialize`  ** "
"** : :c:func:`Py_EncodeLocale`, :c:func:`Py_GetPath`, :c:func:"
"`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, :c:func:"
"`Py_GetProgramFullPath`, :c:func:`Py_GetPythonHome`, :c:func:"
"`Py_GetProgramName`, :c:func:`PyEval_InitThreads` "

#: ../../c-api/init.rst:74
msgid "Global configuration variables"
msgstr ""

#: ../../c-api/init.rst:76
msgid ""
"Python has variables for the global configuration to control different "
"features and options. By default, these flags are controlled by :ref:"
"`command line options `."
msgstr ""
"Python "
"\n"
" :ref:` ` "

#: ../../c-api/init.rst:80
msgid ""
"When a flag is set by an option, the value of the flag is the number of "
"times that the option was set. For example, ``-b`` sets :c:data:"
"`Py_BytesWarningFlag` to 1 and ``-bb`` sets :c:data:`Py_BytesWarningFlag` to "
"2."
msgstr ""
""
"\n"
" ``-b``  :c:data:`Py_BytesWarningFlag`  1  ``-bb`` "
" :c:data:`Py_BytesWarningFlag`  2 "

#: ../../c-api/init.rst:86
msgid ""
"Issue a warning when comparing :class:`bytes` or :class:`bytearray` with :"
"class:`str` or :class:`bytes` with :class:`int`.  Issue an error if greater "
"or equal to ``2``."
msgstr ""
":class:`bytes`  :class:`bytearray`  :class:`str` "
" :class:`bytes`  :class:`int` \n"
"``2`` "

#: ../../c-api/init.rst:90
msgid "Set by the :option:`-b` option."
msgstr ":option:`-b` "

#: ../../c-api/init.rst:94
msgid ""
"Turn on parser debugging output (for expert only, depending on compilation "
"options)."
msgstr ""
"("
")"

#: ../../c-api/init.rst:97
msgid ""
"Set by the :option:`-d` option and the :envvar:`PYTHONDEBUG` environment "
"variable."
msgstr ":option:`-d`  :envvar:`PYTHONDEBUG` "

#: ../../c-api/init.rst:102
msgid ""
"If set to non-zero, Python won't try to write ``.pyc`` files on the import "
"of source modules."
msgstr ""
"Python  ``.pyc`` "
""

#: ../../c-api/init.rst:105
msgid ""
"Set by the :option:`-B` option and the :envvar:`PYTHONDONTWRITEBYTECODE` "
"environment variable."
msgstr ""
":option:`-B`  :envvar:`PYTHONDONTWRITEBYTECODE` "
""

#: ../../c-api/init.rst:110
msgid ""
"Suppress error messages when calculating the module search path in :c:func:"
"`Py_GetPath`."
msgstr ""
":c:func:`Py_GetPath` "
""

#: ../../c-api/init.rst:113
msgid "Private flag used by ``_freeze_importlib`` and ``frozenmain`` programs."
msgstr ""
"``_freeze_importlib``  ``frozenmain`` "
""

#: ../../c-api/init.rst:117
msgid ""
"Set to ``1`` if the :envvar:`PYTHONHASHSEED` environment variable is set to "
"a non-empty string."
msgstr ""
":envvar:`PYTHONHASHSEED`  ``1`` "
""

#: ../../c-api/init.rst:120
msgid ""
"If the flag is non-zero, read the :envvar:`PYTHONHASHSEED` environment "
"variable to initialize the secret hash seed."
msgstr ""
" :envvar:`PYTHONHASHSEED` "
""

#: ../../c-api/init.rst:125
msgid ""
"Ignore all :envvar:`PYTHON*` environment variables, e.g. :envvar:"
"`PYTHONPATH` and :envvar:`PYTHONHOME`, that might be set."
msgstr ""
" :envvar:`PYTHON*`  :envvar:`PYTHONPATH` "
" :envvar:`PYTHONHOME` "

#: ../../c-api/init.rst:128
msgid "Set by the :option:`-E` and :option:`-I` options."
msgstr ":option:`-E`  :option:`-I` "

#: ../../c-api/init.rst:132
msgid ""
"When a script is passed as first argument or the :option:`-c` option is "
"used, enter interactive mode after executing the script or the command, even "
"when :data:`sys.stdin` does not appear to be a terminal."
msgstr ""
" :option:`-c` "
" :data:`sys.stdin` "
""

#: ../../c-api/init.rst:136
msgid ""
"Set by the :option:`-i` option and the :envvar:`PYTHONINSPECT` environment "
"variable."
msgstr ""
":option:`-i`  :envvar:`PYTHONINSPECT` "

#: ../../c-api/init.rst:141
msgid "Set by the :option:`-i` option."
msgstr ":option:`-i` "

#: ../../c-api/init.rst:145
msgid ""
"Run Python in isolated mode. In isolated mode :data:`sys.path` contains "
"neither the script's directory nor the user's site-packages directory."
msgstr ""
"Python \n"
" :data:`sys.path` "
""

#: ../../c-api/init.rst:148
msgid "Set by the :option:`-I` option."
msgstr ":option:`-I` "

#: ../../c-api/init.rst:154
msgid ""
"If the flag is non-zero, use the ``mbcs`` encoding with ``replace`` error "
"handler, instead of the UTF-8 encoding with ``surrogatepass`` error handler, "
"for the :term:`filesystem encoding and error handler`."
msgstr ""

#: ../../c-api/init.rst:158
msgid ""
"Set to ``1`` if the :envvar:`PYTHONLEGACYWINDOWSFSENCODING` environment "
"variable is set to a non-empty string."
msgstr ""
":envvar:`PYTHONLEGACYWINDOWSFSENCODING` "
" ``1`` "

#: ../../c-api/init.rst:161
msgid "See :pep:`529` for more details."
msgstr " :pep:`529` "

#: ../../c-api/init.rst:163 ../../c-api/init.rst:175
msgid ":ref:`Availability `: Windows."
msgstr ":ref:` `: Windows "

#: ../../c-api/init.rst:167
msgid ""
"If the flag is non-zero, use :class:`io.FileIO` instead of :class:"
"`WindowsConsoleIO` for :mod:`sys` standard streams."
msgstr ""
" :class:`WindowsConsoleIO`  :class:`io."
"FileIO`  :mod:`sys` "

#: ../../c-api/init.rst:170
msgid ""
"Set to ``1`` if the :envvar:`PYTHONLEGACYWINDOWSSTDIO` environment variable "
"is set to a non-empty string."
msgstr ""
":envvar:`PYTHONLEGACYWINDOWSSTDIO` "
" ``1`` "

#: ../../c-api/init.rst:173
msgid "See :pep:`528` for more details."
msgstr " :pep:`528` "

#: ../../c-api/init.rst:179
msgid ""
"Disable the import of the module :mod:`site` and the site-dependent "
"manipulations of :data:`sys.path` that it entails.  Also disable these "
"manipulations if :mod:`site` is explicitly imported later (call :func:`site."
"main` if you want them to be triggered)."
msgstr ""
":mod:`site`  import  site "
" :data:`sys.path`  :mod:`site`  "
"import  ( :func:`site."
"main` )"

#: ../../c-api/init.rst:184
msgid "Set by the :option:`-S` option."
msgstr ":option:`-S` "

#: ../../c-api/init.rst:188
msgid ""
"Don't add the :data:`user site-packages directory ` to :data:"
"`sys.path`."
msgstr ""
":data:` `  :data:"
"`sys.path` "

#: ../../c-api/init.rst:191
msgid ""
"Set by the :option:`-s` and :option:`-I` options, and the :envvar:"
"`PYTHONNOUSERSITE` environment variable."
msgstr ""
":option:`-s`  :option:`-I`  :envvar:`PYTHONNOUSERSITE` "
""

#: ../../c-api/init.rst:196
msgid ""
"Set by the :option:`-O` option and the :envvar:`PYTHONOPTIMIZE` environment "
"variable."
msgstr ""
":option:`-O`  :envvar:`PYTHONOPTIMIZE` "

#: ../../c-api/init.rst:201
msgid ""
"Don't display the copyright and version messages even in interactive mode."
msgstr ""
" copyright "

#: ../../c-api/init.rst:203
msgid "Set by the :option:`-q` option."
msgstr ":option:`-q` "

#: ../../c-api/init.rst:209
msgid "Force the stdout and stderr streams to be unbuffered."
msgstr ""

#: ../../c-api/init.rst:211
msgid ""
"Set by the :option:`-u` option and the :envvar:`PYTHONUNBUFFERED` "
"environment variable."
msgstr ""
":option:`-u`  :envvar:`PYTHONUNBUFFERED` "

#: ../../c-api/init.rst:216
msgid ""
"Print a message each time a module is initialized, showing the place "
"(filename or built-in module) from which it is loaded.  If greater or equal "
"to ``2``, print a message for each file that is checked for when searching "
"for a module. Also provides information on module cleanup at exit."
msgstr ""
" ("
") \n"
" 2 "
""
""

#: ../../c-api/init.rst:221
msgid ""
"Set by the :option:`-v` option and the :envvar:`PYTHONVERBOSE` environment "
"variable."
msgstr ""
":option:`-v`  :envvar:`PYTHONVERBOSE` "

#: ../../c-api/init.rst:226
msgid "Initializing and finalizing the interpreter"
msgstr ""

#: ../../c-api/init.rst:244
msgid ""
"Initialize the Python interpreter.  In an application embedding  Python, "
"this should be called before using any other Python/C API functions; see :"
"ref:`Before Python Initialization ` for the few exceptions."
msgstr ""
"Python \n"
"Python  Python/C API "
""
" :ref:`Python  ` "

#: ../../c-api/init.rst:248
msgid ""
"This initializes the table of loaded modules (``sys.modules``), and creates "
"the fundamental modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`.  It "
"also initializes the module search path (``sys.path``). It does not set "
"``sys.argv``; use :c:func:`PySys_SetArgvEx` for that.  This is a no-op when "
"called for a second time (without calling :c:func:`Py_FinalizeEx` first).  "
"There is no return value; it is a fatal error if the initialization fails."
msgstr ""
" (``sys.modules``) "
" :mod:`builtins`, :mod:`__main__`, :mod:`sys` "
" (``sys.path``)  ``sys.argv`` "
" :c:func:`PySys_SetArgvEx` "
" (:c:func:`Py_FinalizeEx` ) "
""

#: ../../c-api/init.rst:257
msgid ""
"On Windows, changes the console mode from ``O_TEXT`` to ``O_BINARY``, which "
"will also affect non-Python uses of the console using the C Runtime."
msgstr ""
"Windows  ``O_TEXT``  ``O_BINARY`` "
" C  Python "
""

#: ../../c-api/init.rst:263
msgid ""
"This function works like :c:func:`Py_Initialize` if *initsigs* is ``1``. If "
"*initsigs* is ``0``, it skips initialization registration of signal "
"handlers, which might be useful when Python is embedded."
msgstr ""
"*initsigs*  ``1``  :c:func:`Py_Initialize` "
"\n"
"*initsigs*  ``0`` "
" Python "

#: ../../c-api/init.rst:270
msgid ""
"Return true (nonzero) when the Python interpreter has been initialized, "
"false (zero) if not.  After :c:func:`Py_FinalizeEx` is called, this returns "
"false until :c:func:`Py_Initialize` is called again."
msgstr ""
"Python ()()"
":c:func:`Py_FinalizeEx` :c:func:`Py_Initialize` "
""

#: ../../c-api/init.rst:277
msgid ""
"Undo all initializations made by :c:func:`Py_Initialize` and subsequent use "
"of Python/C API functions, and destroy all sub-interpreters (see :c:func:"
"`Py_NewInterpreter` below) that were created and not yet destroyed since the "
"last call to :c:func:`Py_Initialize`.  Ideally, this frees all memory "
"allocated by the Python interpreter.  This is a no-op when called for a "
"second time (without calling :c:func:`Py_Initialize` again first).  Normally "
"the return value is ``0``.  If there were errors during finalization "
"(flushing buffered data), ``-1`` is returned."
msgstr ""
":c:func:`Py_Initialize`  Python/C API "
" :c:func:`Py_Initialize`   Python "
"  (sub-interpreter,  :c:func:"
"`Py_NewInterpreter` ) \n"
" Python "
"\n"
" (:c:func:`Py_Initialize` ) "
"\n"
" ``0``  () "
" ``-1`` "

#: ../../c-api/init.rst:286
msgid ""
"This function is provided for a number of reasons.  An embedding application "
"might want to restart Python without having to restart the application "
"itself. An application that has loaded the Python interpreter from a "
"dynamically loadable library (or DLL) might want to free all memory "
"allocated by Python before unloading the DLL. During a hunt for memory leaks "
"in an application a developer might want to free all memory allocated by "
"Python before exiting from the application."
msgstr ""
"Python "
" Python "
" ( DLL)  Python "
"DLL  "
"Python "
" Python "
""

#: ../../c-api/init.rst:294
msgid ""
"**Bugs and caveats:** The destruction of modules and objects in modules is "
"done in random order; this may cause destructors (:meth:`__del__` methods) "
"to fail when they depend on other objects (even functions) or modules.  "
"Dynamically loaded extension modules loaded by Python are not unloaded.  "
"Small amounts of memory allocated by the Python interpreter may not be freed "
"(if you find a leak, please report it).  Memory tied up in circular "
"references between objects is not freed.  Some memory allocated by extension "
"modules may not be freed.  Some extensions may not work properly if their "
"initialization routine is called more than once; this can happen if an "
"application calls :c:func:`Py_Initialize` and :c:func:`Py_FinalizeEx` more "
"than once."
msgstr ""
"**:** "
"() "
"  (:meth:`__del__` ) "
" Python "
" Python "
" ("
")"
""
" 2 "
" :c:func:`Py_Initialize`   :c:func:"
"`Py_FinalizeEx`  2 "

#: ../../c-api/init.rst:305
msgid ""
"Raises an :ref:`auditing event ` ``cpython."
"_PySys_ClearAuditHooks`` with no arguments."
msgstr ""
" :ref:` ` ``cpython._PySys_ClearAuditHooks`` "
" "

#: ../../c-api/init.rst:311
msgid ""
"This is a backwards-compatible version of :c:func:`Py_FinalizeEx` that "
"disregards the return value."
msgstr ""
" :c:func:`Py_FinalizeEx` "
""

#: ../../c-api/init.rst:316
msgid "Process-wide parameters"
msgstr ""

#: ../../c-api/init.rst:326
msgid ""
"This function should be called before :c:func:`Py_Initialize`, if it is "
"called at all. It specifies which encoding and error handling to use with "
"standard IO, with the same meanings as in :func:`str.encode`."
msgstr ""
" :c:func:`Py_Initialize` "
" IO "
" :func:`str.encode` "

#: ../../c-api/init.rst:330
msgid ""
"It overrides :envvar:`PYTHONIOENCODING` values, and allows embedding code to "
"control IO encoding when the environment variable does not work."
msgstr ""
" :envvar:`PYTHONIOENCODING` "
" IO "

#: ../../c-api/init.rst:333
msgid ""
"*encoding* and/or *errors* may be ``NULL`` to use :envvar:`PYTHONIOENCODING` "
"and/or default values (depending on other settings)."
msgstr ""
"*encoding*  *errors*  ``NULL``  :"
"envvar:`PYTHONIOENCODING` "
" ()"

#: ../../c-api/init.rst:337
msgid ""
"Note that :data:`sys.stderr` always uses the \"backslashreplace\" error "
"handler, regardless of this (or any other) setting."
msgstr ""
" ()  :data:`sys.stderr`  "
"\"backslashreplace\" "

#: ../../c-api/init.rst:340
msgid ""
"If :c:func:`Py_FinalizeEx` is called, this function will need to be called "
"again in order to affect subsequent calls to :c:func:`Py_Initialize`."
msgstr ""
":c:func:`Py_FinalizeEx` :c:func:`Py_Initialize` "
""

#: ../../c-api/init.rst:343
msgid ""
"Returns ``0`` if successful, a nonzero value on error (e.g. calling after "
"the interpreter has already been initialized)."
msgstr ""
" ``0``  ``0``  ("
")"

#: ../../c-api/init.rst:356
msgid ""
"This function should be called before :c:func:`Py_Initialize` is called for "
"the first time, if it is called at all.  It tells the interpreter the value "
"of the ``argv[0]`` argument to the :c:func:`main` function of the program "
"(converted to wide characters). This is used by :c:func:`Py_GetPath` and "
"some other functions below to find the Python run-time libraries relative to "
"the interpreter executable.  The default value is ``'python'``.  The "
"argument should point to a zero-terminated wide character string in static "
"storage whose contents will not change for the duration of the program's "
"execution.  No code in the Python interpreter will change the contents of "
"this storage."
msgstr ""
" :c:func:`Py_Initialize` "
" :c:func:"
"`main`  ``argv[0]``  ("
") :c:func:`Py_GetPath` "
" Python "
" ``'python'`` "
""
" Python "
""

#: ../../c-api/init.rst:367 ../../c-api/init.rst:511 ../../c-api/init.rst:617
#: ../../c-api/init.rst:644 ../../c-api/init.rst:661
msgid ""
"Use :c:func:`Py_DecodeLocale` to decode a bytes string to get a :c:expr:"
"`wchar_*` string."
msgstr ""
" :c:expr:`wchar_*`  :c:func:"
"`Py_DecodeLocale` "

#: ../../c-api/init.rst:375
msgid ""
"Return the program name set with :c:func:`Py_SetProgramName`, or the "
"default. The returned string points into static storage; the caller should "
"not modify its value."
msgstr ""
":c:func:`Py_SetProgramName` "
""
""

#: ../../c-api/init.rst:379 ../../c-api/init.rst:398 ../../c-api/init.rst:439
#: ../../c-api/init.rst:458 ../../c-api/init.rst:482 ../../c-api/init.rst:671
msgid ""
"This function should not be called before :c:func:`Py_Initialize`, otherwise "
"it returns ``NULL``."
msgstr ""

#: ../../c-api/init.rst:382 ../../c-api/init.rst:401 ../../c-api/init.rst:442
#: ../../c-api/init.rst:461 ../../c-api/init.rst:487 ../../c-api/init.rst:674
msgid "It now returns ``NULL`` if called before :c:func:`Py_Initialize`."
msgstr ""

#: ../../c-api/init.rst:388
msgid ""
"Return the *prefix* for installed platform-independent files. This is "
"derived through a number of complicated rules from the program name set "
"with :c:func:`Py_SetProgramName` and some environment variables; for "
"example, if the program name is ``'/usr/local/bin/python'``, the prefix is "
"``'/usr/local'``. The returned string points into static storage; the caller "
"should not modify its value.  This corresponds to the :makevar:`prefix` "
"variable in the top-level :file:`Makefile` and the ``--prefix`` argument to "
"the :program:`configure` script at build time.  The value is available to "
"Python code as ``sys.prefix``. It is only useful on Unix.  See also the next "
"function."
msgstr ""
" "
"*prefix*  :c:func:`Py_SetProgramName` "
""
" ``'/usr/local/bin/python'`` prefix  ``'/usr/"
"local'`` ; "
" :file:"
"`Makefile`  :makevar:`prefix`  :program:"
"`configure`  ``--prefix``  "
"Python  ``sys.prefix`` Unix"
""

#: ../../c-api/init.rst:407
msgid ""
"Return the *exec-prefix* for installed platform-*dependent* files.  This is "
"derived through a number of complicated rules from the program name set "
"with :c:func:`Py_SetProgramName` and some environment variables; for "
"example, if the program name is ``'/usr/local/bin/python'``, the exec-prefix "
"is ``'/usr/local'``.  The returned string points into static storage; the "
"caller should not modify its value.  This corresponds to the :makevar:"
"`exec_prefix` variable in the top-level :file:`Makefile` and the ``--exec-"
"prefix`` argument to the :program:`configure` script at build  time.  The "
"value is available to Python code as ``sys.exec_prefix``.  It is only useful "
"on Unix."
msgstr ""
" **  *exec-"
"prefix*  :c:func:`Py_SetProgramName` "
""
" ``'/usr/local/bin/python'`` exec-prefix  ``'/"
"usr/local'`` ; "
" :file:"
"`Makefile`  :makevar:`exec_prefix`  :"
"program:`configure`  ``--exec-prefix`` "
" Python  ``sys.exec_prefix``  "
"Unix"

#: ../../c-api/init.rst:417
msgid ""
"Background: The exec-prefix differs from the prefix when platform dependent "
"files (such as executables and shared libraries) are installed in a "
"different directory tree.  In a typical installation, platform dependent "
"files may be installed in the :file:`/usr/local/plat` subtree while platform "
"independent may be installed in :file:`/usr/local`."
msgstr ""
":  () "
" exec-prefix  prefix "
" :file:`/"
"usr/local`  :file:`/usr/"
"local/plat` "

#: ../../c-api/init.rst:423
msgid ""
"Generally speaking, a platform is a combination of hardware and software "
"families, e.g.  Sparc machines running the Solaris 2.x operating system are "
"considered the same platform, but Intel machines running Solaris 2.x are "
"another platform, and Intel machines running Linux are yet another "
"platform.  Different major revisions of the same operating system generally "
"also form different platforms.  Non-Unix operating systems are a different "
"story; the installation strategies on those systems are so different that "
"the prefix and exec-prefix are meaningless, and set to the empty string. "
"Note that compiled Python bytecode files are platform independent (but not "
"independent from the Python version by which they were compiled!)."
msgstr ""
""
"Solaris 2.x  Sparc "
"Solaris 2.x  Intel "
" Intel  Linux "
""
" Unix "
";  Unix "
"prefix  exec-prefix "
" Python "
" ( Python "
"!)"

#: ../../c-api/init.rst:434
msgid ""
"System administrators will know how to configure the :program:`mount` or :"
"program:`automount` programs to share :file:`/usr/local` between platforms "
"while having :file:`/usr/local/plat` be a different filesystem for each "
"platform."
msgstr ""
" :program:`mount`  :program:`automount` "
" :file:`/usr/local/plat` "
" :file:`/usr/local` "
""

#: ../../c-api/init.rst:452
msgid ""
"Return the full program name of the Python executable; this is  computed as "
"a side-effect of deriving the default module search path  from the program "
"name (set by :c:func:`Py_SetProgramName` above). The returned string points "
"into static storage; the caller should not modify its value.  The value is "
"available to Python code as ``sys.executable``."
msgstr ""
"Python ; "
" ( :c:func:`Py_SetProgramName`  ) "
""
";  "
"Python  ``sys.executable`` "

#: ../../c-api/init.rst:472
msgid ""
"Return the default module search path; this is computed from the program "
"name (set by :c:func:`Py_SetProgramName` above) and some environment "
"variables. The returned string consists of a series of directory names "
"separated by a platform dependent delimiter character.  The delimiter "
"character is ``':'`` on Unix and macOS, ``';'`` on Windows.  The returned "
"string points into static storage; the caller should not modify its value.  "
"The list :data:`sys.path` is initialized with this value on interpreter "
"startup; it can be (and usually is) modified later to change the search path "
"for loading modules."
msgstr ""
";  ( :c:func:"
"`Py_SetProgramName` ) "
""
" Unix  macOS  "
"``':'``, Windows  ``';'`` "
";  :data:`sys.path` "
""
""

#: ../../c-api/init.rst:498
msgid ""
"Set the default module search path.  If this function is called before :c:"
"func:`Py_Initialize`, then :c:func:`Py_GetPath` won't attempt to compute a "
"default search path but uses the one provided instead.  This is useful if "
"Python is embedded by an application that has full knowledge of the location "
"of all modules.  The path components should be separated by the platform "
"dependent delimiter character, which is ``':'`` on Unix and macOS, ``';'`` "
"on Windows."
msgstr ""
" :c:func:"
"`Py_Initialize`  :c:func:`Py_GetPath` "
""
" Python "
""
" Unix  macOS "
" ``':'`` Windows  ``';'`` "

#: ../../c-api/init.rst:506
msgid ""
"This also causes :data:`sys.executable` to be set to the program full path "
"(see :c:func:`Py_GetProgramFullPath`) and for :data:`sys.prefix` and :data:"
"`sys.exec_prefix` to be empty.  It is up to the caller to modify these if "
"required after calling :c:func:`Py_Initialize`."
msgstr ""

#: ../../c-api/init.rst:514
msgid ""
"The path argument is copied internally, so the caller may free it after the "
"call completes."
msgstr ""
""
""

#: ../../c-api/init.rst:517
msgid ""
"The program full path is now used for :data:`sys.executable`, instead of the "
"program name."
msgstr ""
" :data:`sys.executable` "
""

#: ../../c-api/init.rst:524
msgid ""
"Return the version of this Python interpreter.  This is a string that looks "
"something like ::"
msgstr ""
"Python "
" ::"

#: ../../c-api/init.rst:531
msgid ""
"The first word (up to the first space character) is the current Python "
"version; the first characters are the major and minor version separated by a "
"period.  The returned string points into static storage; the caller should "
"not modify its value.  The value is available to Python code as :data:`sys."
"version`."
msgstr ""
" ()  Python ; "
""
"; "
" Python  :data:`sys.version` "
""

#: ../../c-api/init.rst:541
msgid ""
"Return the platform identifier for the current platform.  On Unix, this is "
"formed from the \"official\" name of the operating system, converted to "
"lower case, followed by the major revision number; e.g., for Solaris 2.x, "
"which is also known as SunOS 5.x, the value is ``'sunos5'``.  On macOS, it "
"is ``'darwin'``.  On Windows, it is ``'win'``.  The returned string points "
"into static storage; the caller should not modify its value.  The value is "
"available to Python code as ``sys.platform``."
msgstr ""
"Unix"
" \"\" "
" Solaris 2.x SunOS 5.x, "
"``'sunos5'`` macOS  ``'darwin'`` "
"Windows  ``'win'`` "
";  Python  "
"``sys.platform`` "

#: ../../c-api/init.rst:552
msgid ""
"Return the official copyright string for the current Python version, for "
"example"
msgstr ""
" Python "

#: ../../c-api/init.rst:554
msgid "``'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'``"
msgstr "``'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'``"

#: ../../c-api/init.rst:558
msgid ""
"The returned string points into static storage; the caller should not modify "
"its value.  The value is available to Python code as ``sys.copyright``."
msgstr ""
"; "
" Python  ``sys.copyright`` "
""

#: ../../c-api/init.rst:564
msgid ""
"Return an indication of the compiler used to build the current Python "
"version, in square brackets, for example::"
msgstr ""
" Python "
"::"

#: ../../c-api/init.rst:571 ../../c-api/init.rst:585
msgid ""
"The returned string points into static storage; the caller should not modify "
"its value.  The value is available to Python code as part of the variable "
"``sys.version``."
msgstr ""
"; "
" Python  ``sys.version`` "
""

#: ../../c-api/init.rst:578
msgid ""
"Return information about the sequence number and build date and time  of the "
"current Python interpreter instance, for example ::"
msgstr ""
" Python "
" ::"

#: ../../c-api/init.rst:597
msgid ""
"Set :data:`sys.argv` based on *argc* and *argv*.  These parameters are "
"similar to those passed to the program's :c:func:`main` function with the "
"difference that the first entry should refer to the script file to be "
"executed rather than the executable hosting the Python interpreter.  If "
"there isn't a script that will be run, the first entry in *argv* can be an "
"empty string.  If this function fails to initialize :data:`sys.argv`, a "
"fatal condition is signalled using :c:func:`Py_FatalError`."
msgstr ""
"*argc*  *argv*  :data:`sys.argv` "
" :c:func:`main`  Python "
""
" *argv* "
" :data:`sys.argv` "
" :c:func:`Py_FatalError` "

#: ../../c-api/init.rst:605
msgid ""
"If *updatepath* is zero, this is all the function does.  If *updatepath* is "
"non-zero, the function also modifies :data:`sys.path` according to the "
"following algorithm:"
msgstr ""
"*updatepath*  0  "
"*updatepath*  0  :data:`sys.path` "
":"

#: ../../c-api/init.rst:609
msgid ""
"If the name of an existing script is passed in ``argv[0]``, the absolute "
"path of the directory where the script is located is prepended to :data:`sys."
"path`."
msgstr ""
" ``argv[0]`` "
" :data:`sys.path` "

#: ../../c-api/init.rst:612
msgid ""
"Otherwise (that is, if *argc* is ``0`` or ``argv[0]`` doesn't point to an "
"existing file name), an empty string is prepended to :data:`sys.path`, which "
"is the same as prepending the current working directory (``\".\"``)."
msgstr ""
" (*argc*  ``0``  ``argv[0]`` "
") :data:`sys.path` \n"
" (``\".\"``) "

#: ../../c-api/init.rst:621
msgid ""
"It is recommended that applications embedding the Python interpreter for "
"purposes other than executing a single script pass ``0`` as *updatepath*, "
"and update :data:`sys.path` themselves if desired. See `CVE-2008-5983 "
"`_."
msgstr ""
"Python "
" *updatepath*  ``0``  :data:"
"`sys.path` \n"
"`CVE-2008-5983 `_ "

#: ../../c-api/init.rst:626
msgid ""
"On versions before 3.1.3, you can achieve the same effect by manually "
"popping the first :data:`sys.path` element after having called :c:func:"
"`PySys_SetArgv`, for example using::"
msgstr ""
"3.1.3  :c:func:`PySys_SetArgv` "
" :data:`sys.path` "
"::"

#: ../../c-api/init.rst:640
msgid ""
"This function works like :c:func:`PySys_SetArgvEx` with *updatepath* set to "
"``1`` unless the :program:`python` interpreter was started with the :option:"
"`-I`."
msgstr ""
" :program:`python`  :option:`-I` "
" :c:func:`PySys_SetArgvEx`  *updatepath*  ``1`` "
""

#: ../../c-api/init.rst:647
msgid "The *updatepath* value depends on :option:`-I`."
msgstr "*updatepath*  :option:`-I` "

#: ../../c-api/init.rst:652
msgid ""
"Set the default \"home\" directory, that is, the location of the standard "
"Python libraries.  See :envvar:`PYTHONHOME` for the meaning of the argument "
"string."
msgstr ""
"Python  \"home\" "
" :envvar:`PYTHONHOME` "

#: ../../c-api/init.rst:656
msgid ""
"The argument should point to a zero-terminated character string in static "
"storage whose contents will not change for the duration of the program's "
"execution.  No code in the Python interpreter will change the contents of "
"this storage."
msgstr ""
""
"Python "
""

#: ../../c-api/init.rst:667
msgid ""
"Return the default \"home\", that is, the value set by a previous call to :c:"
"func:`Py_SetPythonHome`, or the value of the :envvar:`PYTHONHOME` "
"environment variable if it is set."
msgstr ""
" :c:func:`Py_SetPythonHome`  \"home\" "
" :envvar:`PYTHONHOME` "

#: ../../c-api/init.rst:681
msgid "Thread State and the Global Interpreter Lock"
msgstr ""
" (thread state)  (global "
"interpreter lock)"

#: ../../c-api/init.rst:688
msgid ""
"The Python interpreter is not fully thread-safe.  In order to support multi-"
"threaded Python programs, there's a global lock, called the :term:`global "
"interpreter lock` or :term:`GIL`, that must be held by the current thread "
"before it can safely access Python objects. Without the lock, even the "
"simplest operations could cause problems in a multi-threaded program: for "
"example, when two threads simultaneously increment the reference count of "
"the same object, the reference count could end up being incremented only "
"once instead of twice."
msgstr ""
"Python  "
"Python  :term:` "
"`  :term:`GIL` "
" Python "
""
""
""
""
""

#: ../../c-api/init.rst:698
msgid ""
"Therefore, the rule exists that only the thread that has acquired the :term:"
"`GIL` may operate on Python objects or call Python/C API functions. In order "
"to emulate concurrency of execution, the interpreter regularly tries to "
"switch threads (see :func:`sys.setswitchinterval`).  The lock is also "
"released around potentially blocking I/O operations like reading or writing "
"a file, so that other Python threads can run in the meantime."
msgstr ""
" :term:`GIL`  Python "
" Python/C API "
""
" (:func:`sys.setswitchinterval` ) "
" I/O  I/O  I/O "
""

#: ../../c-api/init.rst:709
msgid ""
"The Python interpreter keeps some thread-specific bookkeeping information "
"inside a data structure called :c:type:`PyThreadState`.  There's also one "
"global variable pointing to the current :c:type:`PyThreadState`: it can be "
"retrieved using :c:func:`PyThreadState_Get`."
msgstr ""
"Python  :c:type:`PyThreadState` "
" :c:type:"
"`PyThreadState` 1 :c:func:"
"`PyThreadState_Get` "

#: ../../c-api/init.rst:715
msgid "Releasing the GIL from extension code"
msgstr " GIL "

#: ../../c-api/init.rst:717
msgid ""
"Most extension code manipulating the :term:`GIL` has the following simple "
"structure::"
msgstr ""
":term:`GIL` ::"

#: ../../c-api/init.rst:726
msgid "This is so common that a pair of macros exists to simplify it::"
msgstr ""
"2"
"::"

#: ../../c-api/init.rst:736
msgid ""
"The :c:macro:`Py_BEGIN_ALLOW_THREADS` macro opens a new block and declares a "
"hidden local variable; the :c:macro:`Py_END_ALLOW_THREADS` macro closes the "
"block."
msgstr ""
":c:macro:`Py_BEGIN_ALLOW_THREADS` "
"; :c:macro:`Py_END_ALLOW_THREADS` "

#: ../../c-api/init.rst:740
msgid "The block above expands to the following code::"
msgstr "::"

#: ../../c-api/init.rst:752
msgid ""
"Here is how these functions work: the global interpreter lock is used to "
"protect the pointer to the current thread state.  When releasing the lock "
"and saving the thread state, the current thread state pointer must be "
"retrieved before the lock is released (since another thread could "
"immediately acquire the lock and store its own thread state in the global "
"variable). Conversely, when acquiring the lock and restoring the thread "
"state, the lock must be acquired before storing the thread state pointer."
msgstr ""
"GIL "
""
" ("
""
")"
""
""

#: ../../c-api/init.rst:761
msgid ""
"Calling system I/O functions is the most common use case for releasing the "
"GIL, but it can also be useful before calling long-running computations "
"which don't need access to Python objects, such as compression or "
"cryptographic functions operating over memory buffers.  For example, the "
"standard :mod:`zlib` and :mod:`hashlib` modules release the GIL when "
"compressing or hashing data."
msgstr ""
"GIL I/O"
" Python "
" GIL  :mod:"
"`zlib`  :mod:`hashlib`  GIL "
""

#: ../../c-api/init.rst:772
msgid "Non-Python created threads"
msgstr "Python "

#: ../../c-api/init.rst:774
msgid ""
"When threads are created using the dedicated Python APIs (such as the :mod:"
"`threading` module), a thread state is automatically associated to them and "
"the code showed above is therefore correct.  However, when threads are "
"created from C (for example by a third-party library with its own thread "
"management), they don't hold the GIL, nor is there a thread state structure "
"for them."
msgstr ""
"Python API  (:mod:`threading` ) "
"("
")C"
" GIL "
""

#: ../../c-api/init.rst:781
msgid ""
"If you need to call Python code from these threads (often this will be part "
"of a callback API provided by the aforementioned third-party library), you "
"must first register these threads with the interpreter by creating a thread "
"state data structure, then acquiring the GIL, and finally storing their "
"thread state pointer, before you can start using the Python/C API.  When you "
"are done, you should reset the thread state pointer, release the GIL, and "
"finally free the thread state data structure."
msgstr ""
" Python  ("
"API)Python/C API "
"GIL "
""
""
""

#: ../../c-api/init.rst:789
msgid ""
"The :c:func:`PyGILState_Ensure` and :c:func:`PyGILState_Release` functions "
"do all of the above automatically.  The typical idiom for calling into "
"Python from a C thread is::"
msgstr ""
":c:func:`PyGILState_Ensure`  :c:func:`PyGILState_Release` "
" C Python "
"::"

#: ../../c-api/init.rst:803
msgid ""
"Note that the ``PyGILState_*`` functions assume there is only one global "
"interpreter (created automatically by :c:func:`Py_Initialize`).  Python "
"supports the creation of additional interpreters (using :c:func:"
"`Py_NewInterpreter`), but mixing multiple interpreters and the "
"``PyGILState_*`` API is unsupported."
msgstr ""
"``PyGILState_*`` (:c:func:`Py_Initialize` ) "
"1 "
"Python  (:c:func:`Py_NewInterpreter` ) "
" ``PyGILState_*`` API "
""

#: ../../c-api/init.rst:813
msgid "Cautions about fork()"
msgstr ""

#: ../../c-api/init.rst:815
msgid ""
"Another important thing to note about threads is their behaviour in the face "
"of the C :c:func:`fork` call. On most systems with :c:func:`fork`, after a "
"process forks only the thread that issued the fork will exist.  This has a "
"concrete impact both on how locks must be handled and on all stored state in "
"CPython's runtime."
msgstr ""

#: ../../c-api/init.rst:821
msgid ""
"The fact that only the \"current\" thread remains means any locks held by "
"other threads will never be released. Python solves this for :func:`os.fork` "
"by acquiring the locks it uses internally before the fork, and releasing "
"them afterwards. In addition, it resets any :ref:`lock-objects` in the "
"child. When extending or embedding Python, there is no way to inform Python "
"of additional (non-Python) locks that need to be acquired before or reset "
"after a fork. OS facilities such as :c:func:`pthread_atfork` would need to "
"be used to accomplish the same thing. Additionally, when extending or "
"embedding Python, calling :c:func:`fork` directly rather than through :func:"
"`os.fork` (and returning to or calling into Python) may result in a deadlock "
"by one of Python's internal locks being held by a thread that is defunct "
"after the fork. :c:func:`PyOS_AfterFork_Child` tries to reset the necessary "
"locks, but is not always able to."
msgstr ""

#: ../../c-api/init.rst:836
msgid ""
"The fact that all other threads go away also means that CPython's runtime "
"state there must be cleaned up properly, which :func:`os.fork` does.  This "
"means finalizing all other :c:type:`PyThreadState` objects belonging to the "
"current interpreter and all other :c:type:`PyInterpreterState` objects.  Due "
"to this and the special nature of the :ref:`\"main\" interpreter `, :c:func:`fork` should only be called in that "
"interpreter's \"main\" thread, where the CPython global runtime was "
"originally initialized. The only exception is if :c:func:`exec` will be "
"called immediately after."
msgstr ""

#: ../../c-api/init.rst:849
msgid "High-level API"
msgstr "API"

#: ../../c-api/init.rst:851
msgid ""
"These are the most commonly used types and functions when writing C "
"extension code, or when embedding the Python interpreter:"
msgstr ""
"CPython"
":"

#: ../../c-api/init.rst:856
msgid ""
"This data structure represents the state shared by a number of cooperating "
"threads.  Threads belonging to the same interpreter share their module "
"administration and a few other internal items. There are no public members "
"in this structure."
msgstr ""
""
""
" (public) "
""

#: ../../c-api/init.rst:861
msgid ""
"Threads belonging to different interpreters initially share nothing, except "
"process state like available memory, open file descriptors and such.  The "
"global interpreter lock is also shared by all threads, regardless of to "
"which interpreter they belong."
msgstr ""
""
""
"GIL"
""

#: ../../c-api/init.rst:869
msgid ""
"This data structure represents the state of a single thread.  The only "
"public data member is :attr:`interp` (:c:expr:`PyInterpreterState *`), which "
"points to this thread's interpreter state."
msgstr ""
""
" :attr:`interp` (:c:expr:`PyInterpreterState *`) "
""

#: ../../c-api/init.rst:882
msgid "Deprecated function which does nothing."
msgstr ""

#: ../../c-api/init.rst:884
msgid ""
"In Python 3.6 and older, this function created the GIL if it didn't exist."
msgstr ""

#: ../../c-api/init.rst:886
msgid "The function now does nothing."
msgstr ""

#: ../../c-api/init.rst:889
msgid ""
"This function is now called by :c:func:`Py_Initialize()`, so you don't have "
"to call it yourself anymore."
msgstr ""
" :c:func:`Py_Initialize()` "
""

#: ../../c-api/init.rst:893
msgid ""
"This function cannot be called before :c:func:`Py_Initialize()` anymore."
msgstr ""
" :c:func:`Py_Initialize()` "
""

#: ../../c-api/init.rst:903
msgid ""
"Returns a non-zero value if :c:func:`PyEval_InitThreads` has been called.  "
"This function can be called without holding the GIL, and therefore can be "
"used to avoid calls to the locking API when running single-threaded."
msgstr ""
":c:func:`PyEval_InitThreads`  () "
"GIL"
"API"

#: ../../c-api/init.rst:907
msgid "The :term:`GIL` is now initialized by :c:func:`Py_Initialize()`."
msgstr ""
":term:`GIL`  :c:func:`Py_Initialize()` "

#: ../../c-api/init.rst:915
msgid ""
"Release the global interpreter lock (if it has been created) and reset the "
"thread state to ``NULL``, returning the previous thread state (which is not "
"``NULL``).  If the lock has been created, the current thread must have "
"acquired it."
msgstr ""
"(GIL ) GIL ``NULL`` "
" (``NULL`` ) \n"
""
""

#: ../../c-api/init.rst:923
msgid ""
"Acquire the global interpreter lock (if it has been created) and set the "
"thread state to *tstate*, which must not be ``NULL``.  If the lock has been "
"created, the current thread must not have acquired it, otherwise deadlock "
"ensues."
msgstr ""
"(GIL ) GIL  *tstate* "
" *tstate*  ``NULL``  GIL "
""
""

#: ../../c-api/init.rst:929 ../../c-api/init.rst:975 ../../c-api/init.rst:1234
#: ../../c-api/init.rst:1272
msgid ""
"Calling this function from a thread when the runtime is finalizing will "
"terminate the thread, even if the thread was not created by Python. You can "
"use :c:func:`_Py_IsFinalizing` or :func:`sys.is_finalizing` to check if the "
"interpreter is in process of being finalized before calling this function to "
"avoid unwanted termination."
msgstr ""
""
" Python "
"\n"
":c:func:`_Py_IsFinalizing`  :func:`sys.is_finalizing` "
""
""

#: ../../c-api/init.rst:937
msgid ""
"Return the current thread state.  The global interpreter lock must be held. "
"When the current thread state is ``NULL``, this issues a fatal error (so "
"that the caller needn't check for ``NULL``)."
msgstr ""
"GIL "
" ``NULL`` ( ``NULL`` "
") "

#: ../../c-api/init.rst:944
msgid ""
"Swap the current thread state with the thread state given by the argument "
"*tstate*, which may be ``NULL``.  The global interpreter lock must be held "
"and is not released."
msgstr ""
" *tstate* *tstate* "
" ``NULL`` GIL "

#: ../../c-api/init.rst:949
msgid ""
"The following functions use thread-local storage, and are not compatible "
"with sub-interpreters:"
msgstr ""
""
":"

#: ../../c-api/init.rst:954
msgid ""
"Ensure that the current thread is ready to call the Python C API regardless "
"of the current state of Python, or of the global interpreter lock. This may "
"be called as many times as desired by a thread as long as each call is "
"matched with a call to :c:func:`PyGILState_Release`. In general, other "
"thread-related APIs may be used between :c:func:`PyGILState_Ensure` and :c:"
"func:`PyGILState_Release` calls as long as the thread state is restored to "
"its previous state before the Release().  For example, normal usage of the :"
"c:macro:`Py_BEGIN_ALLOW_THREADS` and :c:macro:`Py_END_ALLOW_THREADS` macros "
"is acceptable."
msgstr ""
"PythonGILPython C API"
""
" :c:func:`PyGILState_Release` "
" :c:func:`PyGILState_Ensure`  :c:func:"
"`PyGILState_Release` API "
"Release()"
" :c:macro:`Py_BEGIN_ALLOW_THREADS`  :c:macro:"
"`Py_END_ALLOW_THREADS` "

#: ../../c-api/init.rst:964
msgid ""
"The return value is an opaque \"handle\" to the thread state when :c:func:"
"`PyGILState_Ensure` was called, and must be passed to :c:func:"
"`PyGILState_Release` to ensure Python is left in the same state. Even though "
"recursive calls are allowed, these handles *cannot* be shared - each unique "
"call to :c:func:`PyGILState_Ensure` must save the handle for its call to :c:"
"func:`PyGILState_Release`."
msgstr ""
" :c:func:`PyGILState_Ensure` \""
"\" :c:func:`PyGILState_Release` Python"
" *"
"* -  :c:func:`PyGILState_Ensure` "
" :c:func:`PyGILState_Release` "

#: ../../c-api/init.rst:971
msgid ""
"When the function returns, the current thread will hold the GIL and be able "
"to call arbitrary Python code.  Failure is a fatal error."
msgstr ""
"GIL Python "
""

#: ../../c-api/init.rst:983
msgid ""
"Release any resources previously acquired.  After this call, Python's state "
"will be the same as it was prior to the corresponding :c:func:"
"`PyGILState_Ensure` call (but generally this state will be unknown to the "
"caller, hence the use of the GILState API)."
msgstr ""
"Python"
" :c:func:`PyGILState_Ensure`  ("
"GILState API"
")"

#: ../../c-api/init.rst:988
msgid ""
"Every call to :c:func:`PyGILState_Ensure` must be matched by a call to :c:"
"func:`PyGILState_Release` on the same thread."
msgstr ""
":c:func:`PyGILState_Ensure`  :"
"c:func:`PyGILState_Release` "

#: ../../c-api/init.rst:994
msgid ""
"Get the current thread state for this thread.  May return ``NULL`` if no "
"GILState API has been used on the current thread.  Note that the main thread "
"always has such a thread-state, even if no auto-thread-state call has been "
"made on the main thread.  This is mainly a helper/diagnostic function."
msgstr ""
" "
"GILState API ``NULL`` "
""
""
""

#: ../../c-api/init.rst:1002
msgid ""
"Return ``1`` if the current thread is holding the GIL and ``0`` otherwise. "
"This function can be called from any thread at any time. Only if it has had "
"its Python thread state initialized and currently is holding the GIL will it "
"return ``1``. This is mainly a helper/diagnostic function.  It can be useful "
"for example in callback contexts or memory allocation functions when knowing "
"that the GIL is locked can allow the caller to perform sensitive actions or "
"otherwise behave differently."
msgstr ""
" GIL ``1``  ``0`` "
" "
"Python  GIL  "
"``1`` /"
" GIL "
" sensitive "
""

#: ../../c-api/init.rst:1014
msgid ""
"The following macros are normally used without a trailing semicolon; look "
"for example usage in the Python source distribution."
msgstr ""
"; Python "
""

#: ../../c-api/init.rst:1020
msgid ""
"This macro expands to ``{ PyThreadState *_save; _save = PyEval_SaveThread();"
"``. Note that it contains an opening brace; it must be matched with a "
"following :c:macro:`Py_END_ALLOW_THREADS` macro.  See above for further "
"discussion of this macro."
msgstr ""
" ``{ PyThreadState *_save; _save = PyEval_SaveThread();"
"`` ; "
" :c:macro:`Py_END_ALLOW_THREADS` "
""

#: ../../c-api/init.rst:1028
msgid ""
"This macro expands to ``PyEval_RestoreThread(_save); }``. Note that it "
"contains a closing brace; it must be matched with an earlier :c:macro:"
"`Py_BEGIN_ALLOW_THREADS` macro.  See above for further discussion of this "
"macro."
msgstr ""
" ``PyEval_RestoreThread(_save); }`` "
";  :c:macro:"
"`Py_BEGIN_ALLOW_THREADS` "
""

#: ../../c-api/init.rst:1036
msgid ""
"This macro expands to ``PyEval_RestoreThread(_save);``: it is equivalent to :"
"c:macro:`Py_END_ALLOW_THREADS` without the closing brace."
msgstr ""
" ``PyEval_RestoreThread(_save);`` : "
" :c:macro:`Py_END_ALLOW_THREADS` "

#: ../../c-api/init.rst:1042
msgid ""
"This macro expands to ``_save = PyEval_SaveThread();``: it is equivalent to :"
"c:macro:`Py_BEGIN_ALLOW_THREADS` without the opening brace and variable "
"declaration."
msgstr ""
" ``_save = PyEval_SaveThread();`` : "
" :c:macro:`Py_BEGIN_ALLOW_THREADS` "

#: ../../c-api/init.rst:1048
msgid "Low-level API"
msgstr "API"

#: ../../c-api/init.rst:1050
msgid ""
"All of the following functions must be called after :c:func:`Py_Initialize`."
msgstr ""
" :c:func:`Py_Initialize` "

#: ../../c-api/init.rst:1052
msgid ":c:func:`Py_Initialize()` now initializes the :term:`GIL`."
msgstr ""
":c:func:`Py_Initialize()`  :term:`GIL` "

#: ../../c-api/init.rst:1058
msgid ""
"Create a new interpreter state object.  The global interpreter lock need not "
"be held, but may be held if it is necessary to serialize calls to this "
"function."
msgstr ""
"GIL "
""
""

#: ../../c-api/init.rst:1062
msgid ""
"Raises an :ref:`auditing event ` ``cpython."
"PyInterpreterState_New`` with no arguments."
msgstr ""
" :ref:` ` ``cpython.PyInterpreterState_New`` "
" "

#: ../../c-api/init.rst:1067
msgid ""
"Reset all information in an interpreter state object.  The global "
"interpreter lock must be held."
msgstr ""
"GIL "
""

#: ../../c-api/init.rst:1070
msgid ""
"Raises an :ref:`auditing event ` ``cpython."
"PyInterpreterState_Clear`` with no arguments."
msgstr ""
" :ref:` ` ``cpython."
"PyInterpreterState_Clear``  "

#: ../../c-api/init.rst:1075
msgid ""
"Destroy an interpreter state object.  The global interpreter lock need not "
"be held.  The interpreter state must have been reset with a previous call "
"to :c:func:`PyInterpreterState_Clear`."
msgstr ""
"GIL "
" :c:func:`PyInterpreterState_Clear` "
""

#: ../../c-api/init.rst:1082
msgid ""
"Create a new thread state object belonging to the given interpreter object. "
"The global interpreter lock need not be held, but may be held if it is "
"necessary to serialize calls to this function."
msgstr ""
""
"GIL "
""

#: ../../c-api/init.rst:1089
msgid ""
"Reset all information in a thread state object.  The global interpreter lock "
"must be held."
msgstr ""
"GIL "
""

#: ../../c-api/init.rst:1092
msgid ""
"This function now calls the :c:member:`PyThreadState.on_delete` callback. "
"Previously, that happened in :c:func:`PyThreadState_Delete`."
msgstr ""

#: ../../c-api/init.rst:1099
msgid ""
"Destroy a thread state object.  The global interpreter lock need not be "
"held. The thread state must have been reset with a previous call to :c:func:"
"`PyThreadState_Clear`."
msgstr ""
"GIL "
" :c:func:`PyThreadState_Clear` "
""

#: ../../c-api/init.rst:1106
msgid ""
"Destroy the current thread state and release the global interpreter lock. "
"Like :c:func:`PyThreadState_Delete`, the global interpreter lock need not be "
"held. The thread state must have been reset with a previous call to :c:func:"
"`PyThreadState_Clear`."
msgstr ""

#: ../../c-api/init.rst:1114
msgid "Get the current frame of the Python thread state *tstate*."
msgstr ""

#: ../../c-api/init.rst:1116
msgid ""
"Return a :term:`strong reference`. Return ``NULL`` if no frame is currently "
"executing."
msgstr ""

#: ../../c-api/init.rst:1119
msgid "See also :c:func:`PyEval_GetFrame`."
msgstr ""

#: ../../c-api/init.rst:1121 ../../c-api/init.rst:1130
#: ../../c-api/init.rst:1139
msgid "*tstate* must not be ``NULL``."
msgstr ""

#: ../../c-api/init.rst:1128
msgid ""
"Get the unique thread state identifier of the Python thread state *tstate*."
msgstr ""

#: ../../c-api/init.rst:1137
msgid "Get the interpreter of the Python thread state *tstate*."
msgstr ""

#: ../../c-api/init.rst:1146
msgid "Get the current interpreter."
msgstr ""

#: ../../c-api/init.rst:1148
msgid ""
"Issue a fatal error if there no current Python thread state or no current "
"interpreter. It cannot return NULL."
msgstr ""

#: ../../c-api/init.rst:1151 ../../c-api/init.rst:1161
msgid "The caller must hold the GIL."
msgstr "GIL"

#: ../../c-api/init.rst:1158
msgid ""
"Return the interpreter's unique ID.  If there was any error in doing so then "
"``-1`` is returned and an error is set."
msgstr ""
" ID \n"
" ``-1`` "

#: ../../c-api/init.rst:1168
msgid ""
"Return a dictionary in which interpreter-specific data may be stored. If "
"this function returns ``NULL`` then no exception has been raised and the "
"caller should assume no interpreter-specific dict is available."
msgstr ""
"\n"
" ``NULL`` "
""

#: ../../c-api/init.rst:1172
msgid ""
"This is not a replacement for :c:func:`PyModule_GetState()`, which "
"extensions should use to store interpreter-specific state information."
msgstr ""
" :c:func:`PyModule_GetState()` "
""

#: ../../c-api/init.rst:1179
msgid "Type of a frame evaluation function."
msgstr ""

#: ../../c-api/init.rst:1181
msgid ""
"The *throwflag* parameter is used by the ``throw()`` method of generators: "
"if non-zero, handle the current exception."
msgstr ""

#: ../../c-api/init.rst:1184
msgid "The function now takes a *tstate* parameter."
msgstr ""

#: ../../c-api/init.rst:1189
msgid "Get the frame evaluation function."
msgstr ""

#: ../../c-api/init.rst:1191 ../../c-api/init.rst:1199
msgid "See the :pep:`523` \"Adding a frame evaluation API to CPython\"."
msgstr ""

#: ../../c-api/init.rst:1197
msgid "Set the frame evaluation function."
msgstr ""

#: ../../c-api/init.rst:1206
msgid ""
"Return a dictionary in which extensions can store thread-specific state "
"information.  Each extension should use a unique key to use to store state "
"in the dictionary.  It is okay to call this function when no current thread "
"state is available. If this function returns ``NULL``, no exception has been "
"raised and the caller should assume no current thread state is available."
msgstr ""
""
""
""
" ``NULL`` "
""

#: ../../c-api/init.rst:1215
msgid ""
"Asynchronously raise an exception in a thread. The *id* argument is the "
"thread id of the target thread; *exc* is the exception object to be raised. "
"This function does not steal any references to *exc*. To prevent naive "
"misuse, you must write your own C extension to call this.  Must be called "
"with the GIL held. Returns the number of thread states modified; this is "
"normally one, but will be zero if the thread id isn't found.  If *exc* is :"
"const:`NULL`, the pending exception (if any) for the thread is cleared. This "
"raises no exceptions."
msgstr ""
" *id* "
" id ; *exc*  *exc* "
""
" C  GIL "
";  1 "
" 0  *exc*  :"
"const:`NULL`  () "
""

#: ../../c-api/init.rst:1223
msgid ""
"The type of the *id* parameter changed from :c:expr:`long` to :c:expr:"
"`unsigned long`."
msgstr ""
"*id*  :c:expr:`long`  :c:expr:`unsigned long` "
""

#: ../../c-api/init.rst:1229
msgid ""
"Acquire the global interpreter lock and set the current thread state to "
"*tstate*, which must not be ``NULL``.  The lock must have been created "
"earlier. If this thread already has the lock, deadlock ensues."
msgstr ""
"GIL  *tstate*  *tstate*  "
"``NULL`` "
""
""

#: ../../c-api/init.rst:1240 ../../c-api/init.rst:1278
msgid ""
"Updated to be consistent with :c:func:`PyEval_RestoreThread`, :c:func:"
"`Py_END_ALLOW_THREADS`, and :c:func:`PyGILState_Ensure`, and terminate the "
"current thread if called while the interpreter is finalizing."
msgstr ""

#: ../../c-api/init.rst:1245
msgid ""
":c:func:`PyEval_RestoreThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""
":c:func:`PyEval_RestoreThread`  ("
") "

#: ../../c-api/init.rst:1251
msgid ""
"Reset the current thread state to ``NULL`` and release the global "
"interpreter lock.  The lock must have been created earlier and must be held "
"by the current thread.  The *tstate* argument, which must not be ``NULL``, "
"is only used to check that it represents the current thread state --- if it "
"isn't, a fatal error is reported."
msgstr ""
" ``NULL`` GIL "
""
"*tstate*  ``NULL`` "
" --- "
""

#: ../../c-api/init.rst:1257
msgid ""
":c:func:`PyEval_SaveThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""
":c:func:`PyEval_SaveThread`  ("
") "

#: ../../c-api/init.rst:1263
msgid ""
"Acquire the global interpreter lock.  The lock must have been created "
"earlier. If this thread already has the lock, a deadlock ensues."
msgstr ""
"GIL"
""

#: ../../c-api/init.rst:1266
msgid ""
"This function does not update the current thread state.  Please use :c:func:"
"`PyEval_RestoreThread` or :c:func:`PyEval_AcquireThread` instead."
msgstr ""
" :c:func:"
"`PyEval_RestoreThread`  :c:func:`PyEval_AcquireThread` "
""

#: ../../c-api/init.rst:1286
msgid ""
"Release the global interpreter lock.  The lock must have been created "
"earlier."
msgstr "GIL"

#: ../../c-api/init.rst:1288
msgid ""
"This function does not update the current thread state.  Please use :c:func:"
"`PyEval_SaveThread` or :c:func:`PyEval_ReleaseThread` instead."
msgstr ""
" :c:func:"
"`PyEval_SaveThread`  :c:func:`PyEval_ReleaseThread` "
""

#: ../../c-api/init.rst:1297
msgid "Sub-interpreter support"
msgstr ""

#: ../../c-api/init.rst:1299
msgid ""
"While in most uses, you will only embed a single Python interpreter, there "
"are cases where you need to create several independent interpreters in the "
"same process and perhaps even in the same thread. Sub-interpreters allow you "
"to do that."
msgstr ""
" Python 1"
""
"\n"
""

#: ../../c-api/init.rst:1304
msgid ""
"The \"main\" interpreter is the first one created when the runtime "
"initializes. It is usually the only Python interpreter in a process.  Unlike "
"sub-interpreters, the main interpreter has unique process-global "
"responsibilities like signal handling.  It is also responsible for execution "
"during runtime initialization and is usually the active interpreter during "
"runtime finalization.  The :c:func:`PyInterpreterState_Main` function "
"returns a pointer to its state."
msgstr ""
"\"\" "
"\n"
""
"\n"
""
"\n"
":c:func:`PyInterpreterState_Main` "
""

#: ../../c-api/init.rst:1311
msgid ""
"You can switch between sub-interpreters using the :c:func:"
"`PyThreadState_Swap` function. You can create and destroy them using the "
"following functions:"
msgstr ""
" :c:func:`PyThreadState_Swap` \n"
":"

#: ../../c-api/init.rst:1325
msgid ""
"Create a new sub-interpreter.  This is an (almost) totally separate "
"environment for the execution of Python code.  In particular, the new "
"interpreter has separate, independent versions of all imported modules, "
"including the fundamental modules :mod:`builtins`, :mod:`__main__` and :mod:"
"`sys`.  The table of loaded modules (``sys.modules``) and the module search "
"path (``sys.path``) are also separate.  The new environment has no ``sys."
"argv`` variable.  It has new standard I/O stream file objects ``sys.stdin``, "
"``sys.stdout`` and ``sys.stderr`` (however these refer to the same "
"underlying file descriptors)."
msgstr ""
" (sub-interpreter) "
"()  Python "
" import "
" :mod:`builtins`, :mod:`__main__`  :mod:"
"`sys`  (``sys."
"modules``)   (``sys.path``) "
" ``sys.argv`` "
" I/O  ``sys.stdin``, ``sys."
"stdout``, ``sys.stderr``  ("
")"

#: ../../c-api/init.rst:1335
msgid ""
"The return value points to the first thread state created in the new sub-"
"interpreter.  This thread state is made in the current thread state. Note "
"that no actual thread is created; see the discussion of thread states "
"below.  If creation of the new interpreter is unsuccessful, ``NULL`` is "
"returned; no exception is set since the exception state is stored in the "
"current thread state and there may not be a current thread state.  (Like all "
"other Python/C API functions, the global interpreter lock must be held "
"before calling this function and is still held when it returns; however, "
"unlike most other Python/C API functions, there needn't be a current thread "
"state on entry.)"
msgstr ""
" (thread state) "
""
" (current thread state) "
"; "
"``NULL`` ; "
""
"( Python/C API "
"GIL"
";  Python/C API "
""
")"

#: ../../c-api/init.rst:1350
msgid "Extension modules are shared between (sub-)interpreters as follows:"
msgstr ""

#: ../../c-api/init.rst:1352
msgid ""
"For modules using multi-phase initialization, e.g. :c:func:"
"`PyModule_FromDefAndSpec`, a separate module object is created and "
"initialized for each interpreter. Only C-level static and global variables "
"are shared between these module objects."
msgstr ""

#: ../../c-api/init.rst:1358
msgid ""
"For modules using single-phase initialization, e.g. :c:func:"
"`PyModule_Create`, the first time a particular extension is imported, it is "
"initialized normally, and a (shallow) copy of its module's dictionary is "
"squirreled away. When the same extension is imported by another "
"(sub-)interpreter, a new module is initialized and filled with the contents "
"of this copy; the extension's ``init`` function is not called. Objects in "
"the module's dictionary thus end up shared across (sub-)interpreters, which "
"might cause unwanted behavior (see `Bugs and caveats`_ below)."
msgstr ""

#: ../../c-api/init.rst:1369
msgid ""
"Note that this is different from what happens when an extension is imported "
"after the interpreter has been completely re-initialized by calling :c:func:"
"`Py_FinalizeEx` and :c:func:`Py_Initialize`; in that case, the extension's "
"``initmodule`` function *is* called again. As with multi-phase "
"initialization, this means that only C-level static and global variables are "
"shared between these modules."
msgstr ""

#: ../../c-api/init.rst:1383
msgid ""
"Destroy the (sub-)interpreter represented by the given thread state. The "
"given thread state must be the current thread state.  See the discussion of "
"thread states below.  When the call returns, the current thread state is "
"``NULL``.  All thread states associated with this interpreter are "
"destroyed.  (The global interpreter lock must be held before calling this "
"function and is still held when it returns.)  :c:func:`Py_FinalizeEx` will "
"destroy all sub-interpreters that haven't been explicitly destroyed at that "
"point."
msgstr ""
" *tstate*  () "
" *tstate* "
" "
"``NULL`` "
" (GIL"
") :c:func:`Py_FinalizeEx` "
""

#: ../../c-api/init.rst:1393
msgid "Bugs and caveats"
msgstr ""

#: ../../c-api/init.rst:1395
msgid ""
"Because sub-interpreters (and the main interpreter) are part of the same "
"process, the insulation between them isn't perfect --- for example, using "
"low-level file operations like  :func:`os.close` they can (accidentally or "
"maliciously) affect each other's open files.  Because of the way extensions "
"are shared between (sub-)interpreters, some extensions may not work "
"properly; this is especially likely when using single-phase initialization "
"or (static) global variables. It is possible to insert objects created in "
"one sub-interpreter into a namespace of another (sub-)interpreter; this "
"should be avoided if possible."
msgstr ""

#: ../../c-api/init.rst:1405
msgid ""
"Special care should be taken to avoid sharing user-defined functions, "
"methods, instances or classes between sub-interpreters, since import "
"operations executed by such objects may affect the wrong (sub-)interpreter's "
"dictionary of loaded modules. It is equally important to avoid sharing "
"objects from which the above are reachable."
msgstr ""

#: ../../c-api/init.rst:1411
msgid ""
"Also note that combining this functionality with ``PyGILState_*`` APIs is "
"delicate, because these APIs assume a bijection between Python thread states "
"and OS-level threads, an assumption broken by the presence of sub-"
"interpreters. It is highly recommended that you don't switch sub-"
"interpreters between a pair of matching :c:func:`PyGILState_Ensure` and :c:"
"func:`PyGILState_Release` calls. Furthermore, extensions (such as :mod:"
"`ctypes`) using these APIs to allow calling of Python code from non-Python "
"created threads will probably be broken when using sub-interpreters."
msgstr ""
" ``PyGILState_*`` API "
"APIPythonOS11"
""
" :c:func:`PyGILState_Ensure`  :c:func:`PyGILState_Release` "
""
"(:mod:`ctypes` )APIPython"
" Python"
""

#: ../../c-api/init.rst:1422
msgid "Asynchronous Notifications"
msgstr ""

#: ../../c-api/init.rst:1424
msgid ""
"A mechanism is provided to make asynchronous notifications to the main "
"interpreter thread.  These notifications take the form of a function pointer "
"and a void pointer argument."
msgstr ""
""
" void "

#: ../../c-api/init.rst:1433
msgid ""
"Schedule a function to be called from the main interpreter thread.  On "
"success, ``0`` is returned and *func* is queued for being called in the main "
"thread.  On failure, ``-1`` is returned without setting any exception."
msgstr ""
" "
"``0`` *func* "
" ``-1`` "

#: ../../c-api/init.rst:1437
msgid ""
"When successfully queued, *func* will be *eventually* called from the main "
"interpreter thread with the argument *arg*.  It will be called "
"asynchronously with respect to normally running Python code, but with both "
"these conditions met:"
msgstr ""
"*func*  ** "
"*arg*  "
"Python "
":"

#: ../../c-api/init.rst:1442
msgid "on a :term:`bytecode` boundary;"
msgstr ":term:`bytecode` "

#: ../../c-api/init.rst:1443
msgid ""
"with the main thread holding the :term:`global interpreter lock` (*func* can "
"therefore use the full C API)."
msgstr ""
" :term:`global interpreter lock`  ( "
"*func*  C API ) "

#: ../../c-api/init.rst:1446
msgid ""
"*func* must return ``0`` on success, or ``-1`` on failure with an exception "
"set.  *func* won't be interrupted to perform another asynchronous "
"notification recursively, but it can still be interrupted to switch threads "
"if the global interpreter lock is released."
msgstr ""
" *func*  ``0``  ``-1`` "
"*func* "
""
""

#: ../../c-api/init.rst:1451
msgid ""
"This function doesn't need a current thread state to run, and it doesn't "
"need the global interpreter lock."
msgstr ""
""
""

#: ../../c-api/init.rst:1454
msgid ""
"To call this function in a subinterpreter, the caller must hold the GIL. "
"Otherwise, the function *func* can be scheduled to be called from the wrong "
"interpreter."
msgstr ""

#: ../../c-api/init.rst:1459
msgid ""
"This is a low-level function, only useful for very special cases. There is "
"no guarantee that *func* will be called as quick as possible.  If the main "
"thread is busy executing a system call, *func* won't be called before the "
"system call returns.  This function is generally **not** suitable for "
"calling Python code from arbitrary C threads.  Instead, use the :ref:"
"`PyGILState API`."
msgstr ""
" *func* "
""
" *func* "
" C  Python "
" ****  :ref:`PyGILState API` "
""

#: ../../c-api/init.rst:1466
msgid ""
"If this function is called in a subinterpreter, the function *func* is now "
"scheduled to be called from the subinterpreter, rather than being called "
"from the main interpreter. Each subinterpreter now has its own list of "
"scheduled calls."
msgstr ""

#: ../../c-api/init.rst:1477
msgid "Profiling and Tracing"
msgstr " (profiling and tracing)"

#: ../../c-api/init.rst:1482
msgid ""
"The Python interpreter provides some low-level support for attaching "
"profiling and execution tracing facilities.  These are used for profiling, "
"debugging, and coverage analysis tools."
msgstr ""
"Python :  (profile) :  "
"(trace) "
" (coverage analysis) "
""

#: ../../c-api/init.rst:1486
msgid ""
"This C interface allows the profiling or tracing code to avoid the overhead "
"of calling through Python-level callable objects, making a direct C function "
"call instead.  The essential attributes of the facility have not changed; "
"the interface allows trace functions to be installed per-thread, and the "
"basic events reported to the trace function are the same as had been "
"reported to the Python-level trace functions in previous versions."
msgstr ""
" C Python "
" C "
""
"; "
" (basic event) "
" Python "

#: ../../c-api/init.rst:1496
msgid ""
"The type of the trace function registered using :c:func:`PyEval_SetProfile` "
"and :c:func:`PyEval_SetTrace`. The first parameter is the object passed to "
"the registration function as *obj*, *frame* is the frame object to which the "
"event pertains, *what* is one of the constants :const:`PyTrace_CALL`, :const:"
"`PyTrace_EXCEPTION`, :const:`PyTrace_LINE`, :const:`PyTrace_RETURN`, :const:"
"`PyTrace_C_CALL`, :const:`PyTrace_C_EXCEPTION`, :const:`PyTrace_C_RETURN`, "
"or :const:`PyTrace_OPCODE`, and *arg* depends on the value of *what*:"
msgstr ""
":c:func:`PyEval_SetProfile`  :c:func:`PyEval_SetTrace` "
" *obj* "
" *frame*  "
"*what*  :const:`PyTrace_CALL`, :const:`PyTrace_EXCEPTION`, :const:"
"`PyTrace_LINE`, :const:`PyTrace_RETURN`, :const:`PyTrace_C_CALL`, :const:"
"`PyTrace_C_EXCEPTION`, :const:`PyTrace_C_RETURN`, :const:`PyTrace_OPCODE` "
" *arg*  *what* :"

#: ../../c-api/init.rst:1505
msgid "Value of *what*"
msgstr "*what* "

#: ../../c-api/init.rst:1505
msgid "Meaning of *arg*"
msgstr "*arg* "

#: ../../c-api/init.rst:1507
msgid ":const:`PyTrace_CALL`"
msgstr ":const:`PyTrace_CALL`"

#: ../../c-api/init.rst:1507 ../../c-api/init.rst:1512
#: ../../c-api/init.rst:1523
msgid "Always :c:data:`Py_None`."
msgstr " :c:data:`Py_None` "

#: ../../c-api/init.rst:1509
msgid ":const:`PyTrace_EXCEPTION`"
msgstr ":const:`PyTrace_EXCEPTION`"

#: ../../c-api/init.rst:1509
msgid "Exception information as returned by :func:`sys.exc_info`."
msgstr ":func:`sys.exc_info` "

#: ../../c-api/init.rst:1512
msgid ":const:`PyTrace_LINE`"
msgstr ":const:`PyTrace_LINE`"

#: ../../c-api/init.rst:1514
msgid ":const:`PyTrace_RETURN`"
msgstr ":const:`PyTrace_RETURN`"

#: ../../c-api/init.rst:1514
msgid ""
"Value being returned to the caller, or ``NULL`` if caused by an exception."
msgstr ""
" ``NULL`` "
""

#: ../../c-api/init.rst:1517
msgid ":const:`PyTrace_C_CALL`"
msgstr ":const:`PyTrace_C_CALL`"

#: ../../c-api/init.rst:1517 ../../c-api/init.rst:1519
#: ../../c-api/init.rst:1521
msgid "Function object being called."
msgstr ""

#: ../../c-api/init.rst:1519
msgid ":const:`PyTrace_C_EXCEPTION`"
msgstr ":const:`PyTrace_C_EXCEPTION`"

#: ../../c-api/init.rst:1521
msgid ":const:`PyTrace_C_RETURN`"
msgstr ":const:`PyTrace_C_RETURN`"

#: ../../c-api/init.rst:1523
msgid ":const:`PyTrace_OPCODE`"
msgstr ":const:`PyTrace_OPCODE`"

#: ../../c-api/init.rst:1528
msgid ""
"The value of the *what* parameter to a :c:type:`Py_tracefunc` function when "
"a new call to a function or method is being reported, or a new entry into a "
"generator. Note that the creation of the iterator for a generator function "
"is not reported as there is no control transfer to the Python bytecode in "
"the corresponding frame."
msgstr ""
""
" :c:type:`Py_tracefunc`  *what* "
" Python "
" (control transfer) "
""

#: ../../c-api/init.rst:1537
msgid ""
"The value of the *what* parameter to a :c:type:`Py_tracefunc` function when "
"an exception has been raised.  The callback function is called with this "
"value for *what* when after any bytecode is processed after which the "
"exception becomes set within the frame being executed.  The effect of this "
"is that as exception propagation causes the Python stack to unwind, the "
"callback is called upon return to each frame as the exception propagates.  "
"Only trace functions receives these events; they are not needed by the "
"profiler."
msgstr ""
" :c:type:`Py_tracefunc`  *what* "
" "
"*what* "
" Python "
""
"; "

#: ../../c-api/init.rst:1548
msgid ""
"The value passed as the *what* parameter to a :c:type:`Py_tracefunc` "
"function (but not a profiling function) when a line-number event is being "
"reported. It may be disabled for a frame by setting :attr:`f_trace_lines` to "
"*0* on that frame."
msgstr ""
" () :c:type:"
"`Py_tracefunc`  *what* \n"
":attr:`f_trace_lines`  *0* "
""

#: ../../c-api/init.rst:1555
msgid ""
"The value for the *what* parameter to :c:type:`Py_tracefunc` functions when "
"a call is about to return."
msgstr ""
" :c:type:`Py_tracefunc`  *what* "
""

#: ../../c-api/init.rst:1561
msgid ""
"The value for the *what* parameter to :c:type:`Py_tracefunc` functions when "
"a C function is about to be called."
msgstr ""
"C :c:type:`Py_tracefunc`  *what* "
""

#: ../../c-api/init.rst:1567
msgid ""
"The value for the *what* parameter to :c:type:`Py_tracefunc` functions when "
"a C function has raised an exception."
msgstr ""
"C :c:type:`Py_tracefunc`  *what* "
""

#: ../../c-api/init.rst:1573
msgid ""
"The value for the *what* parameter to :c:type:`Py_tracefunc` functions when "
"a C function has returned."
msgstr ""
"C :c:type:`Py_tracefunc`  *what* "
""

#: ../../c-api/init.rst:1579
msgid ""
"The value for the *what* parameter to :c:type:`Py_tracefunc` functions (but "
"not profiling functions) when a new opcode is about to be executed.  This "
"event is not emitted by default: it must be explicitly requested by setting :"
"attr:`f_trace_opcodes` to *1* on the frame."
msgstr ""
" opcode  () :c:type:"
"`Py_tracefunc`  *what* \n"
" :attr:`f_trace_lines`  "
"*1* "

#: ../../c-api/init.rst:1587
msgid ""
"Set the profiler function to *func*.  The *obj* parameter is passed to the "
"function as its first parameter, and may be any Python object, or ``NULL``.  "
"If the profile function needs to maintain state, using a different value for "
"*obj* for each thread provides a convenient and thread-safe place to store "
"it.  The profile function is called for all monitored events except :const:"
"`PyTrace_LINE` :const:`PyTrace_OPCODE` and :const:`PyTrace_EXCEPTION`."
msgstr ""
" *func* \n"
"*obj*  Python "
" ``NULL`` \n"
""
" *obj* "
"\n"
" :const:`PyTrace_LINE` :"
"const:`PyTrace_OPCODE`, :const:`PyTrace_EXCEPTION` "
""

#: ../../c-api/init.rst:1594 ../../c-api/init.rst:1606
msgid "The caller must hold the :term:`GIL`."
msgstr " :term:`GIL` "

#: ../../c-api/init.rst:1599
msgid ""
"Set the tracing function to *func*.  This is similar to :c:func:"
"`PyEval_SetProfile`, except the tracing function does receive line-number "
"events and per-opcode events, but does not receive any event related to C "
"function objects being called.  Any trace function registered using :c:func:"
"`PyEval_SetTrace` will not receive :const:`PyTrace_C_CALL`, :const:"
"`PyTrace_C_EXCEPTION` or :const:`PyTrace_C_RETURN` as a value for the *what* "
"parameter."
msgstr ""
" *func* \n"
" :c:func:`PyEval_SetProfile` "
" opcode  C "
"\n"
":c:func:`PyEval_SetTrace` *what*  :"
"const:`PyTrace_C_CALL`, :const:`PyTrace_C_EXCEPTION`, :const:"
"`PyTrace_C_RETURN` "

#: ../../c-api/init.rst:1612
msgid "Advanced Debugger Support"
msgstr " (advanced debugger support)"

#: ../../c-api/init.rst:1617
msgid ""
"These functions are only intended to be used by advanced debugging tools."
msgstr ""

#: ../../c-api/init.rst:1622
msgid ""
"Return the interpreter state object at the head of the list of all such "
"objects."
msgstr ""
""

#: ../../c-api/init.rst:1627
msgid "Return the main interpreter state object."
msgstr ""

#: ../../c-api/init.rst:1632
msgid ""
"Return the next interpreter state object after *interp* from the list of all "
"such objects."
msgstr ""
"*interp* "
""

#: ../../c-api/init.rst:1638
msgid ""
"Return the pointer to the first :c:type:`PyThreadState` object in the list "
"of threads associated with the interpreter *interp*."
msgstr ""
" *interp* "
" :c:type:`PyThreadState` "

#: ../../c-api/init.rst:1644
msgid ""
"Return the next thread state object after *tstate* from the list of all such "
"objects belonging to the same :c:type:`PyInterpreterState` object."
msgstr ""
"*tstate*  :c:type:`PyInterpreterState` "
" *tstate* "

#: ../../c-api/init.rst:1651
msgid "Thread Local Storage Support"
msgstr ""

#: ../../c-api/init.rst:1655
msgid ""
"The Python interpreter provides low-level support for thread-local storage "
"(TLS) which wraps the underlying native TLS implementation to support the "
"Python-level thread local storage API (:class:`threading.local`).  The "
"CPython C level APIs are similar to those offered by pthreads and Windows: "
"use a thread key and functions to associate a :c:expr:`void*` value per "
"thread."
msgstr ""
"Python  (thread-local storage, "
"TLS)  TLS "
" Python  API (:class:`threading.local`) "
"\n"
"CPython  C  API  pthreads  Windows  TLS : "
" :c:expr:`void*` "

#: ../../c-api/init.rst:1662
msgid ""
"The GIL does *not* need to be held when calling these functions; they supply "
"their own locking."
msgstr ""
"API  GIL  ** "
""

#: ../../c-api/init.rst:1665
msgid ""
"Note that :file:`Python.h` does not include the declaration of the TLS APIs, "
"you need to include :file:`pythread.h` to use thread-local storage."
msgstr ""
":file:`Python.h`  TLS API  include "
" :file:`pythread.h`  include "
""

#: ../../c-api/init.rst:1669
msgid ""
"None of these API functions handle memory management on behalf of the :c:"
"expr:`void*` values.  You need to allocate and deallocate them yourself. If "
"the :c:expr:`void*` values happen to be :c:expr:`PyObject*`, these functions "
"don't do refcount operations on them either."
msgstr ""
" API  :c:expr:`void*` "
"\n"
"\n"
":c:expr:`void*`  :c:expr:`PyObject*`  API "
""

#: ../../c-api/init.rst:1677
msgid "Thread Specific Storage (TSS) API"
msgstr " (Thread Specific Storage, TSS) API"

#: ../../c-api/init.rst:1679
msgid ""
"TSS API is introduced to supersede the use of the existing TLS API within "
"the CPython interpreter.  This API uses a new type :c:type:`Py_tss_t` "
"instead of :c:expr:`int` to represent thread keys."
msgstr ""
"TSS API  CPython  TLS API "
"\n"
" API  :c:expr:`int`  :c:type:"
"`Py_tss_t` "

#: ../../c-api/init.rst:1685
msgid "\"A New C-API for Thread-Local Storage in CPython\" (:pep:`539`)"
msgstr ""
"\"CPython  C API\" (:pep:`539`)"

#: ../../c-api/init.rst:1690
msgid ""
"This data structure represents the state of a thread key, the definition of "
"which may depend on the underlying TLS implementation, and it has an "
"internal field representing the key's initialization state.  There are no "
"public members in this structure."
msgstr ""
""
" TLS \n"
" (public) "

#: ../../c-api/init.rst:1695
msgid ""
"When :ref:`Py_LIMITED_API ` is not defined, static allocation of "
"this type by :c:macro:`Py_tss_NEEDS_INIT` is allowed."
msgstr ""
":ref:`Py_LIMITED_API `  :c:macro:"
"`Py_tss_NEEDS_INIT` "

#: ../../c-api/init.rst:1701
msgid ""
"This macro expands to the initializer for :c:type:`Py_tss_t` variables. Note "
"that this macro won't be defined with :ref:`Py_LIMITED_API `."
msgstr ""
" :c:type:`Py_tss_t` \n"
" :ref:`Py_LIMITED_API ` "

#: ../../c-api/init.rst:1706
msgid "Dynamic Allocation"
msgstr ""

#: ../../c-api/init.rst:1708
msgid ""
"Dynamic allocation of the :c:type:`Py_tss_t`, required in extension modules "
"built with :ref:`Py_LIMITED_API `, where static allocation of this "
"type is not possible due to its implementation being opaque at build time."
msgstr ""
" :c:type:`Py_tss_t`  :ref:`Py_LIMITED_API ` "
""
""

#: ../../c-api/init.rst:1715
msgid ""
"Return a value which is the same state as a value initialized with :c:macro:"
"`Py_tss_NEEDS_INIT`, or ``NULL`` in the case of dynamic allocation failure."
msgstr ""

#: ../../c-api/init.rst:1722
msgid ""
"Free the given *key* allocated by :c:func:`PyThread_tss_alloc`, after first "
"calling :c:func:`PyThread_tss_delete` to ensure any associated thread locals "
"have been unassigned. This is a no-op if the *key* argument is ``NULL``."
msgstr ""

#: ../../c-api/init.rst:1728
msgid ""
"A freed key becomes a dangling pointer. You should reset the key to `NULL`."
msgstr ""

#: ../../c-api/init.rst:1733
msgid "Methods"
msgstr ""

#: ../../c-api/init.rst:1735
msgid ""
"The parameter *key* of these functions must not be ``NULL``.  Moreover, the "
"behaviors of :c:func:`PyThread_tss_set` and :c:func:`PyThread_tss_get` are "
"undefined if the given :c:type:`Py_tss_t` has not been initialized by :c:"
"func:`PyThread_tss_create`."
msgstr ""

#: ../../c-api/init.rst:1743
msgid ""
"Return a non-zero value if the given :c:type:`Py_tss_t` has been initialized "
"by :c:func:`PyThread_tss_create`."
msgstr ""

#: ../../c-api/init.rst:1749
msgid ""
"Return a zero value on successful initialization of a TSS key.  The behavior "
"is undefined if the value pointed to by the *key* argument is not "
"initialized by :c:macro:`Py_tss_NEEDS_INIT`.  This function can be called "
"repeatedly on the same key -- calling it on an already initialized key is a "
"no-op and immediately returns success."
msgstr ""

#: ../../c-api/init.rst:1758
msgid ""
"Destroy a TSS key to forget the values associated with the key across all "
"threads, and change the key's initialization state to uninitialized.  A "
"destroyed key is able to be initialized again by :c:func:"
"`PyThread_tss_create`. This function can be called repeatedly on the same "
"key -- calling it on an already destroyed key is a no-op."
msgstr ""

#: ../../c-api/init.rst:1767
msgid ""
"Return a zero value to indicate successfully associating a :c:expr:`void*` "
"value with a TSS key in the current thread.  Each thread has a distinct "
"mapping of the key to a :c:expr:`void*` value."
msgstr ""

#: ../../c-api/init.rst:1774
msgid ""
"Return the :c:expr:`void*` value associated with a TSS key in the current "
"thread.  This returns ``NULL`` if no value is associated with the key in the "
"current thread."
msgstr ""

#: ../../c-api/init.rst:1782
msgid "Thread Local Storage (TLS) API"
msgstr " (TLS) API"

#: ../../c-api/init.rst:1784
msgid ""
"This API is superseded by :ref:`Thread Specific Storage (TSS) API `."
msgstr ""

#: ../../c-api/init.rst:1789
msgid ""
"This version of the API does not support platforms where the native TLS key "
"is defined in a way that cannot be safely cast to ``int``.  On such "
"platforms, :c:func:`PyThread_create_key` will return immediately with a "
"failure status, and the other TLS functions will all be no-ops on such "
"platforms."
msgstr ""

#: ../../c-api/init.rst:1794
msgid ""
"Due to the compatibility problem noted above, this version of the API should "
"not be used in new code."
msgstr ""
"API"
""