introduction.po

# 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
# Swen Bachmann, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-22 12:07+0200\n"
"PO-Revision-Date: 2026-08-30 00:02+0000\n"
"Last-Translator: Swen Bachmann <142266608+sba72@users.noreply.github.com>\n"
"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../reference/introduction.rst:6
msgid "Introduction"
msgstr "Einführung"

#: ../../reference/introduction.rst:8
msgid ""
"This reference manual describes the Python programming language. It is not "
"intended as a tutorial."
msgstr ""
"Dieses Referenzhandbuch beschreibt die Programmiersprache Python. Es ist "
"nicht als Tutorial gedacht."

#: ../../reference/introduction.rst:11
msgid ""
"While I am trying to be as precise as possible, I chose to use English "
"rather than formal specifications for everything except syntax and lexical "
"analysis. This should make the document more understandable to the average "
"reader, but will leave room for ambiguities. Consequently, if you were "
"coming from Mars and tried to re-implement Python from this document alone, "
"you might have to guess things and in fact you would probably end up "
"implementing quite a different language. On the other hand, if you are using "
"Python and wonder what the precise rules about a particular area of the "
"language are, you should definitely be able to find them here. If you would "
"like to see a more formal definition of the language, maybe you could "
"volunteer your time --- or invent a cloning machine :-)."
msgstr ""
"Während ich versuche, so präzise wie möglich zu sein, habe ich mich dafür "
"entschieden, für alles außer der Syntax und der lexikalischen Analyse "
"einfaches Englisch statt formaler Spezifikationen zu verwenden. Dies sollte "
"das Dokument für den durchschnittlichen Leser verständlicher machen, lässt "
"jedoch Raum für Mehrdeutigkeiten. Wenn Sie also vom Mars kämen und "
"versuchten, Python allein anhand dieses Dokuments neu zu implementieren, "
"müssten Sie unter Umständen Dinge erraten und würden am Ende wahrscheinlich "
"eine ganz andere Sprache implementieren. Wenn Sie hingegen Python verwenden "
"und sich fragen, wie die genauen Regeln für einen bestimmten Bereich der "
"Sprache lauten, sollten Sie diese hier definitiv finden können. Wenn Sie "
"eine formalere Definition der Sprache wünschen, könnten Sie vielleicht Ihre "
"Zeit opfern --- oder eine Klonmaschine erfinden :-)."

#: ../../reference/introduction.rst:23
msgid ""
"It is dangerous to add too many implementation details to a language "
"reference document --- the implementation may change, and other "
"implementations of the same language may work differently.  On the other "
"hand, CPython is the one Python implementation in widespread use (although "
"alternate implementations continue to gain support), and its particular "
"quirks are sometimes worth being mentioned, especially where the "
"implementation imposes additional limitations. Therefore, you'll find short "
"\"implementation notes\" sprinkled throughout the text."
msgstr ""
"Es ist gefährlich, einem Sprachreferenzdokument zu viele "
"Implementierungsdetails hinzuzufügen --- die Implementierung kann sich "
"ändern, und andere Implementierungen derselben Sprache können anders "
"funktionieren. Andererseits ist CPython die am weitesten verbreitete Python-"
"Implementierung (obwohl alternative Implementierungen weiter an "
"Unterstützung gewinnen), und ihre speziellen Eigenheiten sind es manchmal "
"wert, erwähnt zu werden, insbesondere dort, wo die Implementierung "
"zusätzliche Einschränkungen mit sich bringt. Daher finden sich im gesamten "
"Text verstreut kurze „Implementierungshinweise“."

#: ../../reference/introduction.rst:32
msgid ""
"Every Python implementation comes with a number of built-in and standard "
"modules.  These are documented in :ref:`library-index`.  A few built-in "
"modules are mentioned when they interact in a significant way with the "
"language definition."
msgstr ""
"Jede Python-Implementierung bringt eine Reihe von integrierten und Standard-"
"Modulen mit. Diese sind in :ref:`library-index` dokumentiert. Einige wenige "
"integrierte Module werden erwähnt, wenn sie in wesentlicher Weise mit der "
"Sprachdefinition interagieren."

