# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , 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-05 16:53+0200\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" #: ../../tutorial/errors.rst:5 msgid "Errors and Exceptions" msgstr "Fehler und Ausnahmen" #: ../../tutorial/errors.rst:7 msgid "" "Until now error messages haven't been more than mentioned, but if you have " "tried out the examples you have probably seen some. There are (at least) " "two distinguishable kinds of errors: *syntax errors* and *exceptions*." msgstr "" "Bis jetzt wurden Fehlermeldungen nur erwähnt, aber wenn du die Beispiele " "ausprobiert hast, hast du wahrscheinlich einige gesehen. Es gibt " "(mindestens) zwei Arten von Fehlern, die man unterscheiden kann: " "*Syntaxfehler* und *Ausnahmen*." #: ../../tutorial/errors.rst:15 msgid "Syntax Errors" msgstr "Syntax Fehler" #: ../../tutorial/errors.rst:17 msgid "" "Syntax errors, also known as parsing errors, are perhaps the most common " "kind of complaint you get while you are still learning Python::" msgstr "" "Syntaxfehler, auch bekannt als Parsing-Fehler, sind vielleicht die häufigste " "Art von Beschwerden, die man bekommt, wenn man Python noch lernt::" #: ../../tutorial/errors.rst:20 msgid "" ">>> while True print('Hello world')\n" " File \"\", line 1\n" " while True print('Hello world')\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" ">>> while True print('Hello world')\n" " File \"\", line 1\n" " while True print('Hello world')\n" " ^^^^^\n" "SyntaxError: invalid syntax" #: ../../tutorial/errors.rst:26 msgid "" "The parser repeats the offending line and displays little arrows pointing at " "the place where the error was detected. Note that this is not always the " "place that needs to be fixed. In the example, the error is detected at the " "function :func:`print`, since a colon (``':'``) is missing just before it." msgstr "" "Der Parser wiederholt die fehlerhafte Zeile und zeigt kleine Pfeile an, die " "auf die Stelle verweisen, an der der Fehler erkannt wurde. Beachte, dass " "dies nicht immer die Stelle ist, die korrigiert werden muss. Im Beispiel " "wird der Fehler bei der Funktions :func:`print` erkannt, da unmittelbar " "davor ein Doppelpunkt (``':'``) fehlt." #: ../../tutorial/errors.rst:31 msgid "" "The file name (```` in our example) and line number are printed so " "you know where to look in case the input came from a file." msgstr "" "Der Dateiname (in unserem Beispiel ```` ) und die Zeilennummer werden " "angezeigt, damit du weisst, wo du nachsehen musst, falls die Eingabe aus " "einer Datei stammt." #: ../../tutorial/errors.rst:38 msgid "Exceptions" msgstr "Ausnahmen" #: ../../tutorial/errors.rst:40 msgid "" "Even if a statement or expression is syntactically correct, it may cause an " "error when an attempt is made to execute it. Errors detected during " "execution are called *exceptions* and are not unconditionally fatal: you " "will soon learn how to handle them in Python programs. Most exceptions are " "not handled by programs, however, and result in error messages as shown " "here::" msgstr "" "Auch wenn eine Anweisung oder ein Ausdruck syntaktisch korrekt ist, kann es " "zu einem Fehler kommen, wenn man versucht, sie auszuführen. Fehler, die " "während der Ausführung entdeckt werden, werden *Ausnahmen* genannt und sind " "nicht unbedingt fatal: Du wirst bald lernen, wie man sie in Python-" "Programmen behandelt. Die meisten Ausnahmen werden jedoch nicht von " "Programmen behandelt und führen zu Fehlermeldungen wie hier gezeigt::" #: ../../tutorial/errors.rst:46 msgid "" ">>> 10 * (1/0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 10 * (1/0)\n" " ~^~\n" "ZeroDivisionError: division by zero\n" ">>> 4 + spam*3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 4 + spam*3\n" " ^^^^\n" "NameError: name 'spam' is not defined\n" ">>> '2' + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " '2' + 2\n" " ~~~~^~~\n" "TypeError: can only concatenate str (not \"int\") to str" msgstr "" ">>> 10 * (1/0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 10 * (1/0)\n" " ~^~\n" "ZeroDivisionError: division by zero\n" ">>> 4 + spam*3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 4 + spam*3\n" " ^^^^\n" "NameError: name 'spam' is not defined\n" ">>> '2' + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " '2' + 2\n" " ~~~~^~~\n" "TypeError: can only concatenate str (not \"int\") to str" #: ../../tutorial/errors.rst:65 msgid "" "The last line of the error message indicates what happened. Exceptions come " "in different types, and the type is printed as part of the message: the " "types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:" "`TypeError`. The string printed as the exception type is the name of the " "built-in exception that occurred. This is true for all built-in exceptions, " "but need not be true for user-defined exceptions (although it is a useful " "convention). Standard exception names are built-in identifiers (not reserved " "keywords)." msgstr "" "In der letzten Zeile der Fehlermeldung steht, was passiert ist. Ausnahmen " "gibt es in verschiedenen Typen, und der Typ wird als Teil der Meldung " "ausgegeben: Die Typen im Beispiel sind :exc:`ZeroDivisionError`, :exc:" "`NameError` und :exc:`TypeError`. Die als Ausnahmetyp ausgegebene " "Zeichenkette ist der Name der aufgetretenen integrierten Ausnahme. Dies gilt " "für alle integrierten Ausnahmen, muss aber nicht für benutzerdefinierte " "Ausnahmen gelten (obwohl es eine nützliche Konvention ist). " "Standardausnahmenamen sind integrierte Bezeichner (keine reservierten " "Schlüsselwörter)." #: ../../tutorial/errors.rst:73 msgid "" "The rest of the line provides detail based on the type of exception and what " "caused it." msgstr "" "Der Rest der Zeile enthält detaillierte Informationen über die Art der " "Ausnahme und deren Ursache." #: ../../tutorial/errors.rst:76 msgid "" "The preceding part of the error message shows the context where the " "exception occurred, in the form of a stack traceback. In general it contains " "a stack traceback listing source lines; however, it will not display lines " "read from standard input." msgstr "" "Der vorangehende Teil der Fehlermeldung zeigt den Kontext, in dem die " "Ausnahme aufgetreten ist, in Form eines Stack-Tracebacks. Im Allgemeinen " "enthält er einen Stack-Traceback, der die Zeilen des Quellcodes auflistet; " "er zeigt jedoch keine Zeilen an, die von der Standardeingabe gelesen wurden." #: ../../tutorial/errors.rst:81 msgid "" ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." msgstr "" ":ref:`bltin-exceptions` listet die integrierten Ausnahmen und ihre " "Bedeutungen auf." #: ../../tutorial/errors.rst:87 msgid "Handling Exceptions" msgstr "Behandlung von Ausnahmen" #: ../../tutorial/errors.rst:89 msgid "" "It is possible to write programs that handle selected exceptions. Look at " "the following example, which asks the user for input until a valid integer " "has been entered, but allows the user to interrupt the program (using :kbd:" "`Control-C` or whatever the operating system supports); note that a user-" "generated interruption is signalled by raising the :exc:`KeyboardInterrupt` " "exception. ::" msgstr "" "Es ist möglich, Programme zu schreiben, die ausgewählte Ausnahmen behandeln. " "Schau dir das folgende Beispiel an, das den Benutzer zur Eingabe auffordert, " "bis ein gültiger Integer eingegeben wurde, dem Benutzer aber erlaubt, das " "Programm zu unterbrechen (mit :kbd:`Control-C` oder was auch immer das " "Betriebssystem unterstützt); beachte, dass eine vom Benutzer erzeugte " "Unterbrechung durch das Auslösen der Ausnahme :exc:`KeyboardInterrupt` " "signalisiert wird. ::" #: ../../tutorial/errors.rst:95 msgid "" ">>> while True:\n" "... try:\n" "... x = int(input(\"Please enter a number: \"))\n" "... break\n" "... except ValueError:\n" "... print(\"Oops! That was no valid number. Try again...\")\n" "..." msgstr "" ">>> while True:\n" "... try:\n" "... x = int(input(\"Please enter a number: \"))\n" "... break\n" "... except ValueError:\n" "... print(\"Oops! That was no valid number. Try again...\")\n" "..." #: ../../tutorial/errors.rst:103 msgid "The :keyword:`try` statement works as follows." msgstr "Die :keyword:`try` Anweisung funktioniert wie folgt." #: ../../tutorial/errors.rst:105 msgid "" "First, the *try clause* (the statement(s) between the :keyword:`try` and :" "keyword:`except` keywords) is executed." msgstr "" "Zuerst wird die *Try-Klausel* (Die Anweisung(en) zwischen den " "Schlüsselwörtern :keyword:`try` und :keyword:`except`) ausgeführt." #: ../../tutorial/errors.rst:108 msgid "" "If no exception occurs, the *except clause* is skipped and execution of the :" "keyword:`try` statement is finished." msgstr "" "Wenn keine Ausnahme auftritt, wird die *except-Klausel* übersprungen, und " "die Ausführung der :keyword:`try`-Anweisung ist abgeschlossen." #: ../../tutorial/errors.rst:111 msgid "" "If an exception occurs during execution of the :keyword:`try` clause, the " "rest of the clause is skipped. Then, if its type matches the exception " "named after the :keyword:`except` keyword, the *except clause* is executed, " "and then execution continues after the try/except block." msgstr "" "Wenn während der Ausführung der :keyword:`try` Klausel eine Ausnahme " "auftritt, wird der Rest der Klausel übersprungen. Wenn der Typ der Ausnahme " "mit der nach dem :keyword:`except` Schlüsselwort genannten Ausnahme " "übereinstimmt, wird die *Except-Klausel* ausgeführt, und die Ausführung wird " "nach dem try/except-Block fortgesetzt." #: ../../tutorial/errors.rst:116 msgid "" "If an exception occurs which does not match the exception named in the " "*except clause*, it is passed on to outer :keyword:`try` statements; if no " "handler is found, it is an *unhandled exception* and execution stops with an " "error message." msgstr "" "Tritt eine Ausnahme auf, die nicht mit der in der *Except-Klausel* genannten " "Ausnahme übereinstimmt, wird sie an äußere :keyword:`try` Anweisungen " "weitergegeben; wird kein Handler gefunden, handelt es sich um eine " "*unbehandelte Ausnahme* und die Ausführung wird mit einer Fehlermeldung " "beendet." #: ../../tutorial/errors.rst:120 msgid "" "A :keyword:`try` statement may have more than one *except clause*, to " "specify handlers for different exceptions. At most one handler will be " "executed. Handlers only handle exceptions that occur in the corresponding " "*try clause*, not in other handlers of the same :keyword:`!try` statement. " "An *except clause* may name multiple exceptions, for example::" msgstr "" "Eine :keyword:`try`-Anweisung kann mehr als eine *except-Klausel* haben, um " "Handler für unterschiedliche Ausnahmen anzugeben. Höchstens ein Handler wird " "ausgeführt. Handler behandeln nur Ausnahmen, die in der entsprechenden *try-" "Klausel* auftreten, nicht in anderen Handlern derselben :keyword:`!try`-" "Anweisung. Eine *except-Klausel* kann mehrere Ausnahmen benennen, zum " "Beispiel::" #: ../../tutorial/errors.rst:126 msgid "" "... except RuntimeError, TypeError, NameError:\n" "... pass" msgstr "" "... except RuntimeError, TypeError, NameError:\n" "... pass" #: ../../tutorial/errors.rst:129 msgid "" "A class in an :keyword:`except` clause matches exceptions which are " "instances of the class itself or one of its derived classes (but not the " "other way around --- an *except clause* listing a derived class does not " "match instances of its base classes). For example, the following code will " "print B, C, D in that order::" msgstr "" "Eine Klasse in einer :keyword:`except`-Klausel deckt Ausnahmen ab, bei " "denen es sich um Instanzen dieser Klasse selbst oder einer ihrer " "abgeleiteten Klassen handelt (jedoch nicht umgekehrt – eine *except“-" "Klausel*, in der eine abgeleitete Klasse aufgeführt ist, deckt keine " "Instanzen ihrer Basisklassen ab). Der folgende Code gibt beispielsweise B, C " "und D in dieser Reihenfolge aus:" #: ../../tutorial/errors.rst:134 msgid "" "class B(Exception):\n" " pass\n" "\n" "class C(B):\n" " pass\n" "\n" "class D(C):\n" " pass\n" "\n" "for cls in [B, C, D]:\n" " try:\n" " raise cls()\n" " except D:\n" " print(\"D\")\n" " except C:\n" " print(\"C\")\n" " except B:\n" " print(\"B\")" msgstr "" "class B(Exception):\n" " pass\n" "\n" "class C(B):\n" " pass\n" "\n" "class D(C):\n" " pass\n" "\n" "for cls in [B, C, D]:\n" " try:\n" " raise cls()\n" " except D:\n" " print(\"D\")\n" " except C:\n" " print(\"C\")\n" " except B:\n" " print(\"B\")" #: ../../tutorial/errors.rst:153 msgid "" "Note that if the *except clauses* were reversed (with ``except B`` first), " "it would have printed B, B, B --- the first matching *except clause* is " "triggered." msgstr "" "Beachte, dass, wenn die *Exception-Klauseln* umgekehrt wären (mit ``except " "B`` zuerst), B, B, B ausgegeben worden wäre --- die erste passende " "*Exception-Klausel* wird ausgelöst." #: ../../tutorial/errors.rst:156 msgid "" "When an exception occurs, it may have associated values, also known as the " "exception's *arguments*. The presence and types of the arguments depend on " "the exception type." msgstr "" "Wenn eine Ausnahme auftritt, kann sie mit Werten verbunden sein, die auch " "als *Argumente* der Ausnahme bezeichnet werden. Das Vorhandensein und die " "Art der Argumente hängen von der Art der Ausnahme ab." #: ../../tutorial/errors.rst:160 msgid "" "The *except clause* may specify a variable after the exception name. The " "variable is bound to the exception instance which typically has an ``args`` " "attribute that stores the arguments. For convenience, builtin exception " "types define :meth:`~object.__str__` to print all the arguments without " "explicitly accessing ``.args``. ::" msgstr "" "In der *Except-Klausel* kann nach dem Namen der Ausnahme eine Variable " "angegeben werden. Die Variable ist an die Ausnahmen-Instanz gebunden, die " "typischerweise ein ``args`` Attribut hat, das die Argumente speichert. Der " "Einfachheit halber definieren integrierte Ausnahmetypen :meth:`~object." "__str__`, um alle Argumente auszugeben, ohne explizit auf ``.args`` " "zuzugreifen. ::" #: ../../tutorial/errors.rst:166 msgid "" ">>> try:\n" "... raise Exception('spam', 'eggs')\n" "... except Exception as inst:\n" "... print(type(inst)) # the exception type\n" "... print(inst.args) # arguments stored in .args\n" "... print(inst) # __str__ allows args to be printed directly,\n" "... # but may be overridden in exception " "subclasses\n" "... x, y = inst.args # unpack args\n" "... print('x =', x)\n" "... print('y =', y)\n" "...\n" "\n" "('spam', 'eggs')\n" "('spam', 'eggs')\n" "x = spam\n" "y = eggs" msgstr "" ">>> try:\n" "... raise Exception('spam', 'eggs')\n" "... except Exception as inst:\n" "... print(type(inst)) # der Exception-Typ\n" "... print(inst.args) # in .args gespeicherte Argumentes\n" "... print(inst) # __str__ erlaubt die direkte Ausgabe von " "args,\n" "... # kann aber in Exception-Unterklassen " "überschrieben werden\n" "... x, y = inst.args # args entpacken\n" "... print('x =', x)\n" "... print('y =', y)\n" "...\n" "\n" "('spam', 'eggs')\n" "('spam', 'eggs')\n" "x = spam\n" "y = eggs" #: ../../tutorial/errors.rst:183 msgid "" "The exception's :meth:`~object.__str__` output is printed as the last part " "('detail') of the message for unhandled exceptions." msgstr "" "Bei unbehandelten Ausnahmen wird die :meth:`~object.__str__` Ausgabe der " "Ausnahme als letzter Teil (\"Detail\") der Meldung ausgegeben." #: ../../tutorial/errors.rst:186 msgid "" ":exc:`BaseException` is the common base class of all exceptions. One of its " "subclasses, :exc:`Exception`, is the base class of all the non-fatal " "exceptions. Exceptions which are not subclasses of :exc:`Exception` are not " "typically handled, because they are used to indicate that the program should " "terminate. They include :exc:`SystemExit` which is raised by :meth:`sys." "exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to " "interrupt the program." msgstr "" ":exc:`BaseException` ist die gemeinsame Basisklasse für alle Ausnahmen. Eine " "ihrer Unterklassen, :exc:`Exception`, ist die Basisklasse für alle nicht " "schwerwiegenden Ausnahmen. Ausnahmen, die keine Unterklassen von :exc:" "`Exception` sind, werden in der Regel nicht behandelt, da sie dazu dienen, " "anzuzeigen, dass das Programm beendet werden soll. Dazu gehören :exc:" "`SystemExit`, die von :meth:`sys.exit` ausgelöst wird, und :exc:" "`KeyboardInterrupt`, die ausgelöst wird, wenn ein Benutzer das Programm " "unterbrechen möchte." #: ../../tutorial/errors.rst:194 msgid "" ":exc:`Exception` can be used as a wildcard that catches (almost) everything. " "However, it is good practice to be as specific as possible with the types of " "exceptions that we intend to handle, and to allow any unexpected exceptions " "to propagate on." msgstr "" ":exc:`Exception` kann als Platzhalter verwendet werden, der (fast) alles " "abfängt. Es empfiehlt sich jedoch, die Arten von Ausnahmen, die behandelt " "werden sollen, so genau wie möglich festzulegen und zuzulassen, dass " "unerwartete Ausnahmen weitergegeben werden." #: ../../tutorial/errors.rst:199 msgid "" "The most common pattern for handling :exc:`Exception` is to print or log the " "exception and then re-raise it (allowing a caller to handle the exception as " "well)::" msgstr "" "Das gängigste Muster für die :exc:`Exception` Behandlung ist, die Ausnahme " "auszugeben oder zu protokollieren und sie dann erneut auszulösen (damit ein " "Aufrufer die Ausnahme ebenfalls behandeln kann)::" #: ../../tutorial/errors.rst:203 msgid "" "import sys\n" "\n" "try:\n" " f = open('myfile.txt')\n" " s = f.readline()\n" " i = int(s.strip())\n" "except OSError as err:\n" " print(\"OS error:\", err)\n" "except ValueError:\n" " print(\"Could not convert data to an integer.\")\n" "except Exception as err:\n" " print(f\"Unexpected {err=}, {type(err)=}\")\n" " raise" msgstr "" "import sys\n" "\n" "try:\n" " f = open('myfile.txt')\n" " s = f.readline()\n" " i = int(s.strip())\n" "except OSError as err:\n" " print(\"OS error:\", err)\n" "except ValueError:\n" " print(\"Could not convert data to an integer.\")\n" "except Exception as err:\n" " print(f\"Unexpected {err=}, {type(err)=}\")\n" " raise" #: ../../tutorial/errors.rst:217 msgid "" "The :keyword:`try` ... :keyword:`except` statement has an optional *else " "clause*, which, when present, must follow all *except clauses*. It is " "useful for code that must be executed if the *try clause* does not raise an " "exception. For example::" msgstr "" "Die :keyword:`try` ... :keyword:`except` Anweisung hat eine optionale *Else-" "Klausel*, die, wenn vorhanden, allen *Except-Klauseln* folgen muss. Sie ist " "nützlich für Code, der ausgeführt werden muss, wenn die *Try-Klausel* keine " "Ausnahme auslöst. Zum Beispiel::" #: ../../tutorial/errors.rst:222 msgid "" "for arg in sys.argv[1:]:\n" " try:\n" " f = open(arg, 'r')\n" " except OSError:\n" " print('cannot open', arg)\n" " else:\n" " print(arg, 'has', len(f.readlines()), 'lines')\n" " f.close()" msgstr "" "for arg in sys.argv[1:]:\n" " try:\n" " f = open(arg, 'r')\n" " except OSError:\n" " print('kann nicht geöffnet werden', arg)\n" " else:\n" " print(arg, 'hat', len(f.readlines()), 'Zeilen')\n" " f.close()" #: ../../tutorial/errors.rst:231 msgid "" "The use of the :keyword:`!else` clause is better than adding additional code " "to the :keyword:`try` clause because it avoids accidentally catching an " "exception that wasn't raised by the code being protected by the :keyword:`!" "try` ... :keyword:`!except` statement." msgstr "" "Die Verwendung der :keyword:`!else` Klausel ist besser als das Hinzufügen " "von zusätzlichem Code zu der :keyword:`try` Klausel, weil dadurch vermieden " "wird, dass versehentlich eine Ausnahme abgefangen wird, die nicht durch den " "Code ausgelöst wurde, der durch die :keyword:`!try` ... :keyword:`!except` " "Anweisung geschützt wird." #: ../../tutorial/errors.rst:236 msgid "" "Exception handlers do not handle only exceptions that occur immediately in " "the *try clause*, but also those that occur inside functions that are called " "(even indirectly) in the *try clause*. For example::" msgstr "" "Ausnahmehandler behandeln nicht nur Ausnahmen, die unmittelbar in der *Try-" "Klausel* auftreten, sondern auch solche, die innerhalb von Funktionen " "auftreten, die (auch indirekt) in der *Try-Klausel* aufgerufen werden. Zum " "Beispiel::" #: ../../tutorial/errors.rst:240 msgid "" ">>> def this_fails():\n" "... x = 1/0\n" "...\n" ">>> try:\n" "... this_fails()\n" "... except ZeroDivisionError as err:\n" "... print('Handling run-time error:', err)\n" "...\n" "Handling run-time error: division by zero" msgstr "" ">>> def this_fails():\n" "... x = 1/0\n" "...\n" ">>> try:\n" "... this_fails()\n" "... except ZeroDivisionError as err:\n" "... print('Handling run-time error:', err)\n" "...\n" "Handling run-time error: division by zero" #: ../../tutorial/errors.rst:254 msgid "Raising Exceptions" msgstr "Auslösen von Ausnahmen" #: ../../tutorial/errors.rst:256 msgid "" "The :keyword:`raise` statement allows the programmer to force a specified " "exception to occur. For example::" msgstr "" "Die :keyword:`raise` Anweisung ermöglicht es dem Programmierer, das " "Auftreten einer bestimmten Ausnahme zu erzwingen. Zum Beispiel::" #: ../../tutorial/errors.rst:259 msgid "" ">>> raise NameError('HiThere')\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" ">>> raise NameError('HiThere')\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" #: ../../tutorial/errors.rst:265 msgid "" "The sole argument to :keyword:`raise` indicates the exception to be raised. " "This must be either an exception instance or an exception class (a class " "that derives from :class:`BaseException`, such as :exc:`Exception` or one of " "its subclasses). If an exception class is passed, it will be implicitly " "instantiated by calling its constructor with no arguments::" msgstr "" "Das reine :keyword:`raise` Argument gibt die Ausnahme an, die ausgelöst " "werden soll. Dabei muss es sich entweder um eine Ausnahme-Instanz oder eine " "Ausnahmen-Klasse handeln (Eine Klasse, die von einer :class:`BaseException`, " "wie :exc:`Exception` oder einer ihrer Unterklassen abgeleitet ist). Wenn " "eine Ausnahmeklasse übergeben wird, wird sie implizit instanziiert, indem " "ihr Konstruktor ohne Argumente aufgerufen wird::" #: ../../tutorial/errors.rst:271 msgid "raise ValueError # shorthand for 'raise ValueError()'" msgstr "raise ValueError # Kurzform für 'raise ValueError()'" #: ../../tutorial/errors.rst:273 msgid "" "If you need to determine whether an exception was raised but don't intend to " "handle it, a simpler form of the :keyword:`raise` statement allows you to re-" "raise the exception::" msgstr "" "Wenn du feststellen musst, ob eine Ausnahme ausgelöst wurde, aber nicht " "beabsichtigst, diese zu behandeln, kannst du mit einer einfacheren Form der :" "keyword:`raise` Anweisung die Ausnahme erneut auslösen::" #: ../../tutorial/errors.rst:277 msgid "" ">>> try:\n" "... raise NameError('HiThere')\n" "... except NameError:\n" "... print('An exception flew by!')\n" "... raise\n" "...\n" "An exception flew by!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" ">>> try:\n" "... raise NameError('HiThere')\n" "... except NameError:\n" "... print('An exception flew by!')\n" "... raise\n" "...\n" "An exception flew by!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" #: ../../tutorial/errors.rst:293 msgid "Exception Chaining" msgstr "Verkettung von Ausnahmen" #: ../../tutorial/errors.rst:295 msgid "" "If an unhandled exception occurs inside an :keyword:`except` section, it " "will have the exception being handled attached to it and included in the " "error message::" msgstr "" "Tritt eine unbehandelte Ausnahme innerhalb eines :keyword:`except` " "Abschnitts auf, wird die behandelte Ausnahme an diesen Abschnitt angehängt " "und in die Fehlermeldung aufgenommen::" #: ../../tutorial/errors.rst:299 msgid "" ">>> try:\n" "... open(\"database.sqlite\")\n" "... except OSError:\n" "... raise RuntimeError(\"unable to handle error\")\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " open(\"database.sqlite\")\n" " ~~~~^^^^^^^^^^^^^^^^^^^\n" "FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n" "\n" "During handling of the above exception, another exception occurred:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError(\"unable to handle error\")\n" "RuntimeError: unable to handle error" msgstr "" ">>> try:\n" "... open(\"database.sqlite\")\n" "... except OSError:\n" "... raise RuntimeError(\"unable to handle error\")\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " open(\"database.sqlite\")\n" " ~~~~^^^^^^^^^^^^^^^^^^^\n" "FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n" "\n" "During handling of the above exception, another exception occurred:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError(\"unable to handle error\")\n" "RuntimeError: unable to handle error" #: ../../tutorial/errors.rst:317 msgid "" "To indicate that an exception is a direct consequence of another, the :" "keyword:`raise` statement allows an optional :keyword:`from` clause::" msgstr "" "Um anzuzeigen, dass eine Ausnahme eine direkte Folge einer anderen ist, " "erlaubt die :keyword:`raise` Anweisung eine optionale :keyword:`from` " "Klausel::" #: ../../tutorial/errors.rst:320 msgid "" "# exc must be exception instance or None.\n" "raise RuntimeError from exc" msgstr "" "# exc muss eine Ausnahminstanz oder None sein.\n" "raise RuntimeError from exc" #: ../../tutorial/errors.rst:323 msgid "This can be useful when you are transforming exceptions. For example::" msgstr "" "Dies kann nützlich sein, wenn du Ausnahmen umwandeln wikkst. Zum Beispiel::" #: ../../tutorial/errors.rst:325 msgid "" ">>> def func():\n" "... raise ConnectionError\n" "...\n" ">>> try:\n" "... func()\n" "... except ConnectionError as exc:\n" "... raise RuntimeError('Failed to open database') from exc\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " func()\n" " ~~~~^^\n" " File \"\", line 2, in func\n" "ConnectionError\n" "\n" "The above exception was the direct cause of the following exception:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError('Failed to open database') from exc\n" "RuntimeError: Failed to open database" msgstr "" ">>> def func():\n" "... raise ConnectionError\n" "...\n" ">>> try:\n" "... func()\n" "... except ConnectionError as exc:\n" "... raise RuntimeError('Failed to open database') from exc\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " func()\n" " ~~~~^^\n" " File \"\", line 2, in func\n" "ConnectionError\n" "\n" "The above exception was the direct cause of the following exception:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError('Failed to open database') from exc\n" "RuntimeError: Failed to open database" #: ../../tutorial/errors.rst:347 msgid "" "It also allows disabling automatic exception chaining using the ``from " "None`` idiom::" msgstr "" "Es erlaubt auch die Deaktivierung der automatischen Ausnahmeverkettung mit " "dem ``from None`` Idiom::" #: ../../tutorial/errors.rst:350 msgid "" ">>> try:\n" "... open('database.sqlite')\n" "... except OSError:\n" "... raise RuntimeError from None\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError from None\n" "RuntimeError" msgstr "" ">>> try:\n" "... open('database.sqlite')\n" "... except OSError:\n" "... raise RuntimeError from None\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError from None\n" "RuntimeError" #: ../../tutorial/errors.rst:360 msgid "" "For more information about chaining mechanics, see :ref:`bltin-exceptions`." msgstr "" "Weitere Informationen zur Verkettungsmechanik findest du unter :ref:`bltin-" "exceptions`." #: ../../tutorial/errors.rst:366 msgid "User-defined Exceptions" msgstr "Benutzerdefinierte Ausnahmen" #: ../../tutorial/errors.rst:368 msgid "" "Programs may name their own exceptions by creating a new exception class " "(see :ref:`tut-classes` for more about Python classes). Exceptions should " "typically be derived from the :exc:`Exception` class, either directly or " "indirectly." msgstr "" "Programme können ihre eigenen Ausnahmen benennen, indem sie eine neue " "Ausnahmeklasse erstellen (siehe :ref:`tut-classes` für mehr über Python-" "Klassen). Ausnahmen sollten in der Regel von der :exc:`Exception` Klasse " "abgeleitet werden, entweder direkt oder indirekt." #: ../../tutorial/errors.rst:372 msgid "" "Exception classes can be defined which do anything any other class can do, " "but are usually kept simple, often only offering a number of attributes that " "allow information about the error to be extracted by handlers for the " "exception." msgstr "" "Es können Ausnahmeklassen definiert werden, die alles tun können, was jede " "andere Klasse auch tun kann, aber sie sind in der Regel einfach gehalten und " "bieten oft nur eine Reihe von Attributen, die es ermöglichen, Informationen " "über den Fehler durch Handler für die Ausnahme zu extrahieren." #: ../../tutorial/errors.rst:376 msgid "" "Most exceptions are defined with names that end in \"Error\", similar to the " "naming of the standard exceptions." msgstr "" "Die meisten Ausnahmen werden mit Namen definiert, die auf \"Error\" enden, " "ähnlich der Benennung der Standardausnahmen." #: ../../tutorial/errors.rst:379 msgid "" "Many standard modules define their own exceptions to report errors that may " "occur in functions they define." msgstr "" "Viele Standardmodule definieren ihre eigenen Ausnahmen, um Fehler zu melden, " "die in den von ihnen definierten Funktionen auftreten können." #: ../../tutorial/errors.rst:386 msgid "Defining Clean-up Actions" msgstr "Definition von Bereinigungsaktionen" #: ../../tutorial/errors.rst:388 msgid "" "The :keyword:`try` statement has another optional clause which is intended " "to define clean-up actions that must be executed under all circumstances. " "For example::" msgstr "" "Die :keyword:`try` Anweisung enthält eine weitere optionale Klausel, die " "dazu dient, Bereinigungsaktionen zu definieren, die unter allen Umständen " "ausgeführt werden müssen. Zum Beispiel::" #: ../../tutorial/errors.rst:392 msgid "" ">>> try:\n" "... raise KeyboardInterrupt\n" "... finally:\n" "... print('Goodbye, world!')\n" "...\n" "Goodbye, world!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise KeyboardInterrupt\n" "KeyboardInterrupt" msgstr "" ">>> try:\n" "... raise KeyboardInterrupt\n" "... finally:\n" "... print('Goodbye, world!')\n" "...\n" "Goodbye, world!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise KeyboardInterrupt\n" "KeyboardInterrupt" #: ../../tutorial/errors.rst:403 msgid "" "If a :keyword:`finally` clause is present, the :keyword:`!finally` clause " "will execute as the last task before the :keyword:`try` statement completes. " "The :keyword:`!finally` clause runs whether or not the :keyword:`!try` " "statement produces an exception. The following points discuss more complex " "cases when an exception occurs:" msgstr "" "Wenn eine :keyword:`finally` Klausel vorhanden ist, wird die :keyword:`!" "finally` Klausel als letzte Aufgabe ausgeführt, bevor die :keyword:`try` " "Anweisung abgeschlossen wird. Die :keyword:`!finally` Klausel wird " "unabhängig davon ausgeführt, ob die :keyword:`!try` Anweisung eine Ausnahme " "erzeugt oder nicht. In den folgenden Punkten werden komplexere Fälle beim " "Auftreten einer Ausnahme behandelt:" #: ../../tutorial/errors.rst:409 msgid "" "If an exception occurs during execution of the :keyword:`!try` clause, the " "exception may be handled by an :keyword:`except` clause. If the exception is " "not handled by an :keyword:`!except` clause, the exception is re-raised " "after the :keyword:`!finally` clause has been executed." msgstr "" "Wenn während der Ausführung der :keyword:`!try` Klausel eine Ausnahme " "auftritt, kann die Ausnahme von einer :keyword:`except` Klausel behandelt " "werden. Wenn die Ausnahme nicht durch eine :keyword:`!except` Klausel " "behandelt wird, wird die Ausnahme erneut ausgelöst, nachdem die :keyword:`!" "finally` Klausel ausgeführt wurde." #: ../../tutorial/errors.rst:415 msgid "" "An exception could occur during execution of an :keyword:`!except` or :" "keyword:`!else` clause. Again, the exception is re-raised after the :keyword:" "`!finally` clause has been executed." msgstr "" "Während der Ausführung einer :keyword:`!except` oder :keyword:`!else` " "Klausel kann eine Ausnahme auftreten. Auch hier wird die Ausnahme erneut " "ausgelöst, nachdem die :keyword:`!finally` Klausel ausgeführt wurde." #: ../../tutorial/errors.rst:419 msgid "" "If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:" "`continue` or :keyword:`return` statement, exceptions are not re-raised. " "This can be confusing and is therefore discouraged. From version 3.14 the " "compiler emits a :exc:`SyntaxWarning` for it (see :pep:`765`)." msgstr "" "Wenn die Klausel :keyword:`!finally` eine Anweisung vom Typ :keyword:" "`break`, :keyword:`continue` oder :keyword:`return` ausführt, werden " "Ausnahmen nicht erneut ausgelöst. Dies kann verwirrend sein und wird daher " "nicht empfohlen. Ab Version 3.14 gibt der Compiler hierfür die " "Fehlermeldung :exc:`SyntaxWarning` aus (siehe :pep:`765`)." #: ../../tutorial/errors.rst:425 msgid "" "If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:" "`continue` or :keyword:`return` statement, the :keyword:`!finally` clause " "will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :" "keyword:`!return` statement's execution." msgstr "" "Wenn die :keyword:`!try` Anweisung eine :keyword:`break`, :keyword:" "`continue` oder :keyword:`return` Anweisung erreicht, wird die :keyword:`!" "finally` Klausel direkt vor der Ausführung der :keyword:`!break`, :keyword:`!" "continue` oder :keyword:`!return` Anweisung ausgeführt." #: ../../tutorial/errors.rst:431 msgid "" "If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the " "returned value will be the one from the :keyword:`!finally` clause's :" "keyword:`!return` statement, not the value from the :keyword:`!try` " "clause's :keyword:`!return` statement. This can be confusing and is " "therefore discouraged. From version 3.14 the compiler emits a :exc:" "`SyntaxWarning` for it (see :pep:`765`)." msgstr "" "Wenn eine :keyword:`!finally`-Klausel eine :keyword:`!return`-Anweisung " "enthält, ist der zurückgegebene Wert derjenige aus der :keyword:`!return`-" "Anweisung der :keyword:`!finally`-Klausel und nicht der Wert aus der :" "keyword:`!return`-Anweisung der :keyword:`!try`-Klausel. Dies kann " "verwirrend sein und wird daher nicht empfohlen. Ab Version 3.14 gibt der " "Compiler hierfür eine :exc:`SyntaxWarning`-Meldung aus (siehe :pep:`765`)." #: ../../tutorial/errors.rst:439 msgid "For example::" msgstr "Zum Beispiel::" #: ../../tutorial/errors.rst:441 msgid "" ">>> def bool_return():\n" "... try:\n" "... return True\n" "... finally:\n" "... return False\n" "...\n" ">>> bool_return()\n" "False" msgstr "" ">>> def bool_return():\n" "... try:\n" "... return True\n" "... finally:\n" "... return False\n" "...\n" ">>> bool_return()\n" "False" #: ../../tutorial/errors.rst:450 msgid "A more complicated example::" msgstr "Ein komplizierteres Beispiel::" #: ../../tutorial/errors.rst:452 msgid "" ">>> def divide(x, y):\n" "... try:\n" "... result = x / y\n" "... except ZeroDivisionError:\n" "... print(\"division by zero!\")\n" "... else:\n" "... print(\"result is\", result)\n" "... finally:\n" "... print(\"executing finally clause\")\n" "...\n" ">>> divide(2, 1)\n" "result is 2.0\n" "executing finally clause\n" ">>> divide(2, 0)\n" "division by zero!\n" "executing finally clause\n" ">>> divide(\"2\", \"1\")\n" "executing finally clause\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " divide(\"2\", \"1\")\n" " ~~~~~~^^^^^^^^^^\n" " File \"\", line 3, in divide\n" " result = x / y\n" " ~~^~~\n" "TypeError: unsupported operand type(s) for /: 'str' and 'str'" msgstr "" ">>> def divide(x, y):\n" "... try:\n" "... result = x / y\n" "... except ZeroDivisionError:\n" "... print(\"division by zero!\")\n" "... else:\n" "... print(\"result is\", result)\n" "... finally:\n" "... print(\"executing finally clause\")\n" "...\n" ">>> divide(2, 1)\n" "result is 2.0\n" "executing finally clause\n" ">>> divide(2, 0)\n" "division by zero!\n" "executing finally clause\n" ">>> divide(\"2\", \"1\")\n" "executing finally clause\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " divide(\"2\", \"1\")\n" " ~~~~~~^^^^^^^^^^\n" " File \"\", line 3, in divide\n" " result = x / y\n" " ~~^~~\n" "TypeError: unsupported operand type(s) for /: 'str' and 'str'" #: ../../tutorial/errors.rst:479 msgid "" "As you can see, the :keyword:`finally` clause is executed in any event. " "The :exc:`TypeError` raised by dividing two strings is not handled by the :" "keyword:`except` clause and therefore re-raised after the :keyword:`!" "finally` clause has been executed." msgstr "" "Wie du sehen kannst, wird die :keyword:`finally` Klausel in jedem Fall " "ausgeführt. Der :exc:`TypeError`, ausgelöst durch die Teilung zweier " "Zeichenfolgenn wird von der :keyword:`except` Klausel nicht verarbeitet und " "daher nach Ausführung der :keyword:`!finally` Klausel erneut ausgelöst." #: ../../tutorial/errors.rst:484 msgid "" "In real world applications, the :keyword:`finally` clause is useful for " "releasing external resources (such as files or network connections), " "regardless of whether the use of the resource was successful." msgstr "" "In realen Anwendungen ist die :keyword:`finally` Klausel nützlich, um " "externe Ressourcen (z. B. Dateien oder Netzwerkverbindungen) freizugeben, " "unabhängig davon, ob die Nutzung der Ressource erfolgreich war." #: ../../tutorial/errors.rst:492 msgid "Predefined Clean-up Actions" msgstr "Vordefinierte Bereinigungsaktionen" #: ../../tutorial/errors.rst:494 msgid "" "Some objects define standard clean-up actions to be undertaken when the " "object is no longer needed, regardless of whether or not the operation using " "the object succeeded or failed. Look at the following example, which tries " "to open a file and print its contents to the screen. ::" msgstr "" "Einige Objekte definieren Standardbereinigungsaktionen, die durchgeführt " "werden, wenn das Objekt nicht mehr benötigt wird, unabhängig davon, ob der " "Vorgang mit dem Objekt erfolgreich war oder fehlgeschlagen ist. Schau dir " "das folgende Beispiel an, in dem versucht wird, eine Datei zu öffnen und " "ihren Inhalt auf dem Bildschirm auszugeben. ::" #: ../../tutorial/errors.rst:499 msgid "" "for line in open(\"myfile.txt\"):\n" " print(line, end=\"\")" msgstr "" "for line in open(\"myfile.txt\"):\n" " print(line, end=\"\")" #: ../../tutorial/errors.rst:502 msgid "" "The problem with this code is that it leaves the file open for an " "indeterminate amount of time after this part of the code has finished " "executing. This is not an issue in simple scripts, but can be a problem for " "larger applications. The :keyword:`with` statement allows objects like files " "to be used in a way that ensures they are always cleaned up promptly and " "correctly. ::" msgstr "" "Das Problem bei diesem Code besteht darin, dass die Datei für eine " "unbestimmte Zeit geöffnet bleibt, nachdem die Ausführung dieses Teils des " "Codes abgeschlossen ist. Dies ist bei einfachen Skripten kein Problem, kann " "jedoch bei größeren Anwendungen ein Problem darstellen. Die :keyword:`with` " "Anweisung ermöglicht die Verwendung von Objekten wie Dateien auf eine Weise, " "die sicherstellt, dass sie stets zeitnah und korrekt bereinigt werden. ::" #: ../../tutorial/errors.rst:508 msgid "" "with open(\"myfile.txt\") as f:\n" " for line in f:\n" " print(line, end=\"\")" msgstr "" "with open(\"myfile.txt\") as f:\n" " for line in f:\n" " print(line, end=\"\")" #: ../../tutorial/errors.rst:512 msgid "" "After the statement is executed, the file *f* is always closed, even if a " "problem was encountered while processing the lines. Objects which, like " "files, provide predefined clean-up actions will indicate this in their " "documentation." msgstr "" "Nach Ausführung der Anweisung wird die Datei *f* immer geschlossen, auch " "wenn bei der Verarbeitung der Zeilen ein Problem aufgetreten ist. Objekte, " "die wie Dateien vordefinierte Bereinigungsaktionen bereitstellen, weisen in " "ihrer Dokumentation darauf hin." #: ../../tutorial/errors.rst:520 msgid "Raising and Handling Multiple Unrelated Exceptions" msgstr "Auslösen und Behandeln mehrerer unzusammenhängender Ausnahmen" #: ../../tutorial/errors.rst:522 msgid "" "There are situations where it is necessary to report several exceptions that " "have occurred. This is often the case in concurrency frameworks, when " "several tasks may have failed in parallel, but there are also other use " "cases where it is desirable to continue execution and collect multiple " "errors rather than raise the first exception." msgstr "" "Es gibt Situationen, in denen es notwendig ist, mehrere aufgetretene " "Ausnahmen zu melden. Dies ist häufig in Parallelitäts-Frameworks der Fall, " "wenn möglicherweise mehrere Aufgaben parallel fehlgeschlagen sind. Es gibt " "jedoch auch andere Anwendungsfälle, in denen es wünschenswert ist, die " "Ausführung fortzusetzen und mehrere Fehler zu sammeln, anstatt die erste " "Ausnahme auszulösen." #: ../../tutorial/errors.rst:528 msgid "" "The builtin :exc:`ExceptionGroup` wraps a list of exception instances so " "that they can be raised together. It is an exception itself, so it can be " "caught like any other exception. ::" msgstr "" "Die integrierte :exc:`ExceptionGroup` Funktion umschließt eine Liste von " "Ausnahmeinstanzen, sodass diese gemeinsam ausgelöst werden können. Da es " "sich selbst um eine Ausnahme handelt, kann sie wie jede andere Ausnahme " "abgefangen werden. ::" #: ../../tutorial/errors.rst:532 msgid "" ">>> def f():\n" "... excs = [OSError('error 1'), SystemError('error 2')]\n" "... raise ExceptionGroup('there were problems', excs)\n" "...\n" ">>> f()\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 3, in f\n" " | raise ExceptionGroup('there were problems', excs)\n" " | ExceptionGroup: there were problems (2 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | OSError: error 1\n" " +---------------- 2 ----------------\n" " | SystemError: error 2\n" " +------------------------------------\n" ">>> try:\n" "... f()\n" "... except Exception as e:\n" "... print(f'caught {type(e)}: {e}')\n" "...\n" "caught : there were problems (2 sub-exceptions)\n" ">>>" msgstr "" ">>> def f():\n" "... excs = [OSError('error 1'), SystemError('error 2')]\n" "... raise ExceptionGroup('there were problems', excs)\n" "...\n" ">>> f()\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 3, in f\n" " | raise ExceptionGroup('there were problems', excs)\n" " | ExceptionGroup: there were problems (2 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | OSError: error 1\n" " +---------------- 2 ----------------\n" " | SystemError: error 2\n" " +------------------------------------\n" ">>> try:\n" "... f()\n" "... except Exception as e:\n" "... print(f'caught {type(e)}: {e}')\n" "...\n" "caught : there were problems (2 sub-exceptions)\n" ">>>" #: ../../tutorial/errors.rst:557 msgid "" "By using ``except*`` instead of ``except``, we can selectively handle only " "the exceptions in the group that match a certain type. In the following " "example, which shows a nested exception group, each ``except*`` clause " "extracts from the group exceptions of a certain type while letting all other " "exceptions propagate to other clauses and eventually to be reraised. ::" msgstr "" "Durch das Nutzen von ``except*`` anstelle von ``except``, können wir " "selektiv nur die Ausnahmen in der Gruppe behandeln, die einen bestimmten Typ " "entsprechen. Im folgenden Beispiel, das eine verschachtelte Ausnahmegruppe " "zeigt, extrahiert jede ``except*`` Klausel Ausnahmen eines bestimmten Typs " "aus der Gruppe, während alle anderen Ausnahmen an andere Klauseln " "weitergegeben und schließlich erneut ausgelöst werden. ::" #: ../../tutorial/errors.rst:564 msgid "" ">>> def f():\n" "... raise ExceptionGroup(\n" "... \"group1\",\n" "... [\n" "... OSError(1),\n" "... SystemError(2),\n" "... ExceptionGroup(\n" "... \"group2\",\n" "... [\n" "... OSError(3),\n" "... RecursionError(4)\n" "... ]\n" "... )\n" "... ]\n" "... )\n" "...\n" ">>> try:\n" "... f()\n" "... except* OSError as e:\n" "... print(\"There were OSErrors\")\n" "... except* SystemError as e:\n" "... print(\"There were SystemErrors\")\n" "...\n" "There were OSErrors\n" "There were SystemErrors\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 2, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise ExceptionGroup(\n" " | ...<12 lines>...\n" " | )\n" " | ExceptionGroup: group1 (1 sub-exception)\n" " +-+---------------- 1 ----------------\n" " | ExceptionGroup: group2 (1 sub-exception)\n" " +-+---------------- 1 ----------------\n" " | RecursionError: 4\n" " +------------------------------------\n" ">>>" msgstr "" ">>> def f():\n" "... raise ExceptionGroup(\n" "... \"group1\",\n" "... [\n" "... OSError(1),\n" "... SystemError(2),\n" "... ExceptionGroup(\n" "... \"group2\",\n" "... [\n" "... OSError(3),\n" "... RecursionError(4)\n" "... ]\n" "... )\n" "... ]\n" "... )\n" "...\n" ">>> try:\n" "... f()\n" "... except* OSError as e:\n" "... print(\"There were OSErrors\")\n" "... except* SystemError as e:\n" "... print(\"There were SystemErrors\")\n" "...\n" "There were OSErrors\n" "There were SystemErrors\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 2, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise ExceptionGroup(\n" " | ...<12 lines>...\n" " | )\n" " | ExceptionGroup: group1 (1 sub-exception)\n" " +-+---------------- 1 ----------------\n" " | ExceptionGroup: group2 (1 sub-exception)\n" " +-+---------------- 1 ----------------\n" " | RecursionError: 4\n" " +------------------------------------\n" ">>>" #: ../../tutorial/errors.rst:605 msgid "" "Note that the exceptions nested in an exception group must be instances, not " "types. This is because in practice the exceptions would typically be ones " "that have already been raised and caught by the program, along the following " "pattern::" msgstr "" "Beachte, dass die in einer Ausnahmegruppe verschachtelten Ausnahmen " "Instanzen und keine Typen sein müssen. Dies liegt daran, dass es sich in der " "Praxis typischerweise um Ausnahmen handelt, die bereits vom Programm " "ausgelöst und abgefangen wurden, und zwar nach dem folgenden Muster:" #: ../../tutorial/errors.rst:610 msgid "" ">>> excs = []\n" "... for test in tests:\n" "... try:\n" "... test.run()\n" "... except Exception as e:\n" "... excs.append(e)\n" "...\n" ">>> if excs:\n" "... raise ExceptionGroup(\"Test Failures\", excs)\n" "..." msgstr "" ">>> excs = []\n" "... for test in tests:\n" "... try:\n" "... test.run()\n" "... except Exception as e:\n" "... excs.append(e)\n" "...\n" ">>> if excs:\n" "... raise ExceptionGroup(\"Test Failures\", excs)\n" "..." #: ../../tutorial/errors.rst:625 msgid "Enriching Exceptions with Notes" msgstr "Anreicherung von Ausnahmen mit Notizen" #: ../../tutorial/errors.rst:627 msgid "" "When an exception is created in order to be raised, it is usually " "initialized with information that describes the error that has occurred. " "There are cases where it is useful to add information after the exception " "was caught. For this purpose, exceptions have a method ``add_note(note)`` " "that accepts a string and adds it to the exception's notes list. The " "standard traceback rendering includes all notes, in the order they were " "added, after the exception. ::" msgstr "" "Wenn eine Ausnahme erstellt wird, um ausgelöst zu werden, wird sie " "normalerweise mit Informationen initialisiert, die den aufgetretenen Fehler " "beschreiben. Es gibt Fälle, in denen es sinnvoll ist, Informationen " "hinzuzufügen, nachdem die Ausnahme abgefangen wurde. Zu diesem Zweck " "verfügen Ausnahmen über eine Methode ``add_note(note)``, welche einen String " "akzeptiert und zur Notizenliste der Ausnahme hinzufügt. Das Standard-" "Traceback-Rendering umfasst alle Notizen in der Reihenfolge, in der sie nach " "der Ausnahme hinzugefügt wurden. ::" #: ../../tutorial/errors.rst:634 msgid "" ">>> try:\n" "... raise TypeError('bad type')\n" "... except Exception as e:\n" "... e.add_note('Add some information')\n" "... e.add_note('Add some more information')\n" "... raise\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise TypeError('bad type')\n" "TypeError: bad type\n" "Add some information\n" "Add some more information\n" ">>>" msgstr "" ">>> try:\n" "... raise TypeError('bad type')\n" "... except Exception as e:\n" "... e.add_note('Add some information')\n" "... e.add_note('Add some more information')\n" "... raise\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise TypeError('bad type')\n" "TypeError: bad type\n" "Add some information\n" "Add some more information\n" ">>>" #: ../../tutorial/errors.rst:649 msgid "" "For example, when collecting exceptions into an exception group, we may want " "to add context information for the individual errors. In the following each " "exception in the group has a note indicating when this error has occurred. ::" msgstr "" "Wenn wir beispielsweise Ausnahmen in einer Ausnahmegruppe sammeln, möchten " "wir möglicherweise Kontextinformationen für die einzelnen Fehler hinzufügen. " "Im Folgenden gibt es für jede Ausnahme in der Gruppe einen Hinweis, der " "angibt, wann dieser Fehler aufgetreten ist. ::" #: ../../tutorial/errors.rst:653 msgid "" ">>> def f():\n" "... raise OSError('operation failed')\n" "...\n" ">>> excs = []\n" ">>> for i in range(3):\n" "... try:\n" "... f()\n" "... except Exception as e:\n" "... e.add_note(f'Happened in Iteration {i+1}')\n" "... excs.append(e)\n" "...\n" ">>> raise ExceptionGroup('We have some problems', excs)\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | raise ExceptionGroup('We have some problems', excs)\n" " | ExceptionGroup: We have some problems (3 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 1\n" " +---------------- 2 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 2\n" " +---------------- 3 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 3\n" " +------------------------------------\n" ">>>" msgstr "" ">>> def f():\n" "... raise OSError('operation failed')\n" "...\n" ">>> excs = []\n" ">>> for i in range(3):\n" "... try:\n" "... f()\n" "... except Exception as e:\n" "... e.add_note(f'Happened in Iteration {i+1}')\n" "... excs.append(e)\n" "...\n" ">>> raise ExceptionGroup('We have some problems', excs)\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | raise ExceptionGroup('We have some problems', excs)\n" " | ExceptionGroup: We have some problems (3 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 1\n" " +---------------- 2 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 2\n" " +---------------- 3 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operation failed')\n" " | OSError: operation failed\n" " | Happened in Iteration 3\n" " +------------------------------------\n" ">>>" #~ msgid "" #~ "A :keyword:`try` statement may have more than one *except clause*, to " #~ "specify handlers for different exceptions. At most one handler will be " #~ "executed. Handlers only handle exceptions that occur in the corresponding " #~ "*try clause*, not in other handlers of the same :keyword:`!try` " #~ "statement. An *except clause* may name multiple exceptions as a " #~ "parenthesized tuple, for example::" #~ msgstr "" #~ "Eine :keyword:`try` Anweisung kann mehr als eine *Except-Klausel* " #~ "enthalten, um Handler für verschiedene Ausnahmen anzugeben. Es wird " #~ "höchstens ein Handler ausgeführt. Handler behandeln nur Ausnahmen, die in " #~ "der entsprechenden *Try-Klausel* vorkommen, nicht in anderen Handlern " #~ "derselben :keyword:`!try` Anweisung. Eine *Except-Klausel* kann mehrere " #~ "Ausnahmen als eingeklammerter Tupel benennen, zum Beispiel::" #~ msgid "" #~ "... except (RuntimeError, TypeError, NameError):\n" #~ "... pass" #~ msgstr "" #~ "... except (RuntimeError, TypeError, NameError):\n" #~ "... pass" #~ msgid "" #~ ">>> def f():\n" #~ "... excs = [OSError('error 1'), SystemError('error 2')]\n" #~ "... raise ExceptionGroup('there were problems', excs)\n" #~ "...\n" #~ ">>> f()\n" #~ " + Exception Group Traceback (most recent call last):\n" #~ " | File \"\", line 1, in \n" #~ " | f()\n" #~ " | ~^^\n" #~ " | File \"\", line 3, in f\n" #~ " | raise ExceptionGroup('there were problems', excs)\n" #~ " | ExceptionGroup: there were problems (2 sub-exceptions)\n" #~ " +-+---------------- 1 ----------------\n" #~ " | OSError: error 1\n" #~ " +---------------- 2 ----------------\n" #~ " | SystemError: error 2\n" #~ " +------------------------------------\n" #~ ">>> try:\n" #~ "... f()\n" #~ "... except Exception as e:\n" #~ "... print(f'caught {type(e)}: e')\n" #~ "...\n" #~ "caught : e\n" #~ ">>>" #~ msgstr "" #~ ">>> def f():\n" #~ "... excs = [OSError('Fehler 1'), SystemError('Fehler 2')]\n" #~ "... raise ExceptionGroup('Es sind Probleme aufgetreten', excs)\n" #~ "...\n" #~ ">>> f()\n" #~ " + Traceback der Ausnahmegruppe (letzter Aufruf zuletzt):\n" #~ " | Datei \"\", Zeile 1, in \n" #~ " | f()\n" #~ " | ~^^\n" #~ " | Datei \"\", Zeile 3, in f\n" #~ " | raise ExceptionGroup('es gab Probleme', excs)\n" #~ " | ExceptionGroup: es gab Probleme (2 Unterausnahmen)\n" #~ " +-+---------------- 1 ----------------\n" #~ " | OSError: Fehler 1\n" #~ " +---------------- 2 ----------------\n" #~ " | SystemError: Fehler 2\n" #~ " +------------------------------------\n" #~ ">>> try:\n" #~ "... f()\n" #~ "... except Exception as e:\n" #~ "... print(f'{type(e)} abgefangen: {e}')\n" #~ "... abgefangen: Es gab Probleme (2 " #~ "Unterausnahmen)\n" #~ ">>>"