# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# python-doc bot, 2025

# Swen Bachmann, 2026

#

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: 2026-10-13 22:45+0200\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: German (https://github.com/python/python-docs-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/compound_stmts.rst:5

msgid "Compound statements"

msgstr "Zusammengesetzte Anweisungen"

#: ../../reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

"Zusammengesetzte Anweisungen enthalten (Gruppen von) anderen Anweisungen. "

"Sie beeinflussen oder steuern in gewisser Weise die Ausführung dieser "

"anderen Anweisungen. Im Allgemeinen erstrecken sich zusammengesetzte "

"Anweisungen über mehrere Zeilen, obwohl in einfachen Fällen eine gesamte "

"zusammengesetzte Anweisung auch in einer einzigen Zeile enthalten sein kann."

#: ../../reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

"Die Anweisungen :keyword:`if`, :keyword:`while` und :keyword:`for` "

"implementieren traditionelle Kontrollflusskonstrukte. :keyword:`try` legt "

"Ausnahmebehandler und/oder Aufräumcode für eine Gruppe von Anweisungen fest, "

"während die Anweisung :keyword:`with` die Ausführung von Initialisierungs- "

"und Finalisierungscode um einen Codeblock herum ermöglicht. Funktions- und "

"Klassendefinitionen sind syntaktisch ebenfalls zusammengesetzte Anweisungen."

#: ../../reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"Eine zusammengesetzte Anweisung besteht aus einer oder mehreren "

"\"Klauseln\". Eine Klausel besteht aus einer Überschrift und einer "

"\"Suite\". Die Klauselüberschriften einer bestimmten zusammengesetzten "

"Anweisung befinden sich alle auf derselben Einrückungsebene. Jede "

"Klauselüberschrift beginnt mit einem eindeutig identifizierenden "

"Schlüsselwort und endet mit einem Doppelpunkt. Eine Suite ist eine Gruppe "

"von Anweisungen, die von einer Klausel gesteuert werden. Eine Suite kann "

"aus einer oder mehreren durch Semikolons getrennten einfachen Anweisungen "

"bestehen, die sich in derselben Zeile wie die Überschrift befinden und auf "

"den Doppelpunkt der Überschrift folgen, oder aus einer oder mehreren "

"eingerückten Anweisungen in den folgenden Zeilen. Nur die letztgenannte "

"Form einer Suite darf verschachtelte zusammengesetzte Anweisungen enthalten. "

"Das folgende Beispiel ist unzulässig, vor allem weil unklar wäre, zu "

"welcher :keyword:`if`-Klausel eine nachfolgende :keyword:`else`-Klausel "

"gehören würde::"

#: ../../reference/compound_stmts.rst:37

msgid "if test1: if test2: print(x)"

msgstr "if test1: if test2: print(x)"

#: ../../reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"Beachte außerdem, dass das Semikolon in diesem Zusammenhang eine stärkere "

"Bindung hat als der Doppelpunkt, sodass im folgenden Beispiel entweder alle "

"oder gar keine der :func:`print`-Aufrufe ausgeführt werden::"

#: ../../reference/compound_stmts.rst:43

msgid "if x < y < z: print(x); print(y); print(z)"

msgstr "if x < y < z: print(x); print(y); print(z)"

#: ../../reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "Zusammenfassend lässt sich sagen:"

#: ../../reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

"Beachte, dass Anweisungen immer mit einem ``NEWLINE`` enden, auf das "

"möglicherweise ein ``DEDENT`` folgt. Beachte außerdem, dass optionale "

"Fortsetzungsklauseln immer mit einem Schlüsselwort beginnen, das keine "

"Anweisung einleiten darf, sodass keine Mehrdeutigkeiten entstehen (das "

"Problem der dangling :keyword:`else` wird in Python dadurch gelöst, dass "

"verschachtelte :keyword:`if`-Anweisungen eingerückt sein müssen)."

#: ../../reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

"Zur besseren Übersichtlichkeit werden die Grammatikregeln in den folgenden "

"Abschnitten so formatiert, dass jeder Satzteil in einer eigenen Zeile steht."

#: ../../reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr "Die :keyword:`!if` Anweisung"

#: ../../reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr ""

"Die Anweisung :keyword:`if` wird für die bedingte Ausführung verwendet:"

#: ../../reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

"Es wählt genau eine der Suiten aus, indem es die Ausdrücke nacheinander "

"auswertet, bis einer als wahr erkannt wird (siehe Abschnitt :ref:`booleans` "

"für die Definition von wahr und falsch). Anschließend wird diese Suite "

"ausgeführt (und kein anderer Teil der Anweisung :keyword:`if` wird "

"ausgeführt oder ausgewertet). Sind alle Ausdrücke falsch, wird die Suite der "

"Klausel :keyword:`else` ausgeführt, sofern vorhanden."

#: ../../reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr "Die Erklärung der :keyword:`!while` ."

#: ../../reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

"Die Anweisung :keyword:`while` wird verwendet, um einen Befehl so lange "

"wiederholt auszuführen, wie ein Ausdruck wahr ist:"

#: ../../reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

"Dadurch wird der Ausdruck wiederholt geprüft. Ist er wahr, wird die erste "

"Suite ausgeführt. Ist der Ausdruck falsch (was bereits bei der ersten "

"Prüfung der Fall sein kann), wird die Suite der Klausel :keyword:`!else` . – "

"sofern vorhanden – ausgeführt, und die Schleife wird beendet."

#: ../../reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

"Eine in der ersten Suite ausgeführte Anweisung vom Typ :keyword:`break` "

"beendet die Schleife, ohne die Suite der Klausel :keyword:`!else` "

"auszuführen. Eine in der ersten Suite ausgeführte Anweisung vom Typ :keyword:"

"`continue` überspringt den Rest der Suite und kehrt zur Überprüfung des "

"Ausdrucks zurück."

#: ../../reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr "Die :keyword:`!for` Anweisung"

#: ../../reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

"Die Anweisung :keyword:`for` wird verwendet, um die Elemente einer Sequenz "

"(wie beispielsweise einer Zeichenkette, eines Tupels oder einer Liste) oder "

"eines anderen iterierbaren Objekts nacheinander durchzugehen:"

#: ../../reference/compound_stmts.rst:160

msgid ""

"The :token:`~python-grammar:starred_expression_list` expression is evaluated "

"once; it should yield an :term:`iterable` object. An :term:`iterator` is "

"created for that iterable. The first item provided by the iterator is then "

"assigned to the target list using the standard rules for assignments (see :"

"ref:`assignment`), and the suite is executed. This repeats for each item "

"provided by the iterator. When the iterator is :term:`exhausted`, the suite "

"in the :keyword:`!else` clause, if present, is executed, and the loop "

"terminates."

msgstr ""

"Der Ausdruck :token:`~python-grammar:starred_expression_list` wird einmal "

"ausgewertet. Er sollte ein :term:`iterierbares <iterable>` Objekt liefern. "

"Für dieses iterierbare Objekt wird ein :term:`Iterator <iterator>` erzeugt. "

"Das erste vom Iterator gelieferte Element wird dann nach den üblichen Regeln "

"für Zuweisungen (siehe :ref:`assignment`) der Zielliste zugewiesen, und die "

"Suite wird ausgeführt. Das wiederholt sich für jedes Element, das der "

"Iterator liefert. Ist der Iterator :term:`erschöpft <exhausted>`, wird die "

"Suite der :keyword:`!else`-Klausel ausgeführt, sofern vorhanden, und die "

"Schleife endet."

#: ../../reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

"Eine in der ersten Suite ausgeführte Anweisung :keyword:`break` beendet die "

"Schleife, ohne die Suite der Klausel :keyword:`!else` auszuführen. Eine in "

"der ersten Suite ausgeführte Anweisung :keyword:`continue` überspringt den "

"Rest der Suite und fährt mit dem nächsten Element fort oder, falls kein "

"nächstes Element vorhanden ist, mit der Klausel :keyword:`!else` ."

#: ../../reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"Die for-Schleife führt Zuweisungen an die Variablen in der Zielliste durch. "

"Dadurch werden alle vorherigen Zuweisungen an diese Variablen überschrieben, "

"einschließlich derer, die im Rahmen der for-Schleife vorgenommen wurden::"

#: ../../reference/compound_stmts.rst:183

msgid ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

msgstr ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # Dies hat keinen Einfluss auf die for-Schleife,\n"

" # da i durch den nächsten\n"

" # Index im Bereich überschrieben wird"

#: ../../reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

"Die Namen in der Zielliste werden nach Beendigung der Schleife nicht "

"gelöscht, aber wenn die Folge leer ist, wurden sie von der Schleife gar "

"nicht erst zugewiesen. Hinweis: Der integrierte Typ :func:`range` stellt "

"unveränderliche arithmetische Folgen von Ganzzahlen dar. Wenn man "

"beispielsweise nacheinander ``range(3)`` durchläuft, erhält man nacheinander "

"0, 1 und dann 2."

#: ../../reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr "Elemente mit Sternchen sind nun in der Ausdrucksliste zulässig."

#: ../../reference/compound_stmts.rst:205

msgid "The :keyword:`!try` statement"

msgstr "Die :keyword:`!try` Anweisung"

#: ../../reference/compound_stmts.rst:215

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

"Die Anweisung :keyword:`!try` legt Ausnahmebehandler und/oder Aufräumcode "

"für eine Gruppe von Anweisungen fest:"

#: ../../reference/compound_stmts.rst:231

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

"Weitere Informationen zu Ausnahmen findest du im Abschnitt :ref:"

"`exceptions`, und Informationen zur Verwendung der Anweisung :keyword:"

"`raise` zum Auslösen von Ausnahmen findest du im Abschnitt :ref:`raise` ."

#: ../../reference/compound_stmts.rst:235

msgid ""

"Support for optionally dropping grouping parentheses when using multiple "

"exception types. See :pep:`758`."

msgstr ""

"Unterstützung für das optionale Weglassen von Gruppierungsklammern bei der "

"Verwendung mehrerer Ausnahmetypen. Siehe :pep:`758`."

#: ../../reference/compound_stmts.rst:241

msgid ":keyword:`!except` clause"

msgstr ":keyword:`!except` Klausel"

#: ../../reference/compound_stmts.rst:243

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception handler "

"is executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the :keyword:`!"

"except` clauses in turn until one is found that matches the exception. An "

"expression-less :keyword:`!except` clause, if present, must be last; it "

"matches any exception."

msgstr ""

"Die Klausel(n) :keyword:`!except` legen einen oder mehrere Ausnahmebehandler "

"fest. Tritt in der Klausel :keyword:`try` keine Ausnahme auf, wird kein "

"Ausnahmebehandler ausgeführt. Tritt in der Suite :keyword:`!try` eine "

"Ausnahme auf, wird eine Suche nach einem Ausnahmebehandler gestartet. Bei "

"dieser Suche werden die Klauseln :keyword:`!except` nacheinander "

"durchgesehen, bis eine gefunden wird, die der Ausnahme entspricht. Eine "

"ausdruckslose :keyword:`!except`-Klausel muss, sofern vorhanden, an letzter "

"Stelle stehen. Sie passt auf jede Ausnahme."

#: ../../reference/compound_stmts.rst:251

msgid ""

"For an :keyword:`!except` clause with an expression, the expression must "

"evaluate to an exception type or a tuple of exception types. Parentheses can "

"be dropped if multiple exception types are provided and the ``as`` clause is "

"not used. The raised exception matches an :keyword:`!except` clause whose "

"expression evaluates to the class or a :term:`non-virtual base class "

"<abstract base class>` of the exception object, or to a tuple that contains "

"such a class."

msgstr ""

"Bei einer :keyword:`!except`-Klausel mit einem Ausdruck muss der Ausdruck zu "

"einem Ausnahmetyp oder einem Tupel von Ausnahmetypen ausgewertet werden. "

"Klammern können weggelassen werden, wenn mehrere Ausnahmetypen angegeben "

"werden und die Klausel ``as`` nicht verwendet wird. Die ausgelöste Ausnahme "

"entspricht einer Klausel :keyword:`!except`, deren Ausdruck zu der Klasse "

"oder einer :term:`nicht-virtuellen Basisklasse <abstract base class>` des "

"Ausnahmeobjekts oder zu einem Tupel, das eine solche Klasse enthält, "

"ausgewertet wird."

#: ../../reference/compound_stmts.rst:258

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation "

"stack. [#]_"

msgstr ""

"Wenn keine :keyword:`!except`-Klausel mit der Ausnahme übereinstimmt, wird "

"die Suche nach einem Ausnahmehandler im umgebenden Code und auf dem "

"Aufrufstapel fortgesetzt. [#]_"

#: ../../reference/compound_stmts.rst:262

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except` "

"clause raises an exception, the original search for a handler is canceled "

"and a search starts for the new exception in the surrounding code and on the "

"call stack (it is treated as if the entire :keyword:`try` statement raised "

"the exception)."

msgstr ""

"Wenn bei der Auswertung eines Ausdrucks im Kopf einer :keyword:`!except`-"

"Klausel eine Ausnahme ausgelöst wird, wird die ursprüngliche Suche nach "

"einem Handler abgebrochen und es wird im umgebenden Code sowie auf dem "

"Aufrufstapel nach einem Handler für die neue Ausnahme gesucht (es wird so "

"behandelt, als hätte die gesamte :keyword:`try`-Anweisung die Ausnahme "

"ausgelöst)."

#: ../../reference/compound_stmts.rst:270

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that :"

"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "

"suite is executed. All :keyword:`!except` clauses must have an executable "

"block. When the end of this block is reached, execution continues normally "

"after the entire :keyword:`try` statement. (This means that if two nested "

"handlers exist for the same exception, and the exception occurs in the :"

"keyword:`!try` clause of the inner handler, the outer handler will not "

"handle the exception.)"

msgstr ""

"Wird eine passende :keyword:`!except`-Klausel gefunden, wird die Ausnahme "

"dem Ziel zugewiesen, das nach dem Schlüsselwort :keyword:`!as` in dieser :"

"keyword:`!except`-Klausel angegeben ist, sofern vorhanden, und die Suite "

"der :keyword:`!except`-Klausel wird ausgeführt. Alle :keyword:`!except`-"

"Klauseln müssen einen ausführbaren Block enthalten. Wenn das Ende dieses "

"Blocks erreicht ist, wird die Ausführung nach der gesamten :keyword:`try`-"

"Anweisung normal fortgesetzt. (Das bedeutet: Wenn zwei verschachtelte "

"Handler für dieselbe Ausnahme existieren und die Ausnahme in der :keyword:`!"

"try`-Klausel des inneren Handlers auftritt, wird die Ausnahme vom äußeren "

"Handler nicht behandelt.)"

#: ../../reference/compound_stmts.rst:281

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the :keyword:`!except` clause. This is as if::"

msgstr ""

"Wenn eine Ausnahme mit ``as target`` zugewiesen wurde, wird sie am Ende der :"

"keyword:`!except`-Klausel zurückgesetzt. Dies entspricht folgendem Code::"

#: ../../reference/compound_stmts.rst:284

msgid ""

"except E as N:\n"

" foo"

msgstr ""

"except E as N:\n"

" foo"

#: ../../reference/compound_stmts.rst:287

msgid "was translated to::"

msgstr "wurde übersetzt in:"

#: ../../reference/compound_stmts.rst:289

msgid ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

msgstr ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

#: ../../reference/compound_stmts.rst:295

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the :keyword:`!except` clause. Exceptions are cleared "

"because with the traceback attached to them, they form a reference cycle "

"with the stack frame, keeping all locals in that frame alive until the next "

"garbage collection occurs."

msgstr ""

"Das bedeutet, dass der Ausnahme ein anderer Name zugewiesen werden muss, "

"damit nach der :keyword:`!except`-Klausel auf sie verwiesen werden kann. "

"Ausnahmen werden gelöscht, da sie mit dem ihnen beigefügten Traceback einen "

"Referenzzyklus mit dem Stack-Frame bilden, wodurch alle lokalen Variablen in "

"diesem Frame so lange erhalten bleiben, bis die nächste Garbage Collection "

"stattfindet."

#: ../../reference/compound_stmts.rst:305

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is "

"stored in the :mod:`sys` module, where it can be accessed from within the "

"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "

"leaving an exception handler, the exception stored in the :mod:`sys` module "

"is reset to its previous value::"

msgstr ""

"Bevor die Suite einer :keyword:`!except`-Klausel ausgeführt wird, wird die "

"Ausnahme im Modul :mod:`sys` gespeichert, wo im Körper der :keyword:`!"

"except`-Klausel durch den Aufruf von :func:`sys.exception` darauf "

"zugegriffen werden kann. Beim Verlassen eines Ausnahmebehandlers wird die im "

"Modul :mod:`sys` gespeicherte Ausnahme auf ihren vorherigen Wert "

"zurückgesetzt::"

#: ../../reference/compound_stmts.rst:311

msgid ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

msgstr ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

#: ../../reference/compound_stmts.rst:336

msgid ":keyword:`!except*` clause"

msgstr ":keyword:`!except*` Klausel"

#: ../../reference/compound_stmts.rst:338

msgid ""

"The :keyword:`!except*` clause(s) specify one or more handlers for groups of "

"exceptions (:exc:`BaseExceptionGroup` instances). A :keyword:`try` statement "

"can have either :keyword:`except` or :keyword:`!except*` clauses, but not "

"both. The exception type for matching is mandatory in the case of :keyword:`!"

"except*`, so ``except*:`` is a syntax error. The type is interpreted as in "

"the case of :keyword:`!except`, but matching is performed on the exceptions "

"contained in the group that is being handled. A :exc:`TypeError` is raised "

"if a matching type is a subclass of :exc:`!BaseExceptionGroup`, because that "

"would have ambiguous semantics."

msgstr ""

"Die Klausel(n) :keyword:`!except*` legen einen oder mehrere Handler für "

"Gruppen von Ausnahmen (Instanzen von :exc:`BaseExceptionGroup`) fest. Eine "

"Anweisung :keyword:`try` kann entweder Klauseln vom Typ :keyword:`except` "

"oder :keyword:`!except*` enthalten, jedoch nicht beide. Der Ausnahmetyp für "

"den Abgleich ist im Fall von :keyword:`!except*` obligatorisch, daher ist "

"``except*:`` ein Syntaxfehler. Der Typ wird wie im Fall von :keyword:`!"

"except` interpretiert, der Abgleich erfolgt jedoch anhand der Ausnahmen, die "

"in der gerade behandelten Gruppe enthalten sind. Eine :exc:`TypeError` wird "

"ausgelöst, wenn ein übereinstimmender Typ eine Unterklasse von :exc:`!"

"BaseExceptionGroup` ist, da dies zu einer mehrdeutigen Semantik führen würde."

#: ../../reference/compound_stmts.rst:348

msgid ""

"When an exception group is raised in the try block, each :keyword:`!except*` "

"clause splits (see :meth:`~BaseExceptionGroup.split`) it into the subgroups "

"of matching and non-matching exceptions. If the matching subgroup is not "

"empty, it becomes the handled exception (the value returned from :func:`sys."

"exception`) and assigned to the target of the :keyword:`!except*` clause (if "

"there is one). Then, the body of the :keyword:`!except*` clause executes. If "

"the non-matching subgroup is not empty, it is processed by the next :keyword:"

"`!except*` in the same manner. This continues until all exceptions in the "

"group have been matched, or the last :keyword:`!except*` clause has run."

msgstr ""

"Wenn im \"try\"-Block eine Ausnahmegruppe ausgelöst wird, teilt jede :"

"keyword:`!except*`-Klausel (siehe :meth:`~BaseExceptionGroup.split`) diese "

"in die Untergruppen der passenden und der nicht passenden Ausnahmen auf. Ist "

"die Untergruppe der passenden Ausnahmen nicht leer, wird sie zur behandelten "

"Ausnahme (dem von :func:`sys.exception` zurückgegebenen Wert) und dem Ziel "

"der :keyword:`!except*`-Klausel zugewiesen (sofern vorhanden). Anschließend "

"wird der Hauptteil der Klausel :keyword:`!except*` ausgeführt. Ist die "

"Untergruppe der nicht übereinstimmenden Ausnahmen nicht leer, wird sie von "

"der nächsten Klausel :keyword:`!except*` auf dieselbe Weise verarbeitet. "

"Dies wird so lange fortgesetzt, bis alle Ausnahmen in der Gruppe abgeglichen "

"wurden oder die letzte Klausel :keyword:`!except*` ausgeführt wurde."

#: ../../reference/compound_stmts.rst:358

msgid ""

"After all :keyword:`!except*` clauses execute, the group of unhandled "

"exceptions is merged with any exceptions that were raised or re-raised from "

"within :keyword:`!except*` clauses. This merged exception group propagates "

"on::"

msgstr ""

"Nachdem alle :keyword:`!except*`-Klauseln ausgeführt wurden, wird die Gruppe "

"der nicht behandelten Ausnahmen mit allen Ausnahmen zusammengeführt, die "

"innerhalb von :keyword:`!except*`-Klauseln ausgelöst oder erneut ausgelöst "

"wurden. Diese zusammengeführte Ausnahmegruppe wird weitergegeben an::"

#: ../../reference/compound_stmts.rst:362

msgid ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<doctest default[0]>\", line 2, in <module>\n"

" | raise ExceptionGroup(\"eg\",\n"

" | [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

" | ExceptionGroup: eg (1 sub-exception)\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

msgstr ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<doctest default[0]>\", line 2, in <module>\n"

" | raise ExceptionGroup(\"eg\",\n"

" | [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

" | ExceptionGroup: eg (1 sub-exception)\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

#: ../../reference/compound_stmts.rst:381

msgid ""

"If the exception raised from the :keyword:`try` block is not an exception "

"group and its type matches one of the :keyword:`!except*` clauses, it is "

"caught and wrapped by an exception group with an empty message string. This "

"ensures that the type of the target ``e`` is consistently :exc:"

"`BaseExceptionGroup`::"

msgstr ""

"Wenn die im Block :keyword:`try` ausgelöste Ausnahme keine Ausnahmegruppe "

"ist und ihr Typ mit einer der Klauseln :keyword:`!except*` übereinstimmt, "

"wird sie abgefangen und von einer Ausnahmegruppe mit einer leeren "

"Meldungszeichenfolge umschlossen. Dadurch wird sichergestellt, dass der Typ "

"des Ziels ``e`` durchgehend :exc:`BaseExceptionGroup` lautet ::"

#: ../../reference/compound_stmts.rst:386

msgid ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError(),))"

