# German translations for Python package.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# Automatically generated, 2026.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.15\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-09-28 03:11+0000\n"

"PO-Revision-Date: 2026-09-23 06:17+0000\n"

"Last-Translator: Automatically generated\n"

"Language-Team: none\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../c-api/subinterpreters.rst:6

msgid "Multiple interpreters in a Python process"

msgstr ""

#: ../../c-api/subinterpreters.rst:8

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 ""

#: ../../c-api/subinterpreters.rst:13

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 ""

#: ../../c-api/subinterpreters.rst:20

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-api/subinterpreters.rst:26

msgid ""

"Structure containing most parameters to configure a sub-interpreter. Its "

"values are used only in :c:func:`Py_NewInterpreterFromConfig` and never "

"modified by the runtime."

msgstr ""

#: ../../c-api/subinterpreters.rst:32

msgid "Structure fields:"

msgstr ""

#: ../../c-api/subinterpreters.rst:36

msgid ""

"If this is ``0`` then the sub-interpreter will use its own \"object\" "

"allocator state. Otherwise it will use (share) the main interpreter's."

msgstr ""

#: ../../c-api/subinterpreters.rst:40

msgid ""

"If this is ``0`` then :c:member:`~PyInterpreterConfig."

"check_multi_interp_extensions` must be ``1`` (non-zero). If this is ``1`` "

"then :c:member:`~PyInterpreterConfig.gil` must not be :c:macro:"

"`PyInterpreterConfig_OWN_GIL`."

msgstr ""

#: ../../c-api/subinterpreters.rst:48

msgid ""

"If this is ``0`` then the runtime will not support forking the process in "

"any thread where the sub-interpreter is currently active. Otherwise fork is "

"unrestricted."

msgstr ""

#: ../../c-api/subinterpreters.rst:52

msgid ""

"Note that the :mod:`subprocess` module still works when fork is disallowed."

msgstr ""

#: ../../c-api/subinterpreters.rst:57

msgid ""

"If this is ``0`` then the runtime will not support replacing the current "

"process via exec (e.g. :func:`os.execv`) in any thread where the sub-"

"interpreter is currently active. Otherwise exec is unrestricted."

msgstr ""

#: ../../c-api/subinterpreters.rst:62

msgid ""

"Note that the :mod:`subprocess` module still works when exec is disallowed."

msgstr ""

#: ../../c-api/subinterpreters.rst:67

msgid ""

"If this is ``0`` then the sub-interpreter's :mod:`threading` module won't "

"create threads. Otherwise threads are allowed."

msgstr ""

#: ../../c-api/subinterpreters.rst:73

msgid ""

"If this is ``0`` then the sub-interpreter's :mod:`threading` module won't "

"create daemon threads. Otherwise daemon threads are allowed (as long as :c:"

"member:`~PyInterpreterConfig.allow_threads` is non-zero)."

msgstr ""

#: ../../c-api/subinterpreters.rst:80

msgid ""

"If this is ``0`` then all extension modules may be imported, including "

"legacy (single-phase init) modules, in any thread where the sub-interpreter "

"is currently active. Otherwise only multi-phase init extension modules (see :"

"pep:`489`) may be imported. (Also see :c:macro:"

"`Py_mod_multiple_interpreters`.)"

msgstr ""

#: ../../c-api/subinterpreters.rst:87

msgid ""

"This must be ``1`` (non-zero) if :c:member:`~PyInterpreterConfig."

"use_main_obmalloc` is ``0``."

msgstr ""

#: ../../c-api/subinterpreters.rst:92

msgid ""

"This determines the operation of the GIL for the sub-interpreter. It may be "

"one of the following:"

msgstr ""

#: ../../c-api/subinterpreters.rst:99

msgid "Use the default selection (:c:macro:`PyInterpreterConfig_SHARED_GIL`)."

msgstr ""

#: ../../c-api/subinterpreters.rst:103

msgid "Use (share) the main interpreter's GIL."

msgstr ""

#: ../../c-api/subinterpreters.rst:107

msgid "Use the sub-interpreter's own GIL."

msgstr ""

#: ../../c-api/subinterpreters.rst:109

msgid ""

"If this is :c:macro:`PyInterpreterConfig_OWN_GIL` then :c:member:"