#: ../../reference/introduction.rst:41
msgid "Alternate Implementations"
msgstr "Alternative Implementierungen"

#: ../../reference/introduction.rst:43
msgid ""
"Though there is one Python implementation which is by far the most popular, "
"there are some alternate implementations which are of particular interest to "
"different audiences."
msgstr ""
"Obwohl es eine Python-Implementierung gibt, die bei weitem am beliebtesten "
"ist, gibt es einige alternative Implementierungen, die für verschiedene "
"Zielgruppen von besonderem Interesse sind."

#: ../../reference/introduction.rst:47
msgid "Known implementations include:"
msgstr "Zu den bekannten Implementierungen gehören:"

#: ../../reference/introduction.rst:49
msgid "CPython"
msgstr "CPython"

#: ../../reference/introduction.rst:50
msgid ""
"This is the original and most-maintained implementation of Python, written "
"in C. New language features generally appear here first."
msgstr ""
"Dies ist die ursprüngliche und am meisten gepflegte Implementierung von "
"Python, geschrieben in C. Neue Sprachmerkmale erscheinen hier in der Regel "
"zuerst."

#: ../../reference/introduction.rst:53
msgid "Jython"
msgstr "Jython"

#: ../../reference/introduction.rst:54
msgid ""
"Python implemented in Java.  This implementation can be used as a scripting "
"language for Java applications, or can be used to create applications using "
"the Java class libraries.  It is also often used to create tests for Java "
"libraries. More information can be found at `the Jython website <https://www."
"jython.org/>`_."
msgstr ""
"Python implementiert in Java. Diese Implementierung kann als Skriptsprache "
"für Java-Anwendungen verwendet werden oder zur Erstellung von Anwendungen "
"unter Verwendung der Java-Klassenbibliotheken dienen. Sie wird auch häufig "
"verwendet, um Tests für Java-Bibliotheken zu schreiben. Weitere "
"Informationen sind auf der `Jython-Website <https://www.jython.org/>`_ zu "
"finden."

#: ../../reference/introduction.rst:59
msgid "Python for .NET"
msgstr "Python for .NET"

#: ../../reference/introduction.rst:60
msgid ""
"This implementation actually uses the CPython implementation, but is a "
"managed .NET application and makes .NET libraries available.  It was created "
"by Brian Lloyd.  For more information, see the `Python for .NET home page "
"<https://pythonnet.github.io/>`_."
msgstr ""
"Diese Implementierung verwendet tatsächlich die CPython-Implementierung, ist "
"jedoch eine verwaltete .NET-Anwendung und stellt .NET-Bibliotheken zur "
"Verfügung. Sie wurde von Brian Lloyd entwickelt. Weitere Informationen "
"finden Sie auf der `Python for .NET-Startseite <https://pythonnet.github.io/"
">`_."

#: ../../reference/introduction.rst:65
msgid "IronPython"
msgstr "IronPython"

#: ../../reference/introduction.rst:66
msgid ""
"An alternate Python for .NET.  Unlike Python.NET, this is a complete Python "
"implementation that generates IL, and compiles Python code directly to .NET "
"assemblies.  It was created by Jim Hugunin, the original creator of Jython.  "
"For more information, see `the IronPython website <https://ironpython.net/"
">`_."
msgstr ""
"Ein alternatives Python für .NET. Im Gegensatz zu Python.NET ist dies eine "
"vollständige Python-Implementierung, die IL generiert und Python-Code direkt "
"in .NET-Assemblies kompiliert. Sie wurde von Jim Hugunin, dem ursprünglichen "
"Schöpfer von Jython, entwickelt. Weitere Informationen finden Sie auf der "
"`IronPython-Website <https://ironpython.net/>`_."

#: ../../reference/introduction.rst:71
msgid "PyPy"
msgstr "PyPy"