msgstr ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError(),))"

#: ../../reference/compound_stmts.rst:393

msgid ""

":keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in "

"an :keyword:`!except*` clause."

msgstr ""

":keyword:`break`, :keyword:`continue` und :keyword:`return` dürfen nicht in "

"einer :keyword:`!except*`-Klausel vorkommen."

#: ../../reference/compound_stmts.rst:406

msgid ":keyword:`!else` clause"

msgstr ":keyword:`!else` Klausel"

#: ../../reference/compound_stmts.rst:408

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

"Die optionale Klausel :keyword:`!else` wird ausgeführt, wenn der "

"Kontrollfluss die Suite :keyword:`try` verlässt, keine Ausnahme ausgelöst "

"wurde und keine Anweisung vom Typ :keyword:`return`, :keyword:`continue` "

"oder :keyword:`break` ausgeführt wurde. Ausnahmen in der Klausel :keyword:`!"

"else` werden von den vorangehenden Klauseln :keyword:`except` nicht "

"behandelt."

#: ../../reference/compound_stmts.rst:420

msgid ":keyword:`!finally` clause"

msgstr ":keyword:`!finally` Klausel"

#: ../../reference/compound_stmts.rst:422

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`else <except_else>` clauses. If an exception occurs in any of the "

"clauses and is not handled, the exception is temporarily saved. The :keyword:"

