# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-15 09:12+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\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"

#: ../../reference/executionmodel.rst:6
msgid "Execution model"
msgstr "Ausführungsmodell"

#: ../../reference/executionmodel.rst:15
msgid "Structure of a program"
msgstr "Aufbau eines Programms"

#: ../../reference/executionmodel.rst:19
msgid ""
"A Python program is constructed from code blocks. A :dfn:`block` is a piece "
"of Python program text that is executed as a unit. The following are blocks: "
"a module, a function body, and a class definition. Each command typed "
"interactively is a block.  A script file (a file given as standard input to "
"the interpreter or specified as a command line argument to the interpreter) "
"is a code block.  A script command (a command specified on the interpreter "
"command line with the :option:`-c` option) is a code block. A module run as "
"a top level script (as module ``__main__``) from the command line using a :"
"option:`-m` argument is also a code block. The string argument passed to the "
"built-in functions :func:`eval` and :func:`exec` is a code block."
msgstr ""
"Ein Python-Programm setzt sich aus Codeblöcken zusammen. Ein :dfn:`Block` "
"ist ein Teil des Python-Programmtextes, der als Einheit ausgeführt wird. Zu "
"den Blöcken gehören: ein Modul, ein Funktionskörper und eine "
"Klassendefinition. Jeder interaktiv eingegebene Befehl ist ein Block. Eine "
"Skriptdatei (eine Datei, die dem Interpreter als Standardeingabe übergeben "
"oder als Befehlszeilenargument für den Interpreter angegeben wird) ist ein "
"Codeblock. Ein Skriptbefehl (ein Befehl, der in der Befehlszeile des "
"Interpreters mit der Option :option:`-c` angegeben wird) ist ein Codeblock. "
"Ein Modul, das als Skript der obersten Ebene (als Modul ``__main__`` ) über "
"die Befehlszeile mit dem Argument :option:`-m` ausgeführt wird, ist "
"ebenfalls ein Codeblock. Das an die integrierten Funktionen :func:`eval` "
"und :func:`exec` übergebene Zeichenfolgenargument ist ein Codeblock."

#: ../../reference/executionmodel.rst:33
msgid ""
"A code block is executed in an :dfn:`execution frame`.  A frame contains "
"some administrative information (used for debugging) and determines where "
"and how execution continues after the code block's execution has completed."
msgstr ""
"Ein Codeblock wird in einem :dfn:`Ausführungsrahmen` ausgeführt. Ein Rahmen "
"enthält einige Verwaltungsinformationen (die zur Fehlersuche dienen) und "
"legt fest, wo und wie die Ausführung fortgesetzt wird, nachdem die "
"Ausführung des Codeblocks abgeschlossen ist."

#: ../../reference/executionmodel.rst:40
msgid "Naming and binding"
msgstr "Benennung und Zuordnung"

#: ../../reference/executionmodel.rst:49
msgid "Binding of names"
msgstr "Namensbindung"

#: ../../reference/executionmodel.rst:55
msgid ""
":dfn:`Names` refer to objects.  Names are introduced by name binding "
"operations."
msgstr ""
":dfn:`Namen` beziehen sich auf Objekte. Namen werden durch "
"Namensbindungsoperationen eingeführt."

#: ../../reference/executionmodel.rst:59
msgid "The following constructs bind names:"
msgstr "Die folgenden Konstrukte binden Namen:"

#: ../../reference/executionmodel.rst:61
msgid "formal parameters to functions,"
msgstr "Formale Parameter von Funktionen,"

#: ../../reference/executionmodel.rst:62
msgid "class definitions,"
msgstr "Klassendefinitionen,"

#: ../../reference/executionmodel.rst:63
msgid "function definitions,"
msgstr "Funktionsdefinitionen,"

#: ../../reference/executionmodel.rst:64
msgid "assignment expressions,"
msgstr "Zuweisungsausdrücke,"

#: ../../reference/executionmodel.rst:65
msgid ""
":ref:`targets <assignment>` that are identifiers if occurring in an "
"assignment:"
msgstr ""
":ref:`Ziele <assignment>`, die als Bezeichner gelten, wenn sie in einer "
"Zuweisung vorkommen:"

#: ../../reference/executionmodel.rst:68
msgid ":keyword:`for` loop header,"
msgstr ":keyword:`for` Schleifenkopf,"

#: ../../reference/executionmodel.rst:69
msgid ""
"after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` "
"clause, :keyword:`except* <except_star>` clause, or in the as-pattern in "
"structural pattern matching,"
msgstr ""
"nach :keyword:`!as` in einer :keyword:`with`-Anweisung, einer :keyword:"
"`except`-Klausel, einer :keyword:`except* <except_star>`-Klausel oder im "
"\"as\"-Muster beim strukturellen Musterabgleich,"

#: ../../reference/executionmodel.rst:71
msgid "in a capture pattern in structural pattern matching"
msgstr "in einem Erfassungsmuster beim strukturellen Musterabgleich"

#: ../../reference/executionmodel.rst:73
msgid ":keyword:`import` statements."
msgstr ":keyword:`import` Aussagen."

#: ../../reference/executionmodel.rst:74
msgid ":keyword:`type` statements."
msgstr ":keyword:`type` Aussagen."

#: ../../reference/executionmodel.rst:75
msgid ":ref:`type parameter lists <type-params>`."
msgstr ":ref:`Typ-Parameterlisten <type-params>`."

#: ../../reference/executionmodel.rst:77
msgid ""
"The :keyword:`!import` statement of the form ``from ... import *`` binds all "
"names defined in the imported module, except those beginning with an "
"underscore. This form may only be used at the module level."
msgstr ""
"Die Anweisung :keyword:`!import` in der Form ``from ... import *`` bindet "
"alle im importierten Modul definierten Namen, mit Ausnahme derjenigen, die "
"mit einem Unterstrich beginnen. Diese Form darf nur auf Modulebene verwendet "
"werden."

#: ../../reference/executionmodel.rst:81
msgid ""
"A target occurring in a :keyword:`del` statement is also considered bound "
"for this purpose (though the actual semantics are to unbind the name)."
msgstr ""
"Ein Ziel, das in einer Anweisung vom Typ :keyword:`del` vorkommt, gilt für "
"diesen Zweck ebenfalls als gebunden (auch wenn die eigentliche Semantik "
"darin besteht, die Bindung des Namens aufzuheben)."

#: ../../reference/executionmodel.rst:84
msgid ""
"Each assignment or import statement occurs within a block defined by a class "
"or function definition or at the module level (the top-level code block)."
msgstr ""
"Jede Zuweisungs- oder Importanweisung erfolgt innerhalb eines Blocks, der "
"durch eine Klassen- oder Funktionsdefinition definiert ist, oder auf "
"Modulebene (dem Code-Block der obersten Ebene)."

#: ../../reference/executionmodel.rst:89
msgid ""
"If a name is bound in a block, it is a local variable of that block, unless "
"declared as :keyword:`nonlocal` or :keyword:`global`.  If a name is bound at "
"the module level, it is a global variable.  (The variables of the module "
"code block are local and global.)  If a variable is used in a code block but "
"not defined there, it is a :term:`free variable`."
msgstr ""
"Wird ein Name in einem Block gebunden, handelt es sich um eine lokale "
"Variable dieses Blocks, sofern er nicht als :keyword:`nonlocal` oder :"
"keyword:`global` deklariert wurde. Wird ein Name auf Modulebene gebunden, "
"handelt es sich um eine globale Variable. (Die Variablen des Modul-"
"Codeblocks sind sowohl lokal als auch global.)  Wird eine Variable in einem "
"Codeblock verwendet, dort aber nicht definiert, handelt es sich um eine :"
"term:`freie Variable <free variable>`."