#: ../../reference/introduction.rst:72
msgid ""
"An implementation of Python written completely in Python. It supports "
"several advanced features not found in other implementations like stackless "
"support and a Just in Time compiler. One of the goals of the project is to "
"encourage experimentation with the language itself by making it easier to "
"modify the interpreter (since it is written in Python).  Additional "
"information is available on `the PyPy project's home page <https://pypy.org/"
">`_."
msgstr ""
"Eine vollständig in Python geschriebene Implementierung von Python. Sie "
"unterstützt verschiedene fortgeschrittene Funktionen, die in anderen "
"Implementierungen nicht zu finden sind, wie etwa Stackless-Unterstützung und "
"einen Just-in-Time-Compiler. Eines der Ziele des Projekts ist es, zum "
"Experimentieren mit der Sprache selbst anzuregen, indem es einfacher gemacht "
"wird, den Interpreter anzupassen (da er in Python geschrieben ist). Weitere "
"Informationen sind auf der `Startseite des PyPy-Projekts <https://pypy.org/"
">`_ verfügbar."

#: ../../reference/introduction.rst:79
msgid ""
"Each of these implementations varies in some way from the language as "
"documented in this manual, or introduces specific information beyond what's "
"covered in the standard Python documentation.  Please refer to the "
"implementation-specific documentation to determine what else you need to "
"know about the specific implementation you're using."
msgstr ""
"Jede dieser Implementierungen weicht in irgendeiner Weise von der in diesem "
"Handbuch dokumentierten Sprache ab oder führt spezifische Informationen über "
"das hinaus ein, was in der Standard-Python-Dokumentation behandelt wird. "
"Bitte ziehen Sie die implementierungsspezifische Dokumentation zurate, um zu "
"erfahren, was Sie sonst noch über die von Ihnen verwendete Implementierung "
"wissen müssen."

#: ../../reference/introduction.rst:89
msgid "Notation"
msgstr "Notation"

#: ../../reference/introduction.rst:93
msgid ""
"The descriptions of lexical analysis and syntax use a grammar notation that "
"is a mixture of `EBNF <https://en.wikipedia.org/wiki/"
"Extended_Backus%E2%80%93Naur_form>`_ and `PEG <https://en.wikipedia.org/wiki/"
"Parsing_expression_grammar>`_. For example:"
msgstr ""
"Die Beschreibungen der lexikalischen Analyse und Syntax verwenden eine "
"Grammatik-Notation, die eine Mischung aus `EBNF <https://de.wikipedia.org/"
"wiki/Erweiterte_Backus-Naur-Form>`_ und `PEG <https://en.wikipedia.org/wiki/"
"Parsing_expression_grammar>`_ ist. Zum Beispiel:"

#: ../../reference/introduction.rst:106
msgid ""
"In this example, the first line says that a ``name`` is a ``letter`` "
"followed by a sequence of zero or more ``letter``\\ s, ``digit``\\ s, and "
"underscores. A ``letter`` in turn is any of the single characters ``'a'`` "
"through ``'z'`` and ``A`` through ``Z``; a ``digit`` is a single character "
"from ``0`` to ``9``."
msgstr ""
"In diesem Beispiel besagt die erste Zeile, dass ein ``name`` ein ``letter`` "
"ist, gefolgt von einer Sequenz aus null oder mehr ``letter``\\ n, "
"``digit``\\ s und Unterstrichen. Ein ``letter`` wiederum ist ein beliebiges "
"Einzelzeichen von ``'a'`` bis ``'z'`` sowie ``A`` bis ``Z``, ein ``digit`` "
"ist ein Einzelzeichen von ``0`` bis ``9``."

#: ../../reference/introduction.rst:112
msgid ""
"Each rule begins with a name (which identifies the rule that's being "
"defined) followed by a colon, ``:``. The definition to the right of the "
"colon uses the following syntax elements:"
msgstr ""
"Jede Regel beginnt mit einem Namen (der die zu definierende Regel "
"identifiziert), gefolgt von einem Doppelpunkt, ``:``. Die Definition rechts "
"vom Doppelpunkt verwendet die folgenden Syntaxelemente:"