"`!finally` clause is executed. If there is a saved exception it is re-"

"raised at the end of the :keyword:`!finally` clause. If the :keyword:`!"

"finally` clause raises another exception, the saved exception is set as the "

"context of the new exception. If the :keyword:`!finally` clause executes a :"

"keyword:`return`, :keyword:`break` or :keyword:`continue` statement, the "

"saved exception is discarded. For example, this function returns 42."

msgstr ""

"Wenn :keyword:`!finally` vorhanden ist, wird damit ein \"Cleanup\"-Handler "

"angegeben. Die Klausel :keyword:`try` wird ausgeführt, einschließlich aller :"

"keyword:`except` - und :keyword:`else <except_else>`-Klauseln. Tritt in "

"einer der Klauseln eine Ausnahme auf, die nicht abgefangen wird, wird diese "

"vorübergehend gespeichert. Die Klausel :keyword:`!finally` wird ausgeführt. "

"Liegt eine gespeicherte Ausnahme vor, wird diese am Ende der Klausel :"

"keyword:`!finally` erneut ausgelöst. Löst die Klausel :keyword:`!finally` "

"eine weitere Ausnahme aus, wird die gespeicherte Ausnahme als Kontext der "

"neuen Ausnahme festgelegt. Führt die Klausel :keyword:`!finally` eine "

