# 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.15\n"

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

"POT-Creation-Date: 2026-09-14 20:17+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