#: ../../reference/executionmodel.rst:95
msgid ""
"Each occurrence of a name in the program text refers to the :dfn:`binding` "
"of that name established by the following name resolution rules."
msgstr ""
"Jedes Vorkommen eines Namens im Programmtext bezieht sich auf die :dfn:"
"`Bindung` dieses Namens, die durch die folgenden Namensauflösungsregeln "
"festgelegt wird."

#: ../../reference/executionmodel.rst:101
msgid "Resolution of names"
msgstr "Namensauflösung"

#: ../../reference/executionmodel.rst:105
msgid ""
"A :dfn:`scope` defines the visibility of a name within a block.  If a local "
"variable is defined in a block, its scope includes that block.  If the "
"definition occurs in a function block, the scope extends to any blocks "
"contained within the defining one, unless a contained block introduces a "
"different binding for the name."
msgstr ""
"Ein :dfn:`Gültigkeitsbereich` legt fest, in welchem Umfang ein Name "
"innerhalb eines Blocks sichtbar ist. Wird eine lokale Variable in einem "
"Block definiert, erstreckt sich ihr Gültigkeitsbereich auf diesen Block. "
"Erfolgt die Definition in einem Funktionsblock, erstreckt sich der "
"Gültigkeitsbereich auf alle Blöcke, die in dem definierenden Block enthalten "
"sind, es sei denn, ein darin enthaltener Block führt eine andere Bindung für "
"den Namen ein."

#: ../../reference/executionmodel.rst:113
msgid ""
"When a name is used in a code block, it is resolved using the nearest "
"enclosing scope.  The set of all such scopes visible to a code block is "
"called the block's :dfn:`environment`."
msgstr ""
"Wenn ein Name in einem Codeblock verwendet wird, wird er anhand des "
"nächstgelegenen übergeordneten Gültigkeitsbereichs aufgelöst. Die Menge "
"aller solcher Gültigkeitsbereiche, die für einen Codeblock sichtbar sind, "
"wird als :dfn:`Umgebung` des Blocks bezeichnet."

#: ../../reference/executionmodel.rst:121
msgid ""
"When a name is not found at all, a :exc:`NameError` exception is raised. If "
"the current scope is a function scope, and the name refers to a local "
"variable that has not yet been bound to a value at the point where the name "
"is used, an :exc:`UnboundLocalError` exception is raised. :exc:"
"`UnboundLocalError` is a subclass of :exc:`NameError`."
msgstr ""
"Wenn ein Name überhaupt nicht gefunden wird, wird eine Ausnahme vom Typ :exc:"
"`NameError` ausgelöst. Handelt es sich beim aktuellen Gültigkeitsbereich um "
"einen Funktionsbereich und bezieht sich der Name auf eine lokale Variable, "
"die an der Stelle, an der der Name verwendet wird, noch nicht mit einem Wert "
"belegt wurde, wird eine Ausnahme vom Typ :exc:`UnboundLocalError` "
"ausgelöst. :exc:`UnboundLocalError` ist eine Unterklasse von :exc:"
"`NameError` ."

#: ../../reference/executionmodel.rst:127
msgid ""
"If a name binding operation occurs anywhere within a code block, all uses of "
"the name within the block are treated as references to the current block.  "
"This can lead to errors when a name is used within a block before it is "
"bound.  This rule is subtle.  Python lacks declarations and allows name "
"binding operations to occur anywhere within a code block.  The local "
"variables of a code block can be determined by scanning the entire text of "
"the block for name binding operations. See :ref:`the FAQ entry on "
"UnboundLocalError <faq-unboundlocalerror>` for examples."
msgstr ""
"Wenn irgendwo innerhalb eines Codeblocks eine Namensbindung stattfindet, "
"werden alle Verwendungen des Namens innerhalb des Blocks als Verweise auf "
"den aktuellen Block behandelt. Dies kann zu Fehlern führen, wenn ein Name "
"innerhalb eines Blocks verwendet wird, bevor er gebunden wurde. Diese Regel "
"ist nicht ganz einfach zu verstehen.  Python kennt keine Deklarationen und "
"erlaubt es, dass Namensbindungsoperationen an beliebiger Stelle innerhalb "
"eines Codeblocks stattfinden.  Die lokalen Variablen eines Codeblocks lassen "
"sich ermitteln, indem der gesamte Text des Blocks auf "
"Namensbindungsoperationen durchsucht wird. Beispiele finden Sie im :ref:`FAQ-"
"Eintrag zu UnboundLocalError <faq-unboundlocalerror>`."

#: ../../reference/executionmodel.rst:136
msgid ""
"If the :keyword:`global` statement occurs within a block, all uses of the "
"names specified in the statement refer to the bindings of those names in the "
"top-level namespace.  Names are resolved in the top-level namespace by "
"searching the global namespace, i.e. the namespace of the module containing "
"the code block, and the builtins namespace, the namespace of the module :mod:"
"`builtins`.  The global namespace is searched first.  If the names are not "
"found there, the builtins namespace is searched next. If the names are also "
"not found in the builtins namespace, new variables are created in the global "
"namespace. The global statement must precede all uses of the listed names."
msgstr ""
"Wenn die Anweisung :keyword:`global` innerhalb eines Blocks auftritt, "
"beziehen sich alle Verwendungen der in der Anweisung angegebenen Namen auf "
"die Zuordnungen dieser Namen im obersten Namensraum.  Namen werden im "
"obersten Namensraum aufgelöst, indem der globale Namensraum, d. h. der "
"Namensraum des Moduls, das den Codeblock enthält, sowie der \"builtins\"-"
"Namensraum, der Namensraum des Moduls :mod:`builtins`, durchsucht werden. "
"Der globale Namensraum wird zuerst durchsucht. Werden die Namen dort nicht "
"gefunden, wird als Nächstes der \"builtins\"-Namensraum durchsucht. Werden "
"die Namen auch im \"builtins\"-Namensraum nicht gefunden, werden neue "
"Variablen im globalen Namensraum angelegt. Die Anweisung \"global\" muss "
"allen Verwendungen der aufgeführten Namen vorangestellt werden."

#: ../../reference/executionmodel.rst:146
msgid ""
"The :keyword:`global` statement has the same scope as a name binding "
"operation in the same block.  If the nearest enclosing scope for a free "
"variable contains a global statement, the free variable is treated as a "
"global."
msgstr ""
"Die Anweisung :keyword:`global` hat denselben Geltungsbereich wie eine "
"Namensbindung im selben Block. Wenn der nächstübergeordnete Geltungsbereich "
"einer freien Variablen eine globale Anweisung enthält, wird die freie "
"Variable als globale Variable behandelt."

#: ../../reference/executionmodel.rst:152
msgid ""
"The :keyword:`nonlocal` statement causes corresponding names to refer to "
"previously bound variables in the nearest enclosing function scope. :exc:"
"`SyntaxError` is raised at compile time if the given name does not exist in "
"any enclosing function scope. :ref:`Type parameters <type-params>` cannot be "
"rebound with the :keyword:`!nonlocal` statement."
msgstr ""
"Die Anweisung :keyword:`nonlocal` bewirkt, dass die entsprechenden Namen auf "
"zuvor gebundene Variablen im nächstübergeordneten "
"Funktionsgültigkeitsbereich verweisen. Wenn der angegebene Name in keinem "
"übergeordneten Funktionsgültigkeitsbereich existiert, wird zur "
"Kompilierungszeit ein :exc:`SyntaxError` ausgelöst. :ref:`Typ-Parameter "
"<type-params>` können mit der Anweisung :keyword:`!nonlocal` nicht neu "
"gebunden werden."

#: ../../reference/executionmodel.rst:160
msgid ""
"The namespace for a module is automatically created the first time a module "
"is imported.  The main module for a script is always called :mod:`__main__`."
msgstr ""
"Der Namensraum für ein Modul wird automatisch angelegt, sobald das Modul zum "
"ersten Mal importiert wird. Das Hauptmodul eines Skripts heißt immer :mod:"
"`__main__` ."