"Anweisung :keyword:`return`, :keyword:`break` oder :keyword:`continue` aus, "

"wird die gespeicherte Ausnahme verworfen. Diese Funktion gibt beispielsweise "

"42 zurück."

#: ../../reference/compound_stmts.rst:435

msgid ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

msgstr ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

#: ../../reference/compound_stmts.rst:443

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`!finally` clause."

msgstr ""

"Die Ausnahmedaten stehen dem Programm während der Ausführung der Anweisung :"

"keyword:`!finally` nicht zur Verfügung."

#: ../../reference/compound_stmts.rst:451

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`!finally` clause is also executed 'on the "

"way out.'"

msgstr ""

"Wenn eine Anweisung vom Typ :keyword:`return`, :keyword:`break` oder :"

"keyword:`continue` innerhalb der :keyword:`try`-Suite einer Anweisung vom "

"Typ :keyword:`!try`...\\ :keyword:`!finally` ausgeführt wird, wird die :"

"keyword:`!finally`-Klausel ebenfalls \"beim Verlassen\" ausgeführt."

#: ../../reference/compound_stmts.rst:455

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`!finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed. The following function returns "

"'finally'."

msgstr ""

"Der Rückgabewert einer Funktion wird durch die zuletzt ausgeführte :keyword:"

"`return`-Anweisung bestimmt. Da die :keyword:`!finally`-Klausel immer "

"ausgeführt wird, ist eine in der :keyword:`!finally`-Klausel ausgeführte :"

"keyword:`!return`-Anweisung immer die zuletzt ausgeführte. Die folgende "

"Funktion gibt \"finally\" zurück."

#: ../../reference/compound_stmts.rst:460

msgid ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

msgstr ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

#: ../../reference/compound_stmts.rst:468

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"Vor Python 3.8 war eine Anweisung vom Typ :keyword:`continue` in der "

"Klausel :keyword:`!finally` aufgrund eines Problems bei der Implementierung "

"unzulässig."

#: ../../reference/compound_stmts.rst:472

msgid ""

"The compiler emits a :exc:`SyntaxWarning` when a :keyword:`return`, :keyword:"

"`break` or :keyword:`continue` appears in a :keyword:`!finally` block (see :"

"pep:`765`)."

msgstr ""

"Der Compiler gibt die Fehlermeldung :exc:`SyntaxWarning` aus, wenn :keyword:"

"`return`, :keyword:`break` oder :keyword:`continue` in einem :keyword:`!"

