# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-08-22 12:07+0200\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: Swen Bachmann <[email protected]>\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 \"<stdin>\", line 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> while True print('Hello world')\n"

" Datei \"<stdin>“, Zeile 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: ungültige 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 (``<stdin>`` 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 ``<stdin>`` ) 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 \"<stdin>\", line 1, in <module>\n"

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: can only concatenate str (not \"int\") to str"

msgstr ""

">>> 10 * (1/0)\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 1, in <module>\n"

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: Division durch Null\n"

">>> 4 + spam*3\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 1, in <module>\n"

" 4 + spam*3\n"

" ^^^^\n"

"NameError: Der Name 'spam' ist nicht definiert\n"

">>> '2' + 2\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 1, in <module>\n"

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: Es können nur Zeichenketten (nicht \"int“) mit Zeichenketten "

"verkettet werden"

#: ../../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 eingebauten Ausnahme. Dies gilt "

"für alle eingebauten Ausnahmen, muss aber nicht für benutzerdefinierte "

"Ausnahmen gelten (obwohl es eine nützliche Konvention ist). "

"Standardausnahmenamen sind eingebaute 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 eingebauten 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(\"Bitte gib eine Zahl ein: \"))\n"

"... break\n"

"... except ValueError:\n"

"... print(\"Hoppla! Das war keine gültige Zahl. Versuche es noch "

"einmal...\")\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 eingebaute 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"

"<class 'Exception'>\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"

"<class 'Exception'>\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-Fehler:\", err)\n"

"except ValueError:\n"

" print(\"Daten konnten nicht in eine Ganzzahl konvertiert werden.\")\n"

"except Exception as err:\n"

" print(f\"Unerwarteter {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('Behandlung eines Laufzeitfehlers:', err)\n"

"...\n"

"Behandlung eines Laufzeitfehlers: Division durch Null"

#: ../../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 \"<stdin>\", line 1, in <module>\n"

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> raise NameError('HiThere')\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 1, in <module>\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 \"<stdin>\", line 2, in <module>\n"

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> try:\n"

"... raise NameError('HiThere')\n"

"... except NameError:\n"

"... print('Eine Ausnahme ist aufgetreten!')\n"

"... raise\n"

"...\n"

"Eine Ausnahme ist aufgetreten!\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 2, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 4, in <module>\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(\"Fehler kann nicht behandelt werden\")\n"

"...\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, line 2, in <module>\n"

" open(\"database.sqlite\")\n"

" ~~~~^^^^^^^^^^^^^^^^^^^\n"

"FileNotFoundError: [Errno 2] Keine solche Datei oder kein solches "

"Verzeichnis: 'database.sqlite'\n"

"\n"

"Bei der Behandlung der oben genannten Ausnahme ist eine weitere Ausnahme "

"aufgetreten:\n"

"\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 4, in <module>\n"

" raise RuntimeError(\"Fehler kann nicht behandelt werden“)\n"

"RuntimeError: Fehler kann nicht behandelt werden"

#: ../../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<raise>` clause::"

msgstr ""

"Um anzuzeigen, dass eine Ausnahme eine direkte Folge einer anderen ist, "

"erlaubt die :keyword:`raise` Anweisung eine optionale :keyword:`from<raise>` "

"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 \"<stdin>\", line 2, in <module>\n"

" func()\n"

" ~~~~^^\n"

" File \"<stdin>\", 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 \"<stdin>\", line 4, in <module>\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('Datenbank konnte nicht geöffnet werden') from "

"exc\n"

"...\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 2, in <module>\n"

" func()\n"

" ~~~~^^\n"

" Datei \"<stdin>“, Zeile 2, in func\n"

"ConnectionError\n"

"\n"

"Die oben genannte Ausnahme war die direkte Ursache für die folgende "

"Ausnahme:\n"

"\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 4, in <module>\n"

" raise RuntimeError('Datenbank konnte nicht geöffnet werden') from exc\n"

"RuntimeError: Datenbank konnte nicht geöffnet werden"

#: ../../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 \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError from None\n"

"RuntimeError"

msgstr ""

">>> try:\n"

"... open('database.sqlite')\n"

"... except OSError:\n"

"... raise RuntimeError from None\n"

"...\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 4, in <module>\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 \"<stdin>\", line 2, in <module>\n"

" raise KeyboardInterrupt\n"

"KeyboardInterrupt"

msgstr ""

">>> try:\n"

"... raise KeyboardInterrupt\n"

"... finally:\n"

"... print('Auf Wiedersehen, Welt!')\n"

"...\n"

"Auf Wiedersehen, Welt!\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>“, Zeile 2, in <module>\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"