"`PyInterpreterConfig.use_main_obmalloc` must be ``0``."

msgstr ""

#: ../../c-api/subinterpreters.rst:123

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 ""

#: ../../c-api/subinterpreters.rst:133

msgid ""

"The given *config* controls the options with which the interpreter is "

"initialized."

msgstr ""

#: ../../c-api/subinterpreters.rst:136

msgid ""

"Upon success, *tstate_p* will be set to the first :term:`thread state` "

"created in the new sub-interpreter. This thread state is :term:`attached "

"<attached thread state>`. Note that no actual thread is created; see the "

"discussion of thread states below. If creation of the new interpreter is "

"unsuccessful, *tstate_p* is set to ``NULL``; no exception is set since the "

"exception state is stored in the :term:`attached thread state`, which might "

"not exist."

msgstr ""

#: ../../c-api/subinterpreters.rst:145

msgid ""

"Like all other Python/C API functions, an :term:`attached thread state` must "

"be present before calling this function, but it might be detached upon "

"returning. On success, the returned thread state will be :term:`attached "

"<attached thread state>`. If the sub-interpreter is created with its own :"

"term:`GIL` then the :term:`attached thread state` of the calling interpreter "

"will be detached. When the function returns, the new interpreter's :term:"

"`thread state` will be :term:`attached <attached thread state>` to the "

"current thread and the previous interpreter's :term:`attached thread state` "

"will remain detached."

msgstr ""

#: ../../c-api/subinterpreters.rst:156

msgid ""

"Sub-interpreters are most effective when isolated from each other, with "

"certain functionality restricted::"

msgstr ""

#: ../../c-api/subinterpreters.rst:159

msgid ""

"PyInterpreterConfig config = {\n"

" .use_main_obmalloc = 0,\n"

" .allow_fork = 0,\n"

" .allow_exec = 0,\n"

" .allow_threads = 1,\n"

" .allow_daemon_threads = 0,\n"

" .check_multi_interp_extensions = 1,\n"

" .gil = PyInterpreterConfig_OWN_GIL,\n"

"};\n"

"PyThreadState *tstate = NULL;\n"

"PyStatus status = Py_NewInterpreterFromConfig(&tstate, &config);\n"

"if (PyStatus_Exception(status)) {\n"

" Py_ExitStatusException(status);\n"

"}"

msgstr ""

#: ../../c-api/subinterpreters.rst:174

msgid ""

"Note that the config is used only briefly and does not get modified. During "

"initialization the config's values are converted into various :c:type:"

"`PyInterpreterState` values. A read-only copy of the config may be stored "

"internally on the :c:type:`PyInterpreterState`."

msgstr ""

#: ../../c-api/subinterpreters.rst:183

msgid "Extension modules are shared between (sub-)interpreters as follows:"

msgstr ""

#: ../../c-api/subinterpreters.rst:185

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/subinterpreters.rst:191

msgid ""

"For modules using legacy :ref:`single-phase initialization <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/subinterpreters.rst:203

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/subinterpreters.rst:223

msgid ""

"Create a new sub-interpreter. This is essentially just a wrapper around :c:"

"func:`Py_NewInterpreterFromConfig` with a config that preserves the existing "

"behavior. The result is an unisolated sub-interpreter that shares the main "

"interpreter's GIL, allows fork/exec, allows daemon threads, and allows "

"single-phase init modules."

msgstr ""

#: ../../c-api/subinterpreters.rst:235

msgid ""

"Destroy the (sub-)interpreter represented by the given :term:`thread state`. "

"The given thread state must be :term:`attached <attached thread state>`. "

"When the call returns, there will be no :term:`attached thread state`. All "

"thread states associated with this interpreter are destroyed."

msgstr ""

#: ../../c-api/subinterpreters.rst:240

msgid ""

":c:func:`Py_FinalizeEx` will destroy all sub-interpreters that haven't been "

"explicitly destroyed at that point."

msgstr ""

#: ../../c-api/subinterpreters.rst:247

msgid "A per-interpreter GIL"

msgstr ""

#: ../../c-api/subinterpreters.rst:251

msgid ""

"Using :c:func:`Py_NewInterpreterFromConfig` you can create a sub-interpreter "

"that is completely isolated from other interpreters, including having its "

"own GIL. The most important benefit of this isolation is that such an "