"finally`-Block vorkommt (siehe :pep:`765`)."

#: ../../reference/compound_stmts.rst:482

msgid "The :keyword:`!with` statement"

msgstr "Die Erklärung von :keyword:`!with` ."

#: ../../reference/compound_stmts.rst:491

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

"Die Anweisung :keyword:`with` dient dazu, die Ausführung eines Blocks mit "

"Methoden zu umschließen, die von einem Kontextmanager definiert wurden "

"(siehe Abschnitt :ref:`context-managers`). Dadurch lassen sich gängige "

"Verwendungsmuster wie :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` zur bequemen Wiederverwendung kapseln."

#: ../../reference/compound_stmts.rst:501

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"Die Ausführung der Anweisung :keyword:`with` mit einem \"Element\" verläuft "

"wie folgt:"

#: ../../reference/compound_stmts.rst:503

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

"Der Kontextausdruck (der in der Datei :token:`~python-grammar:with_item` "

"angegebene Ausdruck) wird ausgewertet, um einen Kontextmanager zu erhalten."

#: ../../reference/compound_stmts.rst:506

msgid ""

"The context manager's :meth:`~object.__enter__` is loaded for later use."

msgstr ""

"Die :meth:`~object.__enter__` des Kontextmanagers wird zur späteren "

"Verwendung geladen."