#: ../../reference/introduction.rst:116
msgid ""
"``name``: A name refers to another rule. Where possible, it is a link to the "
"rule's definition."
msgstr ""
"``name``: Ein Name verweist auf eine andere Regel. Wo möglich, handelt es "
"sich um einen Link zur Definition der Regel."

#: ../../reference/introduction.rst:119
msgid ""
"``TOKEN``: An uppercase name refers to a :term:`token`. For the purposes of "
"grammar definitions, tokens are the same as rules."
msgstr ""
"``TOKEN``: Ein in Großbuchstaben geschriebener Name verweist auf ein :term:"
"`Token <token>`. Für die Zwecke von Grammatikdefinitionen sind Tokens "
"dasselbe wie Regeln."

#: ../../reference/introduction.rst:122
msgid ""
"``\"text\"``, ``'text'``: Text in single or double quotes must match "
"literally (without the quotes). The type of quote is chosen according to the "
"meaning of ``text``:"
msgstr ""
"``\"text\"``, ``'text'``: Text in einfachen oder doppelten Anführungszeichen "
"muss buchstäblich (ohne die Anführungszeichen) übereinstimmen. Die Art der "
"Anführungszeichen wird entsprechend der Bedeutung von ``text`` gewählt:"

#: ../../reference/introduction.rst:126
msgid "``'if'``: A name in single quotes denotes a :ref:`keyword <keywords>`."
msgstr ""
"``'if'``: Ein Name in einfachen Anführungszeichen kennzeichnet ein :ref:"
"`Schlüsselwort <keywords>`."

#: ../../reference/introduction.rst:127
msgid ""
"``\"case\"``: A name in double quotes denotes a :ref:`soft-keyword <soft-"
"keywords>`."
msgstr ""
"``\"case\"``: Ein Name in doppelten Anführungszeichen kennzeichnet ein :ref:"
"`Soft-Schlüsselwort <soft-keywords>`."

#: ../../reference/introduction.rst:129
msgid ""
"``'@'``: A non-letter symbol in single quotes denotes an :py:data:`~token."
"OP` token, that is, a :ref:`delimiter <delimiters>` or :ref:`operator "
"<operators>`."
msgstr ""
"``'@'``: Ein Symbol, das kein Buchstabe ist, in einfachen Anführungszeichen "
"kennzeichnet ein :py:data:`~token.OP`-Token, das heißt ein :ref:"
"`Trennzeichen <delimiters>` oder einen :ref:`Operator <operators>`."

#: ../../reference/introduction.rst:133
msgid ""
"``e1 e2``: Items separated only by whitespace denote a sequence. Here, "
"``e1`` must be followed by ``e2``."
msgstr ""
"``e1 e2``: Elemente, die nur durch Leerzeichen getrennt sind, bezeichnen "
"eine Sequenz. Hier muss ``e1`` von ``e2`` gefolgt werden."

#: ../../reference/introduction.rst:135
msgid ""
"``e1 | e2``: A vertical bar is used to separate alternatives. It denotes "
"PEG's \"ordered choice\": if ``e1`` matches, ``e2`` is not considered. In "
"traditional PEG grammars, this is written as a slash, ``/``, rather than a "
"vertical bar. See :pep:`617` for more background and details."
msgstr ""
"``e1 | e2``: Ein senkrechter Strich wird verwendet, um Alternativen zu "
"trennen. Er bezeichnet PEGs „geordnete Auswahl“ (ordered choice): Wenn "
"``e1`` passt, wird ``e2`` nicht berücksichtigt. In traditionellen PEG-"
"Grammatiken wird dies als Schrägstrich, ``/``, anstelle eines senkrechten "
"Strichs geschrieben. Siehe :pep:`617` für weitere Hintergründe und Details."

#: ../../reference/introduction.rst:141
msgid "``e*``: A star means zero or more repetitions of the preceding item."
msgstr ""
"``e*``: Ein Stern bedeutet null oder mehr Wiederholungen des vorhergehenden "
"Elements."