"interpreter can execute Python code without being blocked by other "

"interpreters or blocking any others. Thus a single Python process can truly "

"take advantage of multiple CPU cores when running Python code. The "

"isolation also encourages a different approach to concurrency than that of "

"just using threads. (See :pep:`554` and :pep:`684`.)"

msgstr ""

#: ../../c-api/subinterpreters.rst:261

msgid ""

"Using an isolated interpreter requires vigilance in preserving that "

"isolation. That especially means not sharing any objects or mutable state "

"without guarantees about thread-safety. Even objects that are otherwise "

"immutable (e.g. ``None``, ``(1, 5)``) can't normally be shared because of "

"the refcount. One simple but less-efficient approach around this is to use "

"a global lock around all use of some state (or object). Alternately, "

"effectively immutable objects (like integers or strings) can be made safe in "

"spite of their refcounts by making them :term:`immortal`. In fact, this has "

"been done for the builtin singletons, small integers, and a number of other "

"builtin objects."

msgstr ""

#: ../../c-api/subinterpreters.rst:272

msgid ""

"If you preserve isolation then you will have access to proper multi-core "

"computing without the complications that come with free-threading. Failure "

"to preserve isolation will expose you to the full consequences of free-"

"threading, including races and hard-to-debug crashes."

msgstr ""

#: ../../c-api/subinterpreters.rst:277

msgid ""

"Aside from that, one of the main challenges of using multiple isolated "

"interpreters is how to communicate between them safely (not break isolation) "

"and efficiently. The runtime and stdlib do not provide any standard "

"approach to this yet. A future stdlib module would help mitigate the effort "

"of preserving isolation and expose effective tools for communicating (and "

"sharing) data between interpreters."

msgstr ""

#: ../../c-api/subinterpreters.rst:286

msgid "Bugs and caveats"

msgstr ""

#: ../../c-api/subinterpreters.rst:288

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/subinterpreters.rst:298

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/subinterpreters.rst:304

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 ""

#: ../../c-api/subinterpreters.rst:315

msgid "High-level APIs"

msgstr ""

#: ../../c-api/subinterpreters.rst:319

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 ""

#: ../../c-api/subinterpreters.rst:324

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 ""

#: ../../c-api/subinterpreters.rst:331

msgid ""

":pep:`684` introduced the possibility of a :ref:`per-interpreter GIL <per-"

"interpreter-gil>`. See :c:func:`Py_NewInterpreterFromConfig`."

msgstr ""

#: ../../c-api/subinterpreters.rst:338

msgid "Get the current interpreter."

msgstr ""

#: ../../c-api/subinterpreters.rst:340

msgid ""

"Issue a fatal error if there is no :term:`attached thread state`. It cannot "

"return NULL."

msgstr ""

#: ../../c-api/subinterpreters.rst:348

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 ""

#: ../../c-api/subinterpreters.rst:351

msgid "The caller must have an :term:`attached thread state`."

msgstr ""

#: ../../c-api/subinterpreters.rst:358

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 ""

#: ../../c-api/subinterpreters.rst:362

msgid ""

"This is not a replacement for :c:func:`PyModule_GetState()`, which "

"extensions should use to store interpreter-specific state information."

msgstr ""

#: ../../c-api/subinterpreters.rst:365

msgid ""

"The returned dictionary is borrowed from the interpreter and is valid until "

"interpreter shutdown."

msgstr ""

#: ../../c-api/subinterpreters.rst:373

msgid "Type of a frame evaluation function."

msgstr ""

#: ../../c-api/subinterpreters.rst:375

msgid ""

"The *throwflag* parameter is used by the ``throw()`` method of generators: "

"if non-zero, handle the current exception."

msgstr ""

#: ../../c-api/subinterpreters.rst:378

msgid "The function now takes a *tstate* parameter."

msgstr ""

#: ../../c-api/subinterpreters.rst:381

msgid ""

"The *frame* parameter changed from ``PyFrameObject*`` to "

"``_PyInterpreterFrame*``."

msgstr ""

#: ../../c-api/subinterpreters.rst:387

msgid "Get the frame evaluation function."

msgstr ""

#: ../../c-api/subinterpreters.rst:389 ../../c-api/subinterpreters.rst:398