#: ../../reference/executionmodel.rst:163
msgid ""
"Class definition blocks and arguments to :func:`exec` and :func:`eval` are "
"special in the context of name resolution. A class definition is an "
"executable statement that may use and define names. These references follow "
"the normal rules for name resolution with an exception that unbound local "
"variables are looked up in the global namespace. The namespace of the class "
"definition becomes the attribute dictionary of the class. The scope of names "
"defined in a class block is limited to the class block; it does not extend "
"to the code blocks of methods. This includes comprehensions and generator "
"expressions, but it does not include :ref:`annotation scopes <annotation-"
"scopes>`, which have access to their enclosing class scopes. This means that "
"the following will fail::"
msgstr ""
"Klassendefinitionsblöcke und Argumente für :func:`exec` und :func:`eval` "
"stellen im Zusammenhang mit der Namensauflösung einen Sonderfall dar. Eine "
"Klassendefinition ist eine ausführbare Anweisung, die Namen verwenden und "
"definieren kann. Diese Verweise folgen den üblichen Regeln für die "
"Namensauflösung, mit der Ausnahme, dass ungebundene lokale Variablen im "
"globalen Namensraum gesucht werden. Der Namensraum der Klassendefinition "
"wird zum Attributwörterbuch der Klasse. Der Geltungsbereich von Namen, die "
"in einem Klassenblock definiert werden, ist auf den Klassenblock beschränkt; "
"er erstreckt sich nicht auf die Codeblöcke von Methoden. Dies umfasst "
"Comprehensions und Generatorausdrücke, jedoch nicht :ref:`Annotations-"
"Geltungsbereiche <annotation-scopes>`, die Zugriff auf die Geltungsbereiche "
"ihrer umschließenden Klassen haben. Das bedeutet, dass Folgendes "
"fehlschlagen wird::"

#: ../../reference/executionmodel.rst:176
msgid ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"
msgstr ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"

#: ../../reference/executionmodel.rst:180
msgid "However, the following will succeed::"
msgstr "Folgendes wird jedoch funktionieren:"

#: ../../reference/executionmodel.rst:182
msgid ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"
msgstr ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"

#: ../../reference/executionmodel.rst:191
msgid "Annotation scopes"
msgstr "Gültigkeitsbereiche von Annotationen"

#: ../../reference/executionmodel.rst:193
msgid ""
":term:`Annotations <annotation>`, :ref:`type parameter lists <type-params>` "
"and :keyword:`type` statements introduce *annotation scopes*, which behave "
"mostly like function scopes, but with some exceptions discussed below."
msgstr ""
":term:`Annotationen <annotation>`, :ref:`Typ-Parameterlisten <type-params>` "
"und :keyword:`type`-Anweisungen führen *Annotationsgültigkeitsbereiche* ein, "
"die sich größtenteils wie Funktionsgültigkeitsbereiche verhalten, jedoch mit "
"einigen Ausnahmen, die im Folgenden erläutert werden."

#: ../../reference/executionmodel.rst:198
msgid "Annotation scopes are used in the following contexts:"
msgstr "Annotationsbereiche werden in den folgenden Kontexten verwendet:"

#: ../../reference/executionmodel.rst:200
msgid ":term:`Function annotations <function annotation>`."
msgstr ":term:`Funktionsannotationen <function annotation>`."

#: ../../reference/executionmodel.rst:201
msgid ":term:`Variable annotations <variable annotation>`."
msgstr ":term:`Variablen-Annotationen <variable annotation>`."

#: ../../reference/executionmodel.rst:202
msgid ""
"Type parameter lists for :ref:`generic type aliases <generic-type-aliases>`."
msgstr ""
"Typ-Parameterlisten für :ref:`generische Typ-Aliase <generic-type-aliases>`."

#: ../../reference/executionmodel.rst:203
msgid ""
"Type parameter lists for :ref:`generic functions <generic-functions>`. A "
"generic function's annotations are executed within the annotation scope, but "
"its defaults and decorators are not."
msgstr ""
"Typ-Parameterlisten für :ref:`generische Funktionen <generic-functions>`. "
"Die Annotationen einer generischen Funktion werden innerhalb des "
"Annotationsbereichs ausgeführt, ihre Standardwerte und Dekoratoren hingegen "
"nicht."

#: ../../reference/executionmodel.rst:206
msgid ""
"Type parameter lists for :ref:`generic classes <generic-classes>`. A generic "
"class's base classes and keyword arguments are executed within the "
"annotation scope, but its decorators are not."
msgstr ""
"Typ-Parameterlisten für :ref:`generische Klassen <generic-classes>`. Die "
"Basisklassen und Schlüsselwortargumente einer generischen Klasse werden "
"innerhalb des Annotationsbereichs ausgeführt, ihre Dekoratoren jedoch nicht."