#: ../../reference/introduction.rst:142
msgid "``e+``: Likewise, a plus means one or more repetitions."
msgstr "``e+``: Ebenso bedeutet ein Plus ein oder mehr Wiederholungen."

#: ../../reference/introduction.rst:143
msgid ""
"``[e]``: A phrase enclosed in square brackets means zero or one occurrences. "
"In other words, the enclosed phrase is optional."
msgstr ""
"``[e]``: Ein in eckige Klammern eingeschlossener Ausdruck bedeutet null oder "
"ein Vorkommen. Mit anderen Worten: Der eingeschlossene Ausdruck ist optional."

#: ../../reference/introduction.rst:145
msgid ""
"``e?``: A question mark has exactly the same meaning as square brackets: the "
"preceding item is optional."
msgstr ""
"``e?``: Ein Fragezeichen hat exakt dieselbe Bedeutung wie eckige Klammern: "
"Das vorhergehende Element ist optional."

#: ../../reference/introduction.rst:147
msgid "``(e)``: Parentheses are used for grouping."
msgstr "``(e)``: Runde Klammern werden zur Gruppierung verwendet."

#: ../../reference/introduction.rst:149
msgid ""
"The following notation is only used in :ref:`lexical definitions <notation-"
"lexical-vs-syntactic>`."
msgstr ""
"Die folgende Notation wird nur in :ref:`lexikalischen Definitionen <notation-"
"lexical-vs-syntactic>` verwendet."

#: ../../reference/introduction.rst:152
msgid ""
"``\"a\"...\"z\"``: Two literal characters separated by three dots mean a "
"choice of any single character in the given (inclusive) range of ASCII "
"characters."
msgstr ""
"``\"a\"...\"z\"``: Zwei Literalzeichen, die durch drei Punkte getrennt sind, "
"bedeuten die Auswahl eines beliebigen Einzelzeichens im angegebenen "
"(inklusiven) Bereich von ASCII-Zeichen."

#: ../../reference/introduction.rst:154
msgid ""
"``<...>``: A phrase between angular brackets gives an informal description "
"of the matched symbol (for example, ``<any ASCII character except \"\\"
"\">``), or an abbreviation that is defined in nearby text (for example, "
"``<Lu>``)."
msgstr ""
"``<...>``: Ein Ausdruck in spitzen Klammern liefert eine informelle "
"Beschreibung des passenden Symbols (zum Beispiel ``<any ASCII character "
"except \"\\\">``) oder eine Abkürzung, die im umgebenden Text definiert ist "
"(zum Beispiel ``<Lu>``)."

#: ../../reference/introduction.rst:160
msgid ""
"Some definitions also use *lookaheads*, which indicate that an element must "
"(or must not) match at a given position, but without consuming any input:"
msgstr ""
"Einige Definitionen verwenden auch *Lookaheads*, die angeben, dass ein "
"Element an einer bestimmten Position passen muss (oder nicht passen darf), "
"jedoch ohne eine Eingabe zu konsumieren:"

#: ../../reference/introduction.rst:163
msgid "``&e``: a positive lookahead (that is, ``e`` is required to match)"
msgstr ""
"``&e``: ein positiver Lookahead (das heißt, ``e`` muss zwingend passen)"

#: ../../reference/introduction.rst:164
msgid ""
"``!e``: a negative lookahead (that is, ``e`` is required *not* to match)"
msgstr ""
"``!e``: ein negativer Lookahead (das heißt, ``e`` darf zwingend *nicht* "
"passen)"

#: ../../reference/introduction.rst:166
msgid ""
"The unary operators (``*``, ``+``, ``?``) bind as tightly as possible; the "
"vertical bar (``|``) binds most loosely."
msgstr ""
"Die unären Operatoren (``*``, ``+``, ``?``) binden so stark wie möglich; der "
"senkrechte Strich (``|``) bindet am schwächsten."

#: ../../reference/introduction.rst:169
msgid "White space is only meaningful to separate tokens."
msgstr "Whitespace dient ausschließlich dazu, Tokens voneinander zu trennen."