msgid "See the :pep:`523` \"Adding a frame evaluation API to CPython\"."

msgstr ""

#: ../../c-api/subinterpreters.rst:396

msgid "Set the frame evaluation function."

msgstr ""

#: ../../c-api/subinterpreters.rst:404

msgid ""

"Enables or disables specialization why a custom frame evaluator is in place."

msgstr ""

#: ../../c-api/subinterpreters.rst:406

msgid ""

"If *allow_specialization* is non-zero, the adaptive specializer will "

"continue to specialize bytecodes even though a custom eval frame function is "

"set. When *allow_specialization* is zero, setting a custom eval frame "

"disables specialization. The standard interpreter loop will continue to "

"deopt while a frame evaluation API is in place - the frame evaluation "

"function needs to handle the specialized opcodes to take advantage of this."

msgstr ""

#: ../../c-api/subinterpreters.rst:417

msgid ""

"Return non-zero if adaptive specialization is enabled for the interpreter. "

"Specialization is enabled when no custom eval frame function is set, or when "

"one is set with *allow_specialization* enabled."

msgstr ""

#: ../../c-api/subinterpreters.rst:425

msgid "Low-level APIs"

msgstr ""

#: ../../c-api/subinterpreters.rst:427

msgid ""

"All of the following functions must be called after :c:func:`Py_Initialize`."

msgstr ""

#: ../../c-api/subinterpreters.rst:429

msgid ""

":c:func:`Py_Initialize()` now initializes the :term:`GIL` and sets an :term:"

"`attached thread state`."

msgstr ""

#: ../../c-api/subinterpreters.rst:436

msgid ""

"Create a new interpreter state object. An :term:`attached thread state` is "

"not needed, but may optionally exist if it is necessary to serialize calls "

"to this function."

msgstr ""

#: ../../c-api/subinterpreters.rst:440

msgid ""

"Raises an :ref:`auditing event <auditing>` ``cpython."

"PyInterpreterState_New`` with no arguments."

msgstr ""

#: ../../c-api/subinterpreters.rst:445

msgid ""

"Reset all information in an interpreter state object. There must be an :"

"term:`attached thread state` for the interpreter."

msgstr ""

#: ../../c-api/subinterpreters.rst:448

msgid ""

"Raises an :ref:`auditing event <auditing>` ``cpython."

"PyInterpreterState_Clear`` with no arguments."

msgstr ""

#: ../../c-api/subinterpreters.rst:453

msgid ""

"Destroy an interpreter state object. There **should not** be an :term:"

"`attached thread state` for the target interpreter. The interpreter state "

"must have been reset with a previous call to :c:func:"

"`PyInterpreterState_Clear`."

msgstr ""

#: ../../c-api/subinterpreters.rst:461

msgid "Advanced debugger support"

msgstr ""

#: ../../c-api/subinterpreters.rst:463

msgid ""

"These functions are only intended to be used by advanced debugging tools."

msgstr ""

#: ../../c-api/subinterpreters.rst:468

msgid ""

"Return the interpreter state object at the head of the list of all such "

"objects."

msgstr ""

#: ../../c-api/subinterpreters.rst:473

msgid "Return the main interpreter state object."

msgstr ""

#: ../../c-api/subinterpreters.rst:478

msgid ""

"Return the next interpreter state object after *interp* from the list of all "

"such objects."

msgstr ""

#: ../../c-api/subinterpreters.rst:484

msgid ""

"Return the pointer to the first :c:type:`PyThreadState` object in the list "

"of threads associated with the interpreter *interp*."

msgstr ""

#: ../../c-api/subinterpreters.rst:490

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 ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "module"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "builtins"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "__main__"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "sys"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "stdout (in module sys)"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "stderr (in module sys)"

msgstr ""

#: ../../c-api/subinterpreters.rst:115 ../../c-api/subinterpreters.rst:215

msgid "stdin (in module sys)"

msgstr ""

#: ../../c-api/subinterpreters.rst:179 ../../c-api/subinterpreters.rst:233

msgid "Py_FinalizeEx (C function)"

msgstr ""

#: ../../c-api/subinterpreters.rst:179

msgid "Py_Initialize (C function)"

msgstr ""

#: ../../c-api/subinterpreters.rst:210

msgid "close (in module os)"

msgstr ""