#: ../../reference/compound_stmts.rst:508

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."

msgstr ""

"Die :meth:`~object.__exit__` des Kontextmanagers wird für die spätere "

"Verwendung geladen."

#: ../../reference/compound_stmts.rst:510

msgid "The context manager's :meth:`~object.__enter__` method is invoked."

msgstr ""

"Die Methode :meth:`~object.__enter__` des Kontextmanagers wird aufgerufen."

#: ../../reference/compound_stmts.rst:512

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`~object.__enter__` is assigned to it."

msgstr ""

"Wenn in der Anweisung :keyword:`with` ein Ziel angegeben wurde, wird ihm der "

"Rückgabewert von :meth:`~object.__enter__` zugewiesen."

#: ../../reference/compound_stmts.rst:517

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`~object."

"__enter__` method returns without an error, then :meth:`~object.__exit__` "

"will always be called. Thus, if an error occurs during the assignment to the "

"target list, it will be treated the same as an error occurring within the "

"suite would be. See step 7 below."

msgstr ""

"Die :keyword:`with`-Anweisung garantiert, dass :meth:`~object.__exit__` "

"stets aufgerufen wird, sofern die Methode :meth:`~object.__enter__` "

"fehlerfrei zurückkehrt. Tritt also während der Zuweisung an die Ziel-Liste "