#: ../../reference/introduction.rst:171
msgid ""
"Rules are normally contained on a single line, but rules that are too long "
"may be wrapped:"
msgstr ""
"Regeln stehen normalerweise in einer einzelnen Zeile, zu lange Regeln können "
"jedoch umgebrochen werden:"

#: ../../reference/introduction.rst:180
msgid ""
"Alternatively, rules may be formatted with the first line ending at the "
"colon, and each alternative beginning with a vertical bar on a new line. For "
"example:"
msgstr ""
"Alternativ können Regeln so formatiert werden, dass die erste Zeile mit dem "
"Doppelpunkt endet und jede Alternative mit einem senkrechten Strich in einer "
"neuen Zeile beginnt. Zum Beispiel:"

#: ../../reference/introduction.rst:195
msgid "This does *not* mean that there is an empty first alternative."
msgstr "Dies bedeutet *nicht*, dass es eine leere erste Alternative gibt."

#: ../../reference/introduction.rst:202
msgid "Lexical and Syntactic definitions"
msgstr "Lexikalische und syntaktische Definitionen"

#: ../../reference/introduction.rst:204
msgid ""
"There is some difference between *lexical* and *syntactic* analysis: the :"
"term:`lexical analyzer` operates on the individual characters of the input "
"source, while the *parser* (syntactic analyzer) operates on the stream of :"
"term:`tokens <token>` generated by the lexical analysis. However, in some "
"cases the exact boundary between the two phases is a CPython implementation "
"detail."
msgstr ""
"Es gibt einen Unterschied zwischen *lexikalischer* und *syntaktischer* "
"Analyse: Der :term:`Lexikalische Analysierer <lexical analyzer>` arbeitet "
"auf den einzelnen Zeichen der Eingabequelle, während der *Parser* "
"(syntaktischer Analysierer) auf dem Datenstrom von :term:`Tokens <token>` "
"arbeitet, die von der lexikalischen Analyse erzeugt wurden. In manchen "
"Fällen ist die genaue Grenze zwischen den beiden Phasen jedoch ein CPython-"
"Implementierungsdetail."

#: ../../reference/introduction.rst:211
msgid ""
"The practical difference between the two is that in *lexical* definitions, "
"all whitespace is significant. The lexical analyzer :ref:`discards "
"<whitespace>` all whitespace that is not converted to tokens like :data:"
"`token.INDENT` or :data:`~token.NEWLINE`. *Syntactic* definitions then use "
"these tokens, rather than source characters."
msgstr ""
"Der praktische Unterschied zwischen beiden besteht darin, dass in "
"*lexikalischen* Definitionen sämtlicher Whitespace signifikant ist. Der "
"lexikalische Analysierer :ref:`verwirft <whitespace>` allen Whitespace, der "
"nicht in Tokens wie :data:`token.INDENT` oder :data:`~token.NEWLINE` "
"umgewandelt wird. *Syntaktische* Definitionen verwenden dann diese Tokens "
"anstelle von Quelltext-Zeichen."

#: ../../reference/introduction.rst:217
msgid ""
"This documentation uses the same BNF grammar for both styles of definitions. "
"All uses of BNF in the next chapter (:ref:`lexical`) are lexical "
"definitions; uses in subsequent chapters are syntactic definitions."
msgstr ""
"Diese Dokumentation verwendet dieselbe BNF-Grammatik für beide Arten von "
"Definitionen. Alle Verwendungen von BNF im nächsten Kapitel (:ref:`lexical`) "
"sind lexikalische Definitionen; Verwendungen in nachfolgenden Kapiteln sind "
"syntaktische Definitionen."

#: ../../reference/introduction.rst:91
msgid "BNF"
msgstr "BNF"

#: ../../reference/introduction.rst:91
msgid "grammar"
msgstr "Grammatik"

#: ../../reference/introduction.rst:91
msgid "syntax"
msgstr "Syntax"

#: ../../reference/introduction.rst:91
msgid "notation"
msgstr "Notation"

#: ../../reference/introduction.rst:197
msgid "lexical definitions"
msgstr "lexikalische Definitionen"