#: ../../reference/executionmodel.rst:209
msgid ""
"The bounds, constraints, and default values for type parameters (:ref:"
"`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"Die Grenzen, Einschränkungen und Standardwerte für Typparameter (:ref:"
"`verzögert ausgewertete <lazy-evaluation>`)."

#: ../../reference/executionmodel.rst:211
msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"Der Wert von Typaliasen (:ref:`verzögert ausgewertet <lazy-evaluation>`)."

#: ../../reference/executionmodel.rst:213
msgid "Annotation scopes differ from function scopes in the following ways:"
msgstr ""
"Annotations-Gültigkeitsbereiche unterscheiden sich in folgenden Punkten von "
"Funktions-Gültigkeitsbereichen:"

#: ../../reference/executionmodel.rst:215
msgid ""
"Annotation scopes have access to their enclosing class namespace. If an "
"annotation scope is immediately within a class scope, or within another "
"annotation scope that is immediately within a class scope, the code in the "
"annotation scope can use names defined in the class scope as if it were "
"executed directly within the class body. This contrasts with regular "
"functions defined within classes, which cannot access names defined in the "
"class scope."
msgstr ""
"Annotationsbereiche haben Zugriff auf den Namensraum ihrer übergeordneten "
"Klasse. Befindet sich ein Annotationsbereich unmittelbar innerhalb eines "
"Klassenbereichs oder innerhalb eines anderen Annotationsbereichs, der sich "
"wiederum unmittelbar innerhalb eines Klassenbereichs befindet, kann der Code "
"im Annotationsbereich auf im Klassenbereich definierte Namen zugreifen, als "
"würde er direkt innerhalb des Klassenkörpers ausgeführt. Dies steht im "
"Gegensatz zu regulären, innerhalb von Klassen definierten Funktionen, die "
"keinen Zugriff auf im Klassenbereich definierte Namen haben."

#: ../../reference/executionmodel.rst:221
msgid ""
"Expressions in annotation scopes cannot contain :keyword:`yield`, ``yield "
"from``, :keyword:`await`, or :token:`:= <python-grammar:"
"assignment_expression>` expressions. (These expressions are allowed in other "
"scopes contained within the annotation scope.)"
msgstr ""
"Ausdrücke in Annotationsbereichen dürfen keine Ausdrücke vom Typ :keyword:"
"`yield`, ``yield from``, :keyword:`await` oder :token:`:= <python-grammar:"
"assignment_expression>` enthalten. (Diese Ausdrücke sind in anderen "
"Bereichen zulässig, die innerhalb des Annotationsbereichs enthalten sind.)"

#: ../../reference/executionmodel.rst:225
msgid ""
"Names defined in annotation scopes cannot be rebound with :keyword:"
"`nonlocal` statements in inner scopes. This includes only type parameters, "
"as no other syntactic elements that can appear within annotation scopes can "
"introduce new names."
msgstr ""
"Namen, die in Annotationsbereichen definiert wurden, können nicht mit :"
"keyword:`nonlocal`-Anweisungen in inneren Bereichen neu definiert werden. "
"Dies betrifft ausschließlich Typparameter, da keine anderen syntaktischen "
"Elemente, die innerhalb von Annotationsbereichen vorkommen können, neue "
"Namen einführen können."

#: ../../reference/executionmodel.rst:228
msgid ""
"While annotation scopes have an internal name, that name is not reflected in "
"the :term:`qualified name` of objects defined within the scope. Instead, "
"the :attr:`~definition.__qualname__` of such objects is as if the object "
"were defined in the enclosing scope."
msgstr ""
"Annotationsbereiche verfügen zwar über einen internen Namen, dieser Name "
"spiegelt sich jedoch nicht im :term:`qualifizierten Namen <qualified name>` "
"der innerhalb des Bereichs definierten Objekte wider. Stattdessen entspricht "
"der :attr:`~definition.__qualname__` solcher Objekte dem, als wäre das "
"Objekt im übergeordneten Bereich definiert."

#: ../../reference/executionmodel.rst:233
msgid "Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."
msgstr ""
"Annotationsbereiche wurden in Python 3.12 als Teil von :pep:`695` eingeführt."

#: ../../reference/executionmodel.rst:236
msgid ""
"Annotation scopes are also used for type parameter defaults, as introduced "
"by :pep:`696`."
msgstr ""
"Annotationsbereiche werden auch für Standardwerte von Typparametern "
"verwendet, wie unter :pep:`696` beschrieben."

#: ../../reference/executionmodel.rst:240
msgid ""
"Annotation scopes are now also used for annotations, as specified in :pep:"
"`649` and :pep:`749`."
msgstr ""
"Annotationsbereiche werden nun auch für Annotationen verwendet, wie unter :"
"pep:`649` und :pep:`749` beschrieben."

#: ../../reference/executionmodel.rst:247
msgid "Lazy evaluation"
msgstr "Verzögerte Auswertung"

#: ../../reference/executionmodel.rst:249
msgid ""
"Most annotation scopes are *lazily evaluated*. This includes annotations, "
"the values of type aliases created through the :keyword:`type` statement, "
"and the bounds, constraints, and default values of type variables created "
"through the :ref:`type parameter syntax <type-params>`. This means that they "
"are not evaluated when the type alias or type variable is created, or when "
"the object carrying annotations is created. Instead, they are only evaluated "
"when necessary, for example when the ``__value__`` attribute on a type alias "
"is accessed."
msgstr ""
"Die meisten Annotationsbereiche werden *verzögert ausgewertet*. Dazu gehören "
"Annotationen, die Werte von Typaliasen, die über die Anweisung :keyword:"
"`type` erstellt wurden, sowie die Grenzen, Einschränkungen und Standardwerte "
"von Typvariablen, die über die :ref:`Typ-Parametersyntax <type-params>` "
"erstellt wurden. Das bedeutet, dass sie nicht ausgewertet werden, wenn der "
"Typalias oder die Typvariable erstellt wird oder wenn das Objekt, das die "
"Annotationen trägt, erstellt wird. Stattdessen werden sie erst bei Bedarf "
"ausgewertet, beispielsweise wenn auf das Attribut ``__value__`` eines "
"Typalias zugegriffen wird."

#: ../../reference/executionmodel.rst:258
msgid "Example:"
msgstr "Beispiel:"

#: ../../reference/executionmodel.rst:260
msgid ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"
msgstr ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"

#: ../../reference/executionmodel.rst:274
msgid ""
"Here the exception is raised only when the ``__value__`` attribute of the "
"type alias or the ``__bound__`` attribute of the type variable is accessed."
msgstr ""
"Hier wird die Ausnahme nur ausgelöst, wenn auf das Attribut ``__value__``  "
"des Typalias oder auf das Attribut ``__bound__`` der Typvariablen "
"zugegriffen wird."

#: ../../reference/executionmodel.rst:278
msgid ""
"This behavior is primarily useful for references to types that have not yet "
"been defined when the type alias or type variable is created. For example, "
"lazy evaluation enables creation of mutually recursive type aliases::"
msgstr ""
"Dieses Verhalten ist vor allem bei Verweisen auf Typen nützlich, die zum "
"Zeitpunkt der Erstellung des Typalias oder der Typvariablen noch nicht "
"definiert waren. So ermöglicht die verzögerte Auswertung beispielsweise die "
"Erstellung von gegenseitig rekursiven Typalias:"

#: ../../reference/executionmodel.rst:282
msgid ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"
msgstr ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"

#: ../../reference/executionmodel.rst:288
msgid ""
"Lazily evaluated values are evaluated in :ref:`annotation scope <annotation-"
"scopes>`, which means that names that appear inside the lazily evaluated "
"value are looked up as if they were used in the immediately enclosing scope."
msgstr ""
"Verzögerte ausgewertete Werte werden im :ref:`Annotationsbereich <annotation-"
"scopes>` ausgewertet, was bedeutet, dass Namen, die innerhalb des "
"verzögertausgewerteten Werts vorkommen, so nachgeschlagen werden, als würden "
"sie im unmittelbar umgebenden Bereich verwendet."

#: ../../reference/executionmodel.rst:297
msgid "Builtins and restricted execution"
msgstr "Eingebaute Funktionen und eingeschränkte Ausführung"

#: ../../reference/executionmodel.rst:303
msgid ""
"Users should not touch ``__builtins__``; it is strictly an implementation "
"detail.  Users wanting to override values in the builtins namespace should :"
"keyword:`import` the :mod:`builtins` module and modify its attributes "
"appropriately."
msgstr ""
"Benutzer sollten ``__builtins__`` nicht ändern; es handelt sich dabei "
"ausschließlich um ein Implementierungsdetail. Benutzer, die Werte im "
"Namespace \"builtins\" überschreiben möchten, sollten das Modul :mod:"
"`builtins` über :keyword:`import` laden und dessen Attribute entsprechend "
"anpassen."

#: ../../reference/executionmodel.rst:308
msgid ""
"The builtins namespace associated with the execution of a code block is "
"actually found by looking up the name ``__builtins__`` in its global "
"namespace; this should be a dictionary or a module (in the latter case the "
"module's dictionary is used).  By default, when in the :mod:`__main__` "
"module, ``__builtins__`` is the built-in module :mod:`builtins`; when in any "
"other module, ``__builtins__`` is an alias for the dictionary of the :mod:"
"`builtins` module itself."
msgstr ""
"Der mit der Ausführung eines Codeblocks verbundene \"builtins\"-Namensraum "
"wird tatsächlich durch Abfrage des Namens ``__builtins__`` in dessen "
"globalem Namensraum ermittelt; dabei sollte es sich um ein Wörterbuch oder "
"ein Modul handeln (im letzteren Fall wird das Wörterbuch des Moduls "
"verwendet).  Standardmäßig ist ``__builtins__`` im Modul :mod:`__main__` das "
"eingebaute Modul :mod:`builtins` ; in jedem anderen Modul ist "
"``__builtins__`` ein Alias für das Wörterbuch des Moduls :mod:`builtins` "
"selbst."

#: ../../reference/executionmodel.rst:320
msgid "Interaction with dynamic features"
msgstr "Interaktion mit dynamischen Funktionen"

#: ../../reference/executionmodel.rst:322
msgid ""
"Name resolution of free variables occurs at runtime, not at compile time. "
"This means that the following code will print 42::"
msgstr ""
"Die Auflösung freier Variablen erfolgt zur Laufzeit und nicht zur "
"Kompilierungszeit. Das bedeutet, dass der folgende Code 42 ausgibt::"

#: ../../reference/executionmodel.rst:325
msgid ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"
msgstr ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"

#: ../../reference/executionmodel.rst:333
msgid ""
"The :func:`eval` and :func:`exec` functions do not have access to the full "
"environment for resolving names.  Names may be resolved in the local and "
"global namespaces of the caller.  Free variables are not resolved in the "
"nearest enclosing namespace, but in the global namespace.  [#]_ The :func:"
"`exec` and :func:`eval` functions have optional arguments to override the "
"global and local namespace.  If only one namespace is specified, it is used "
"for both."
msgstr ""
"Die Funktionen :func:`eval` und :func:`exec` haben keinen Zugriff auf die "
"vollständige Umgebung zur Namensauflösung.  Namen können im lokalen und "
"globalen Namensraum des Aufrufers aufgelöst werden. Freie Variablen werden "
"nicht im nächstübergeordneten Namensraum, sondern im globalen Namensraum "
"aufgelöst. [#]_ Die Funktionen :func:`exec` und :func:`eval` verfügen über "
"optionale Argumente, um den globalen und lokalen Namensraum zu "
"überschreiben. Wird nur ein Namensraum angegeben, wird dieser für beide "
"verwendet."

#: ../../reference/executionmodel.rst:347
msgid "Exceptions"
msgstr "Ausnahmen"

#: ../../reference/executionmodel.rst:358
msgid ""
"Exceptions are a means of breaking out of the normal flow of control of a "
"code block in order to handle errors or other exceptional conditions.  An "
"exception is *raised* at the point where the error is detected; it may be "
"*handled* by the surrounding code block or by any code block that directly "
"or indirectly invoked the code block where the error occurred."
msgstr ""
"Ausnahmen dienen dazu, den normalen Kontrollfluss eines Codeblocks zu "
"unterbrechen, um Fehler oder andere Ausnahmebedingungen zu behandeln.  Eine "
"Ausnahme wird an der Stelle *ausgelöst*, an der der Fehler erkannt wird; sie "
"kann vom umgebenden Codeblock oder von jedem Codeblock *behandelt* werden, "
"der den Codeblock, in dem der Fehler aufgetreten ist, direkt oder indirekt "
"aufgerufen hat."

#: ../../reference/executionmodel.rst:364
msgid ""
"The Python interpreter raises an exception when it detects a run-time error "
"(such as division by zero).  A Python program can also explicitly raise an "
"exception with the :keyword:`raise` statement. Exception handlers are "
"specified with the :keyword:`try` ... :keyword:`except` statement.  The :"
"keyword:`finally` clause of such a statement can be used to specify cleanup "
"code which does not handle the exception, but is executed whether an "
"exception occurred or not in the preceding code."
msgstr ""
"Der Python-Interpreter löst eine Ausnahme aus, wenn er einen Laufzeitfehler "
"(wie beispielsweise eine Division durch Null) feststellt. Ein Python-"
"Programm kann zudem mit der Anweisung :keyword:`raise` explizit eine "
"Ausnahme auslösen. Ausnahmebehandler werden mit der Anweisung :keyword:"
"`try`... :keyword:`except` festgelegt.  Die Klausel :keyword:`finally` einer "
"solchen Anweisung kann verwendet werden, um Aufräumcode anzugeben, der die "
"Ausnahme nicht behandelt, sondern unabhängig davon ausgeführt wird, ob im "
"vorangehenden Code eine Ausnahme aufgetreten ist oder nicht."

#: ../../reference/executionmodel.rst:374
msgid ""
"Python uses the \"termination\" model of error handling: an exception "
"handler can find out what happened and continue execution at an outer level, "
"but it cannot repair the cause of the error and retry the failing operation "
"(except by re-entering the offending piece of code from the top)."
msgstr ""
"Python verwendet das \"Termination\"-Modell der Fehlerbehandlung: Ein "
"Ausnahmebehandler kann zwar feststellen, was passiert ist, und die "
"Ausführung auf einer übergeordneten Ebene fortsetzen, aber er kann die "
"Fehlerursache nicht beheben und den fehlgeschlagenen Vorgang nicht "
"wiederholen (außer durch erneutes Ausführen des fehlerhaften Codeabschnitts "
"von Anfang an)."

#: ../../reference/executionmodel.rst:381
msgid ""
"When an exception is not handled at all, the interpreter terminates "
"execution of the program, or returns to its interactive main loop.  In "
"either case, it prints a stack traceback, except when the exception is :exc:"
"`SystemExit`."
msgstr ""
"Wird eine Ausnahme überhaupt nicht abgefangen, bricht der Interpreter die "
"Ausführung des Programms ab oder kehrt zu seiner interaktiven Hauptschleife "
"zurück. In beiden Fällen gibt er einen Stack-Traceback aus, es sei denn, es "
"handelt sich um die Ausnahme :exc:`SystemExit` ."

#: ../../reference/executionmodel.rst:385
msgid ""
"Exceptions are identified by class instances.  The :keyword:`except` clause "
"is selected depending on the class of the instance: it must reference the "
"class of the instance or a :term:`non-virtual base class <abstract base "
"class>` thereof. The instance can be received by the handler and can carry "
"additional information about the exceptional condition."
msgstr ""
"Ausnahmen werden anhand von Klasseninstanzen identifiziert. Die Klausel :"
"keyword:`except` wird je nach Klasse der Instanz ausgewählt: Sie muss auf "
"die Klasse der Instanz oder auf eine :term:`nicht-virtuelle Basisklasse "
"<abstract base class>` derselben verweisen. Die Instanz kann vom Handler "
"empfangen werden und zusätzliche Informationen über die Ausnahmebedingung "
"enthalten."

#: ../../reference/executionmodel.rst:393
msgid ""
"Exception messages are not part of the Python API.  Their contents may "
"change from one version of Python to the next without warning and should not "
"be relied on by code which will run under multiple versions of the "
"interpreter."
msgstr ""
"Ausnahmemeldungen sind nicht Teil der Python-API. Ihr Inhalt kann sich von "
"einer Python-Version zur nächsten ohne Vorwarnung ändern, weshalb sich Code, "
"der unter mehreren Versionen des Interpreters ausgeführt wird, nicht darauf "
"verlassen sollte."

#: ../../reference/executionmodel.rst:397
msgid ""
"See also the description of the :keyword:`try` statement in section :ref:"
"`try` and :keyword:`raise` statement in section :ref:`raise`."
msgstr ""
"Siehe auch die Beschreibung der Anweisung :keyword:`try` im Abschnitt :ref:"
"`try` und der Anweisung :keyword:`raise` im Abschnitt :ref:`raise`."

#: ../../reference/executionmodel.rst:404
msgid "Runtime Components"
msgstr "Laufzeitkomponenten"

#: ../../reference/executionmodel.rst:407
msgid "General Computing Model"
msgstr "Allgemeines Rechenmodell"

#: ../../reference/executionmodel.rst:409
msgid ""
"Python's execution model does not operate in a vacuum.  It runs on a host "
"machine and through that host's runtime environment, including its operating "
"system (OS), if there is one.  When a program runs, the conceptual layers of "
"how it runs on the host look something like this:"
msgstr ""
"Das Ausführungsmodell von Python funktioniert nicht in einem Vakuum. Es "
"läuft auf einem Host-Rechner und nutzt dessen Laufzeitumgebung, "
"einschließlich des Betriebssystems (OS), sofern vorhanden. Wenn ein Programm "
"ausgeführt wird, sehen die konzeptionellen Ebenen seiner Ausführung auf dem "
"Host in etwa wie folgt aus:"

#: ../../reference/executionmodel.rst:415
#: ../../reference/executionmodel.rst:474
msgid "**host machine**"
msgstr "**Host-Rechner**"

#: ../../reference/executionmodel.rst:416
#: ../../reference/executionmodel.rst:475
msgid "**process** (global resources)"
msgstr "**Prozess** (globale Ressourcen)"

#: ../../reference/executionmodel.rst:417
msgid "**thread** (runs machine code)"
msgstr "**Thread** (führt Maschinencode aus)"

#: ../../reference/executionmodel.rst:419
msgid ""
"Each process represents a program running on the host.  Think of each "
"process itself as the data part of its program.  Think of the process' "
"threads as the execution part of the program.  This distinction will be "
"important to understand the conceptual Python runtime."
msgstr ""
"Jeder Prozess entspricht einem Programm, das auf dem Host läuft. Stellen Sie "
"sich jeden Prozess selbst als den Datenteil seines Programms vor. Stellen "
"Sie sich die Threads des Prozesses als den Ausführungsteil des Programms "
"vor. Diese Unterscheidung ist wichtig, um die konzeptionelle Python-"
"Laufzeitumgebung zu verstehen."

#: ../../reference/executionmodel.rst:424
msgid ""
"The process, as the data part, is the execution context in which the program "
"runs.  It mostly consists of the set of resources assigned to the program by "
"the host, including memory, signals, file handles, sockets, and environment "
"variables."
msgstr ""
"Der Prozess ist, ebenso wie der Datenteil, der Ausführungskontext, in dem "
"das Programm läuft. Er besteht im Wesentlichen aus der Gesamtheit der "
"Ressourcen, die dem Programm vom Host zugewiesen wurden, darunter Speicher, "
"Signale, Dateihandles, Sockets und Umgebungsvariablen."

#: ../../reference/executionmodel.rst:429
msgid ""
"Processes are isolated and independent from one another.  (The same is true "
"for hosts.)  The host manages the process' access to its assigned resources, "
"in addition to coordinating between processes."
msgstr ""
"Prozesse sind voneinander isoliert und unabhängig. (Das Gleiche gilt für "
"Hosts.) Der Host verwaltet den Zugriff des Prozesses auf die ihm "
"zugewiesenen Ressourcen und sorgt zudem für die Koordination zwischen den "
"Prozessen."

#: ../../reference/executionmodel.rst:433
msgid ""
"Each thread represents the actual execution of the program's machine code, "
"running relative to the resources assigned to the program's process.  It's "
"strictly up to the host how and when that execution takes place."
msgstr ""
"Jeder Thread steht für die tatsächliche Ausführung des Maschinencodes des "
"Programms, die relativ zu den Ressourcen erfolgt, die dem Prozess des "
"Programms zugewiesen sind. Es liegt ausschließlich im Ermessen des Hosts, "
"wie und wann diese Ausführung stattfindet."

#: ../../reference/executionmodel.rst:438
msgid ""
"From the point of view of Python, a program always starts with exactly one "
"thread.  However, the program may grow to run in multiple simultaneous "
"threads.  Not all hosts support multiple threads per process, but most do.  "
"Unlike processes, threads in a process are not isolated and independent from "
"one another.  Specifically, all threads in a process share all of the "
"process' resources."
msgstr ""
"Aus Sicht von Python beginnt ein Programm immer mit genau einem Thread. Das "
"Programm kann jedoch so wachsen, dass es in mehreren gleichzeitigen Threads "
"ausgeführt wird. Nicht alle Hosts unterstützen mehrere Threads pro Prozess, "
"die meisten jedoch schon.  Im Gegensatz zu Prozessen sind Threads innerhalb "
"eines Prozesses nicht voneinander isoliert und unabhängig.  Konkret bedeutet "
"dies, dass sich alle Threads eines Prozesses die gesamten Ressourcen des "
"Prozesses teilen."

#: ../../reference/executionmodel.rst:445
msgid ""
"The fundamental point of threads is that each one does *run* independently, "
"at the same time as the others.  That may be only conceptually at the same "
"time (\"concurrently\") or physically (\"in parallel\").  Either way, the "
"threads effectively run at a non-synchronized rate."
msgstr ""
"Das Wesentliche an Threads ist, dass jeder einzelne unabhängig von den "
"anderen *läuft*, und zwar gleichzeitig mit ihnen. Das kann entweder nur "
"konzeptionell gleichzeitig (\"konkurrent\") oder physisch (\"parallel\") der "
"Fall sein. So oder so laufen die Threads effektiv mit einer nicht "
"synchronisierten Geschwindigkeit."

#: ../../reference/executionmodel.rst:453
msgid ""
"That non-synchronized rate means none of the process' memory is guaranteed "
"to stay consistent for the code running in any given thread.  Thus multi-"
"threaded programs must take care to coordinate access to intentionally "
"shared resources.  Likewise, they must take care to be absolutely diligent "
"about not accessing any *other* resources in multiple threads; otherwise two "
"threads running at the same time might accidentally interfere with each "
"other's use of some shared data.  All this is true for both Python programs "
"and the Python runtime."
msgstr ""
"Diese nicht synchronisierte Rate bedeutet, dass für den in einem bestimmten "
"Thread ausgeführten Code nicht garantiert werden kann, dass der Speicher des "
"Prozesses konsistent bleibt. Daher müssen Multithread-Programme darauf "
"achten, den Zugriff auf bewusst gemeinsam genutzte Ressourcen zu "
"koordinieren.  Ebenso müssen sie unbedingt darauf achten, in mehreren "
"Threads nicht auf *andere* Ressourcen zuzugreifen; andernfalls könnten sich "
"zwei gleichzeitig laufende Threads versehentlich bei der Nutzung gemeinsamer "
"Daten gegenseitig stören.  All dies gilt sowohl für Python-Programme als "
"auch für die Python-Laufzeitumgebung."

#: ../../reference/executionmodel.rst:463
msgid ""
"The cost of this broad, unstructured requirement is the tradeoff for the "
"kind of raw concurrency that threads provide.  The alternative to the "
"required discipline generally means dealing with non-deterministic bugs and "
"data corruption."
msgstr ""
"Der Preis für diese weit gefasste, unstrukturierte Anforderung ist der "
"Kompromiss, den man für die Art von roher Parallelität eingehen muss, die "
"Threads bieten. Die Alternative zu der erforderlichen Disziplin bedeutet in "
"der Regel, sich mit nichtdeterministischen Fehlern und Datenbeschädigungen "
"auseinandersetzen zu müssen."

#: ../../reference/executionmodel.rst:469
msgid "Python Runtime Model"
msgstr "Python-Laufzeitmodell"

#: ../../reference/executionmodel.rst:471
msgid ""
"The same conceptual layers apply to each Python program, with some extra "
"data layers specific to Python:"
msgstr ""
"Für jedes Python-Programm gelten dieselben konzeptionellen Ebenen, ergänzt "
"durch einige zusätzliche, für Python spezifische Datenschichten:"

#: ../../reference/executionmodel.rst:476
msgid "Python global runtime (*state*)"
msgstr "Globale Laufzeitumgebung von Python (*state*)"

#: ../../reference/executionmodel.rst:477
msgid "Python interpreter (*state*)"
msgstr "Python-Interpreter (*Zustand*)"

#: ../../reference/executionmodel.rst:478
msgid "**thread** (runs Python bytecode and \"C-API\")"
msgstr "**Thread** (führt Python-Bytecode und \"C-API\" aus)"

#: ../../reference/executionmodel.rst:479
msgid "Python thread *state*"
msgstr "Python-Thread-*Zustand*"

#: ../../reference/executionmodel.rst:481
msgid ""
"At the conceptual level: when a Python program starts, it looks exactly like "
"that diagram, with one of each.  The runtime may grow to include multiple "
"interpreters, and each interpreter may grow to include multiple thread "
"states."
msgstr ""
"Auf konzeptioneller Ebene: Wenn ein Python-Programm startet, sieht es genau "
"wie in diesem Diagramm aus, wobei jeweils nur ein Element vorhanden ist. Die "
"Laufzeitumgebung kann sich so weit ausdehnen, dass sie mehrere Interpreter "
"umfasst, und jeder Interpreter kann sich so weit ausdehnen, dass er mehrere "
"Thread-Zustände umfasst."

#: ../../reference/executionmodel.rst:488
msgid ""
"A Python implementation won't necessarily implement the runtime layers "
"distinctly or even concretely.  The only exception is places where distinct "
"layers are directly specified or exposed to users, like through the :mod:"
"`threading` module."
msgstr ""
"Eine Python-Implementierung muss die Laufzeitschichten nicht unbedingt klar "
"voneinander abgegrenzt oder gar konkret implementieren. Die einzige Ausnahme "
"bilden Stellen, an denen bestimmte Schichten direkt festgelegt oder den "
"Benutzern zugänglich gemacht werden, beispielsweise über das Modul :mod:"
"`threading` ."

#: ../../reference/executionmodel.rst:495
msgid ""
"The initial interpreter is typically called the \"main\" interpreter. Some "
"Python implementations, like CPython, assign special roles to the main "
"interpreter."
msgstr ""
"Der ursprüngliche Interpreter wird in der Regel als \"Haupt\"-Interpreter "
"bezeichnet. Einige Python-Implementierungen, wie beispielsweise CPython, "
"weisen dem Hauptinterpreter besondere Rollen zu."

#: ../../reference/executionmodel.rst:499
msgid ""
"Likewise, the host thread where the runtime was initialized is known as the "
"\"main\" thread.  It may be different from the process' initial thread, "
"though they are often the same.  In some cases \"main thread\" may be even "
"more specific and refer to the initial thread state. A Python runtime might "
"assign specific responsibilities to the main thread, such as handling "
"signals."
msgstr ""
"Ebenso wird der Host-Thread, in dem die Laufzeitumgebung initialisiert "
"wurde, als \"Hauptthread\" bezeichnet. Er kann sich vom Start-Thread des "
"Prozesses unterscheiden, obwohl beide oft identisch sind. In manchen Fällen "
"kann der Begriff „Hauptthread“ sogar noch spezifischer sein und sich auf den "
"Zustand des Start-Threads beziehen. Eine Python-Laufzeitumgebung kann dem "
"Hauptthread bestimmte Aufgaben zuweisen, wie beispielsweise die Verarbeitung "
"von Signalen."

#: ../../reference/executionmodel.rst:506
msgid ""
"As a whole, the Python runtime consists of the global runtime state, "
"interpreters, and thread states.  The runtime ensures all that state stays "
"consistent over its lifetime, particularly when used with multiple host "
"threads."
msgstr ""
"Insgesamt besteht die Python-Laufzeitumgebung aus dem globalen "
"Laufzeitzustand, den Interpretern und den Thread-Zuständen. Die "
"Laufzeitumgebung stellt sicher, dass all diese Zustände während ihrer "
"gesamten Lebensdauer konsistent bleiben, insbesondere bei der Verwendung mit "
"mehreren Host-Threads."

#: ../../reference/executionmodel.rst:511
msgid ""
"The global runtime, at the conceptual level, is just a set of interpreters.  "
"While those interpreters are otherwise isolated and independent from one "
"another, they may share some data or other resources.  The runtime is "
"responsible for managing these global resources safely.  The actual nature "
"and management of these resources is implementation-specific.  Ultimately, "
"the external utility of the global runtime is limited to managing "
"interpreters."
msgstr ""
"Die globale Laufzeitumgebung ist auf konzeptioneller Ebene lediglich eine "
"Sammlung von Interpretern. Obwohl diese Interpreter ansonsten voneinander "
"isoliert und unabhängig sind, können sie bestimmte Daten oder andere "
"Ressourcen gemeinsam nutzen. Die Laufzeitumgebung ist dafür verantwortlich, "
"diese globalen Ressourcen sicher zu verwalten. Die konkrete Ausgestaltung "
"und Verwaltung dieser Ressourcen ist implementierungsspezifisch.  "
"Letztendlich beschränkt sich der externe Nutzen der globalen "
"Laufzeitumgebung auf die Verwaltung von Interpretern."

#: ../../reference/executionmodel.rst:519
msgid ""
"In contrast, an \"interpreter\" is conceptually what we would normally think "
"of as the (full-featured) \"Python runtime\".  When machine code executing "
"in a host thread interacts with the Python runtime, it calls into Python in "
"the context of a specific interpreter."
msgstr ""
"Im Gegensatz dazu entspricht ein \"Interpreter\" konzeptionell dem, was wir "
"normalerweise unter der (voll funktionsfähigen) \"Python-Laufzeitumgebung\" "
"verstehen. Wenn Maschinencode, der in einem Host-Thread ausgeführt wird, mit "
"der Python-Laufzeitumgebung interagiert, ruft er Python im Kontext eines "
"bestimmten Interpreters auf."

#: ../../reference/executionmodel.rst:526
msgid ""
"The term \"interpreter\" here is not the same as the \"bytecode "
"interpreter\", which is what regularly runs in threads, executing compiled "
"Python code."
msgstr ""
"Der Begriff \"Interpreter\" ist hier nicht mit dem \"Bytecode-Interpreter\" "
"gleichzusetzen, der üblicherweise in Threads läuft und kompilierten Python-"
"Code ausführt."

#: ../../reference/executionmodel.rst:530
msgid ""
"In an ideal world, \"Python runtime\" would refer to what we currently call "
"\"interpreter\".  However, it's been called \"interpreter\" at least since "
"introduced in 1997 (`CPython:a027efa5b`_)."
msgstr ""
"In einer idealen Welt würde sich der Begriff \"Python-Laufzeitumgebung\" auf "
"das beziehen, was wir derzeit als \"Interpreter\" bezeichnen. Allerdings "
"wird er bereits seit seiner Einführung im Jahr 1997 als \"Interpreter\" "
"bezeichnet (`CPython:a027efa5b`_)."

#: ../../reference/executionmodel.rst:536
msgid ""
"Each interpreter completely encapsulates all of the non-process-global, non-"
"thread-specific state needed for the Python runtime to work. Notably, the "
"interpreter's state persists between uses.  It includes fundamental data "
"like :data:`sys.modules`.  The runtime ensures multiple threads using the "
"same interpreter will safely share it between them."
msgstr ""
"Jeder Interpreter kapselt den gesamten nicht prozessglobalen und nicht "
"threadspezifischen Zustand vollständig ein, der für den Betrieb der Python-"
"Laufzeitumgebung erforderlich ist. Insbesondere bleibt der Zustand des "
"Interpreters zwischen den einzelnen Verwendungen erhalten. Er umfasst "
"grundlegende Daten wie :data:`sys.modules`. Die Laufzeitumgebung stellt "
"sicher, dass mehrere Threads, die denselben Interpreter verwenden, diesen "
"sicher untereinander gemeinsam nutzen können."

#: ../../reference/executionmodel.rst:543
msgid ""
"A Python implementation may support using multiple interpreters at the same "
"time in the same process.  They are independent and isolated from one "
"another.  For example, each interpreter has its own :data:`sys.modules`."
msgstr ""
"Eine Python-Implementierung kann die gleichzeitige Nutzung mehrerer "
"Interpreter innerhalb desselben Prozesses unterstützen. Diese sind "
"voneinander unabhängig und isoliert. So verfügt beispielsweise jeder "
"Interpreter über eine eigene Instanz von :data:`sys.modules`."

#: ../../reference/executionmodel.rst:548
msgid ""
"For thread-specific runtime state, each interpreter has a set of thread "
"states, which it manages, in the same way the global runtime contains a set "
"of interpreters.  It can have thread states for as many host threads as it "
"needs.  It may even have multiple thread states for the same host thread, "
"though that isn't as common."
msgstr ""
"Für den threadspezifischen Laufzeitstatus verfügt jeder Interpreter über "
"eine Reihe von Thread-Zuständen, die er verwaltet – genauso wie die globale "
"Laufzeitumgebung eine Reihe von Interpretern enthält. Er kann Thread-"
"Zustände für so viele Host-Threads haben, wie er benötigt. Es kann sogar "
"vorkommen, dass er mehrere Thread-Zustände für denselben Host-Thread hat, "
"auch wenn dies nicht allzu häufig vorkommt."

#: ../../reference/executionmodel.rst:554
msgid ""
"Each thread state, conceptually, has all the thread-specific runtime data an "
"interpreter needs to operate in one host thread.  The thread state includes "
"the current raised exception and the thread's Python call stack.  It may "
"include other thread-specific resources."
msgstr ""
"Konzeptionell enthält jeder Thread-Zustand alle threadspezifischen "
"Laufzeitdaten, die ein Interpreter benötigt, um in einem Host-Thread zu "
"arbeiten. Der Thread-Zustand umfasst die aktuell ausgelöste Ausnahme und den "
"Python-Aufrufstapel des Threads. Er kann auch weitere threadspezifische "
"Ressourcen enthalten."

#: ../../reference/executionmodel.rst:561
msgid ""
"The term \"Python thread\" can sometimes refer to a thread state, but "
"normally it means a thread created using the :mod:`threading` module."
msgstr ""
"Der Begriff \"Python-Thread\" kann sich manchmal auf einen Thread-Zustand "
"beziehen, bezeichnet jedoch in der Regel einen Thread, der mithilfe des "
"Moduls :mod:`threading` erstellt wurde."

#: ../../reference/executionmodel.rst:564
msgid ""
"Each thread state, over its lifetime, is always tied to exactly one "
"interpreter and exactly one host thread.  It will only ever be used in that "
"thread and with that interpreter."
msgstr ""
"Jeder Thread-Zustand ist während seiner gesamten Lebensdauer stets an genau "
"einen Interpreter und genau einen Host-Thread gebunden. Er wird "
"ausschließlich in diesem Thread und mit diesem Interpreter verwendet."

#: ../../reference/executionmodel.rst:568
msgid ""
"Multiple thread states may be tied to the same host thread, whether for "
"different interpreters or even the same interpreter.  However, for any given "
"host thread, only one of the thread states tied to it can be used by the "
"thread at a time."
msgstr ""
"Einem Host-Thread können mehrere Thread-Zustände zugeordnet sein, sei es für "
"verschiedene Interpreter oder sogar für denselben Interpreter. Für einen "
"bestimmten Host-Thread kann jedoch jeweils nur einer der ihm zugeordneten "
"Thread-Zustände von diesem Thread verwendet werden."

#: ../../reference/executionmodel.rst:573
msgid ""
"Thread states are isolated and independent from one another and don't share "
"any data, except for possibly sharing an interpreter and objects or other "
"resources belonging to that interpreter."
msgstr ""
"Die Zustände der Threads sind voneinander isoliert und unabhängig und "
"tauschen keine Daten aus, abgesehen von der möglichen gemeinsamen Nutzung "
"eines Interpreters sowie von Objekten oder anderen Ressourcen, die zu diesem "
"Interpreter gehören."

#: ../../reference/executionmodel.rst:577
msgid ""
"Once a program is running, new Python threads can be created using the :mod:"
"`threading` module (on platforms and Python implementations that support "
"threads).  Additional processes can be created using the :mod:`os`, :mod:"
"`subprocess`, and :mod:`multiprocessing` modules. Interpreters can be "
"created and used with the :mod:`~concurrent.interpreters` module.  "
"Coroutines (async) can be run using :mod:`asyncio` in each interpreter, "
"typically only in a single thread (often the main thread)."
msgstr ""
"Sobald ein Programm läuft, können mithilfe des Moduls :mod:`threading` neue "
"Python-Threads erstellt werden (auf Plattformen und in Python-"
"Implementierungen, die Threads unterstützen).  Zusätzliche Prozesse können "
"mithilfe der Module :mod:`os`, :mod:`subprocess` und :mod:`multiprocessing` "
"erstellt werden. Interpreter können mit dem Modul :mod:`~concurrent."
"interpreters` erstellt und verwendet werden. Coroutinen (async) können "
"mithilfe von :mod:`asyncio` in jedem Interpreter ausgeführt werden, in der "
"Regel nur in einem einzigen Thread (häufig dem Hauptthread)."

#: ../../reference/executionmodel.rst:588
msgid "Footnotes"
msgstr "Fußnoten"

#: ../../reference/executionmodel.rst:589
msgid ""
"This limitation occurs because the code that is executed by these operations "
"is not available at the time the module is compiled."
msgstr ""
"Diese Einschränkung ergibt sich daraus, dass der Code, der durch diese "
"Operationen ausgeführt wird, zum Zeitpunkt der Kompilierung des Moduls noch "
"nicht verfügbar ist."

#: ../../reference/executionmodel.rst:8
msgid "execution model"
msgstr "execution model"

#: ../../reference/executionmodel.rst:8
msgid "code"
msgstr "code"

#: ../../reference/executionmodel.rst:8 ../../reference/executionmodel.rst:17
msgid "block"
msgstr "block"

#: ../../reference/executionmodel.rst:31 ../../reference/executionmodel.rst:299
msgid "execution"
msgstr "execution"

#: ../../reference/executionmodel.rst:31
msgid "frame"
msgstr "frame"

#: ../../reference/executionmodel.rst:42
msgid "namespace"
msgstr "namespace"

#: ../../reference/executionmodel.rst:42 ../../reference/executionmodel.rst:103
msgid "scope"
msgstr "scope"

#: ../../reference/executionmodel.rst:51
msgid "name"
msgstr "name"

#: ../../reference/executionmodel.rst:51
msgid "binding"
msgstr "binding"

#: ../../reference/executionmodel.rst:57
msgid "from"
msgstr "from"

#: ../../reference/executionmodel.rst:57
msgid "import statement"
msgstr "import statement"

#: ../../reference/executionmodel.rst:87
msgid "free"
msgstr "free"

#: ../../reference/executionmodel.rst:87
msgid "variable"
msgstr "variable"

#: ../../reference/executionmodel.rst:111
msgid "environment"
msgstr "environment"

#: ../../reference/executionmodel.rst:117
msgid "NameError (built-in exception)"
msgstr "NameError (built-in exception)"

#: ../../reference/executionmodel.rst:117
msgid "UnboundLocalError"
msgstr "UnboundLocalError"

#: ../../reference/executionmodel.rst:158
msgid "module"
msgstr "module"

#: ../../reference/executionmodel.rst:158
msgid "__main__"
msgstr "__main__"

#: ../../reference/executionmodel.rst:299
msgid "restricted"
msgstr "restricted"

#: ../../reference/executionmodel.rst:349
msgid "exception"
msgstr "exception"

#: ../../reference/executionmodel.rst:351
msgid "raise an exception"
msgstr "raise an exception"

#: ../../reference/executionmodel.rst:351
msgid "handle an exception"
msgstr "handle an exception"

#: ../../reference/executionmodel.rst:351
msgid "exception handler"
msgstr "exception handler"

#: ../../reference/executionmodel.rst:351
msgid "errors"
msgstr "errors"

#: ../../reference/executionmodel.rst:351
msgid "error handling"
msgstr "error handling"

#: ../../reference/executionmodel.rst:372
msgid "termination model"
msgstr "termination model"

#: ../../reference/executionmodel.rst:379
msgid "SystemExit (built-in exception)"
msgstr "SystemExit (built-in exception)"