"ein Fehler auf, so wird dieser genauso behandelt wie ein Fehler innerhalb "

"des Anweisungsblocks. Siehe Schritt 7 weiter unten."

#: ../../reference/compound_stmts.rst:523

msgid "The suite is executed."

msgstr "Die Suite wurde aufgeführt."

#: ../../reference/compound_stmts.rst:525

msgid ""

"The context manager's :meth:`~object.__exit__` method is invoked. If an "

"exception caused the suite to be exited, its type, value, and traceback are "

"passed as arguments to :meth:`~object.__exit__`. Otherwise, three :const:"

"`None` arguments are supplied."

msgstr ""

"Die Methode :meth:`~object.__exit__` des Kontextmanagers wird aufgerufen. "

"Wenn eine Ausnahme zum Abbruch der Suite geführt hat, werden deren Typ, Wert "

"und Traceback als Argumente an :meth:`~object.__exit__` übergeben. "

"Andernfalls werden drei Argumente vom Typ :const:`None` übergeben."

#: ../../reference/compound_stmts.rst:530

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`~object.__exit__` method was false, the exception is reraised. If the "

"return value was true, the exception is suppressed, and execution continues "

"with the statement following the :keyword:`with` statement."

msgstr ""

"Wurde die Suite aufgrund einer Ausnahme beendet und war der Rückgabewert der "

"Methode :meth:`~object.__exit__` `false`, wird die Ausnahme erneut "

"ausgelöst. War der Rückgabewert `true`, wird die Ausnahme unterdrückt, und "

"die Ausführung wird mit der Anweisung fortgesetzt, die auf die Anweisung :"

"keyword:`with` folgt."

#: ../../reference/compound_stmts.rst:535

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`~object.__exit__` is ignored, and execution proceeds at "

"the normal location for the kind of exit that was taken."

msgstr ""

"Wurde die Suite aus einem anderen Grund als einer Ausnahme beendet, wird der "

"Rückgabewert von :meth:`~object.__exit__` ignoriert, und die Ausführung wird "

"an der für die jeweilige Beendigungsart üblichen Stelle fortgesetzt."

#: ../../reference/compound_stmts.rst:539

#: ../../reference/compound_stmts.rst:1677

#: ../../reference/compound_stmts.rst:1718

msgid "The following code::"

msgstr "Der folgende Code::"

#: ../../reference/compound_stmts.rst:541

msgid ""

"with EXPRESSION as TARGET:\n"

" SUITE"

msgstr ""

"with EXPRESSION as TARGET:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:544

#: ../../reference/compound_stmts.rst:572

#: ../../reference/compound_stmts.rst:1723

msgid "is semantically equivalent to::"

msgstr "ist semantisch gleichbedeutend mit::"

#: ../../reference/compound_stmts.rst:546

msgid ""

"manager = (EXPRESSION)\n"

"enter = manager.__enter__\n"

"exit = manager.__exit__\n"

"value = enter()\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(*sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(None, None, None)"

msgstr ""

"manager = (EXPRESSION)\n"

"enter = manager.__enter__\n"

"exit = manager.__exit__\n"

"value = enter()\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(*sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(None, None, None)"

#: ../../reference/compound_stmts.rst:563

msgid ""

"except that implicit :ref:`special method lookup <special-lookup>` is used "

"for :meth:`~object.__enter__` and :meth:`~object.__exit__`."

msgstr ""

"mit der Ausnahme, dass für :meth:`~object.__enter__` und :meth:`~object."

"__exit__` die implizite :ref:`Spezialmethoden-Suche <special-lookup>` "

"verwendet wird."

#: ../../reference/compound_stmts.rst:566

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

"Bei mehr als einem Element werden die Kontextmanager so verarbeitet, als "

"wären mehrere :keyword:`with`-Anweisungen verschachtelt::"

#: ../../reference/compound_stmts.rst:569

msgid ""

"with A() as a, B() as b:\n"

" SUITE"

msgstr ""

"with A() as a, B() as b:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:574

msgid ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

msgstr ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

#: ../../reference/compound_stmts.rst:578

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

"Du kannst Kontextmanager mit mehreren Elementen auch über mehrere Zeilen "

"hinweg schreiben, wenn die Elemente in Klammern stehen. Zum Beispiel::"

#: ../../reference/compound_stmts.rst:581

msgid ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

msgstr ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"