glossary.po

# German translation of the Python documentation.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Swen Bachmann, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-11-01 00:10+0000\n"
"PO-Revision-Date: 2026-08-30 00:02+0000\n"
"Last-Translator: Swen Bachmann\n"
"Language-Team: German (https://github.com/python/python-docs-de)\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../glossary.rst:5
msgid "Glossary"
msgstr "Glossar"

#: ../../glossary.rst:10
msgid "``>>>``"
msgstr "``>>>``"

#: ../../glossary.rst:12
msgid ""
"The default Python prompt of the :term:`interactive` shell.  Often seen for "
"code examples which can be executed interactively in the interpreter."
msgstr ""
"Die Standard-Python-Eingabeaufforderung der :term:`interaktiven "
"<interactive>` Shell. Wird häufig bei Code-Beispielen verwendet, die "
"interaktiv im Interpreter ausgeführt werden können."

#: ../../glossary.rst:15
msgid "``...``"
msgstr "``...``"

#: ../../glossary.rst:17
msgid "Can refer to:"
msgstr "Kann sich beziehen auf:"

#: ../../glossary.rst:19
msgid ""
"The default Python prompt of the :term:`interactive` shell when entering the "
"code for an indented code block, when within a pair of matching left and "
"right delimiters (parentheses, square brackets, curly braces or triple "
"quotes), or after specifying a decorator."
msgstr ""
"Die Standard-Python-Eingabeaufforderung der :term:`interactive`-Shell bei "
"der Eingabe von Code für einen eingerückten Codeblock, wenn dieser sich "
"innerhalb eines Paares übereinstimmender linker und rechter Begrenzer "
"(Klammern, eckige Klammern, geschweifte Klammern oder dreifache "
"Anführungszeichen) befindet, oder nach der Angabe eines Dekorators."

#: ../../glossary.rst:26
msgid ""
"The three dots form of the :ref:`Ellipsis <bltin-ellipsis-object>` object."
msgstr ""
"Die drei Punkte bilden das :ref:`Ellipsis- <bltin-ellipsis-object>`-Objekt."

#: ../../glossary.rst:27
msgid "abstract base class"
msgstr "Abstrakte Basisklasse"

#: ../../glossary.rst:29
msgid ""
"Abstract base classes complement :term:`duck-typing` by providing a way to "
"define interfaces when other techniques like :func:`hasattr` would be clumsy "
"or subtly wrong (for example with :ref:`magic methods <special-lookup>`).  "
"ABCs introduce virtual subclasses, which are classes that don't inherit from "
"a class but are still recognized by :func:`isinstance` "
"and :func:`issubclass`; see the :mod:`abc` module documentation.  Python "
"comes with many built-in ABCs for data structures (in "
"the :mod:`collections.abc` module), numbers (in the :mod:`numbers` module), "
"streams (in the :mod:`io` module), import finders and loaders (in "
"the :mod:`importlib.abc` module).  You can create your own ABCs with "
"the :mod:`abc` module."
msgstr ""
"Abstrakte Basisklassen (abstract base class / ABC) ergänzen :term:`Duck-"
"Typing <duck-typing>`, indem sie eine Möglichkeit bieten, Schnittstellen zu "
"definieren, wenn andere Techniken wie :func:`hasattr` umständlich oder in "
"subtiler Weise falsch wären (zum Beispiel bei :ref:`magischen Methoden "
"<special-lookup>`). ABCs führen virtuelle Unterklassen ein – das sind "
"Klassen, die nicht von einer Klasse erben, aber dennoch "
"von :func:`isinstance` und :func:`issubclass` erkannt werden. Siehe die "
"Dokumentation zum Modul :mod:`abc`. Python enthält viele integrierte ABCs "
"für Datenstrukturen (im Modul :mod:`collections.abc` ), Zahlen (im "
"Modul :mod:`numbers` ), Streams (im Modul :mod:`io` ) sowie Import-Finder "
"und Loader (im Modul :mod:`importlib.abc` ). Mit dem Modul :mod:`abc` kannst "
"du eigene ABCs erstellen."

#: ../../glossary.rst:40
msgid "annotate function"
msgstr "Annotate-Funktion"

#: ../../glossary.rst:42
msgid ""
"A callable that can be called to retrieve the :term:`annotations "
"<annotation>` of an object. Annotate functions are usually :term:`functions "
"<function>`, automatically generated as the :attr:`~object.__annotate__` "
"attribute of functions, classes, and modules. Annotate functions are a "
"subset of :term:`evaluate functions <evaluate function>`."
msgstr ""
"Ein aufrufbares Objekt, das aufgerufen werden kann, um "
"die :term:`Annotationen <annotation>` eines Objekts abzurufen. Annotate-"
"Funktionen sind normalerweise :term:`Funktionen <function>`, die automatisch "
"als Attribut :attr:`~object.__annotate__` von Funktionen, Klassen und "
"Modulen erzeugt werden. Annotate-Funktionen sind eine Teilmenge "
"der :term:`Evaluate-Funktionen <evaluate function>`."

#: ../../glossary.rst:47
msgid "annotation"
msgstr "Annotation"

#: ../../glossary.rst:49
msgid ""
"A label associated with a variable, a class attribute or a function "
"parameter or return value, used by convention as a :term:`type hint`."
msgstr ""
"Eine Bezeichnung, die einer Variablen, einem Klassenattribut oder einem "
"Funktionsparameter bzw. Rückgabewert zugeordnet ist und üblicherweise "
"als :term:`Typhinweis <type hint>` verwendet wird."

#: ../../glossary.rst:53
msgid ""
"Annotations of local variables cannot be accessed at runtime, but "
"annotations of global variables, class attributes, and functions can be "
"retrieved by calling :func:`annotationlib.get_annotations` on modules, "
"classes, and functions, respectively."
msgstr ""
"Auf Annotationen lokaler Variablen kann zur Laufzeit nicht zugegriffen "
"werden, doch Annotationen globaler Variablen, Klassenattribute und "
"Funktionen lassen sich durch Aufruf "
"von :func:`annotationlib.get_annotations` für Module, Klassen bzw. "
"Funktionen abrufen."

#: ../../glossary.rst:58
msgid ""
"See :term:`variable annotation`, :term:`function "
"annotation`, :pep:`484`, :pep:`526`, and :pep:`649`, which describe this "
"functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Siehe :term:`Variablen-Annotation <variable annotation>`, :term:`Funktions-"
"Annotation <function annotation>`, :pep:`484`, :pep:`526` und :pep:`649`, wo "
"diese Funktionalität beschrieben wird. Siehe außerdem :ref:`annotations-"
"howto` für bewährte Vorgehensweisen beim Umgang mit Annotationen."

#: ../../glossary.rst:62
msgid "argument"
msgstr "Argument"

#: ../../glossary.rst:64
msgid ""
"A value passed to a :term:`function` (or :term:`method`) when calling the "
"function.  There are two kinds of argument:"
msgstr ""
"Ein Wert, der beim Aufruf einer :term:`Funktion <function>` "
"(oder :term:`Methode <method>`) an diese übergeben wird. Es gibt zwei Arten "
"von Argumenten:"

#: ../../glossary.rst:67
msgid ""
":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "
"``name=``) in a function call or passed as a value in a dictionary preceded "
"by ``**``.  For example, ``3`` and ``5`` are both keyword arguments in the "
"following calls to :func:`complex`::"
msgstr ""
":dfn:`Schlüsselwortargument`: Ein Argument, dem in einem Funktionsaufruf ein "
"Bezeichner vorangestellt ist (z. B. ``name=``) oder das in einem Dictionary "
"als Wert übergeben wird, dem ``**`` vorangestellt ist. Beispielsweise sind "
"sowohl ``3`` als auch ``5`` Schlüsselwortargumente in den folgenden Aufrufen "
"von :func:`complex`::"

#: ../../glossary.rst:72
msgid ""
"complex(real=3, imag=5)\n"
"complex(**{'real': 3, 'imag': 5})"
msgstr ""
"complex(real=3, imag=5)\n"
"complex(**{'real': 3, 'imag': 5})"

#: ../../glossary.rst:75
msgid ""
":dfn:`positional argument`: an argument that is not a keyword argument. "
"Positional arguments can appear at the beginning of an argument list and/or "
"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "
"``3`` and ``5`` are both positional arguments in the following calls::"
msgstr ""
":dfn:`Positionsargument <positional argument>`: Ein Argument, das kein "
"Schlüsselwortargument ist. Positionsargumente können am Anfang einer "
"Argumentliste stehen und/oder als Elemente eines :term:`iterable` übergeben "
"werden, dem ``*`` vorangestellt ist. Beispielsweise sind sowohl ``3`` als "
"auch ``5`` Positionsargumente in den folgenden Aufrufen::"

#: ../../glossary.rst:81
msgid ""
"complex(3, 5)\n"
"complex(*(3, 5))"
msgstr ""
"complex(3, 5)\n"
"complex(*(3, 5))"

#: ../../glossary.rst:84
msgid ""
"Arguments are assigned to the named local variables in a function body. See "
"the :ref:`calls` section for the rules governing this assignment. "
"Syntactically, any expression can be used to represent an argument; the "
"evaluated value is assigned to the local variable."
msgstr ""
"Argumente werden im Funktionskörper den benannten lokalen Variablen "
"zugewiesen. Die Regeln für diese Zuweisung findest du im "
"Abschnitt :ref:`calls` . Syntaktisch kann jeder Ausdruck zur Darstellung "
"eines Arguments verwendet werden. Der ausgewertete Wert wird der lokalen "
"Variablen zugewiesen."

#: ../../glossary.rst:89
msgid ""
"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"and :pep:`362`."
msgstr ""
"Siehe auch den Glossareintrag zu :term:`parameter`, die FAQ-Frage "
"zum :ref:`Unterschied zwischen Argumenten und Parametern <faq-argument-vs-"
"parameter>` und :pep:`362`."

#: ../../glossary.rst:92
msgid "asynchronous context manager"
msgstr "asynchroner Kontextmanager"

#: ../../glossary.rst:94
msgid ""
"An object which controls the environment seen in an :keyword:`async with` "
"statement by defining :meth:`~object.__aenter__` "
"and :meth:`~object.__aexit__` methods.  Introduced by :pep:`492`."
msgstr ""
"Ein Objekt, das die in einer :keyword:`async with`-Anweisung angezeigte "
"Umgebung steuert, indem es die Methoden :meth:`~object.__aenter__` "
"und :meth:`~object.__aexit__` definiert. Eingeführt durch :pep:`492`."

#: ../../glossary.rst:97
msgid "asynchronous generator"
msgstr "asynchroner Generator"

#: ../../glossary.rst:99
msgid ""
"Informally used to mean either an :term:`asynchronous generator function` or "
"an :term:`asynchronous generator iterator`, depending on context.  The "
"formal terms :term:`asynchronous generator function` and :term:`asynchronous "
"generator iterator` are uncommon in practice; \"asynchronous generator\" "
"alone is almost always sufficient."
msgstr ""
"Wird umgangssprachlich je nach Kontext entweder für eine :term:`asynchrone "
"Generatorfunktion <asynchronous generator function>` oder "
"einen :term:`asynchronen Generator-Iterator <asynchronous generator "
"iterator>` verwendet. Die formalen Begriffe :term:`asynchrone "
"Generatorfunktion <asynchronous generator function>` und :term:`asynchroner "
"Generator-Iterator <asynchronous generator iterator>` sind in der Praxis "
"selten; \"asynchroner Generator\" allein reicht fast immer aus."

#: ../../glossary.rst:104
msgid "asynchronous generator function"
msgstr "asynchrone Generatorfunktion"

#: ../../glossary.rst:106
msgid ""
"A function which returns an :term:`asynchronous generator iterator`. It "
"looks like a coroutine function defined with :keyword:`async def` except "
"that it contains :keyword:`yield` expressions for producing a series of "
"values usable in an :keyword:`async for` loop.  See :pep:`525`."
msgstr ""
"Eine Funktion, die einen :term:`asynchronen Generator-Iterator <asynchronous "
"generator iterator>` zurückgibt. Sie ähnelt einer mit :keyword:`async def` "
"definierten Coroutine-Funktion, enthält jedoch Ausdrücke vom "
"Typ :keyword:`yield`, um eine Reihe von Werten zu erzeugen, die in "
"einer :keyword:`async for`-Schleife verwendet werden können. "
"Siehe :pep:`525`."

#: ../../glossary.rst:111
msgid ""
"An asynchronous generator function may contain :keyword:`await` expressions "
"as well as :keyword:`async for`, and :keyword:`async with` statements."
msgstr ""
"Eine asynchrone Generatorfunktion kann sowohl :keyword:`await`-Ausdrücke als "
"auch :keyword:`async for`- und :keyword:`async with`-Anweisungen enthalten."

#: ../../glossary.rst:114
msgid "asynchronous generator iterator"
msgstr "asynchrone Generator-Iterator"

#: ../../glossary.rst:116
msgid "An object created by an :term:`asynchronous generator function`."
msgstr ""
"Ein Objekt, das von einer :term:`asynchronen Generatorfunktion <asynchronous "
"generator function>` erstellt wurde."

#: ../../glossary.rst:118
msgid ""
"This is an :term:`asynchronous iterator` which when called using "
"the :meth:`~object.__anext__` method returns an awaitable object which will "
"execute the body of the asynchronous generator function until the "
"next :keyword:`yield` expression."
msgstr ""
"Dies ist ein :term:`asynchroner Iterator <asynchronous iterator>`, der beim "
"Aufruf mit der Methode  :meth:`~object.__anext__` ein awaitable-Objekt "
"zurückgibt, das den Körper der asynchronen Generatorfunktion bis zum "
"nächsten  :keyword:`yield`-Ausdruck ausführt."

#: ../../glossary.rst:123
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"execution state (including local variables and pending try-statements).  "
"When the *asynchronous generator iterator* effectively resumes with another "
"awaitable returned by :meth:`~object.__anext__`, it picks up where it left "
"off.  See :pep:`492` and :pep:`525`."
msgstr ""
"Jeder :keyword:`yield` unterbricht die Verarbeitung vorübergehend und "
"speichert dabei den Ausführungsstatus (einschließlich lokaler Variablen und "
"ausstehender \"try\"-Anweisungen). Wenn der *asynchrone Generator-Iterator* "
"mit einem anderen von :meth:`~object.__anext__` zurückgegebenen "
"\"awaitable\" effektiv fortgesetzt wird, setzt er die Ausführung an der "
"Stelle fort, an der er unterbrochen wurde. Siehe :pep:`492` und :pep:`525`."

#: ../../glossary.rst:128
msgid "asynchronous iterable"
msgstr "asynchrones iterierbares Objekt"

#: ../../glossary.rst:130
msgid ""
"An object, that can be used in an :keyword:`async for` statement. Must "
"return an :term:`asynchronous iterator` from its :meth:`~object.__aiter__` "
"method.  Introduced by :pep:`492`."
msgstr ""
"Ein Objekt, das in einer :keyword:`async for`-Anweisung verwendet werden "
"kann. Es muss über seine Methode :meth:`~object.__aiter__` "
"einen :term:`asynchronen Iterator <asynchronous iterator>` zurückgeben. "
"Eingeführt durch :pep:`492`."

#: ../../glossary.rst:133
msgid "asynchronous iterator"
msgstr "asynchroner Iterator"

#: ../../glossary.rst:135
msgid ""
"An object that implements the :meth:`~object.__aiter__` "
"and :meth:`~object.__anext__` methods.  :meth:`~object.__anext__` must "
"return an :term:`awaitable` object. :keyword:`async for` resolves the "
"awaitables returned by an asynchronous iterator's :meth:`~object.__anext__` "
"method until it raises a :exc:`StopAsyncIteration` exception.  Introduced "
"by :pep:`492`."
msgstr ""
"Ein Objekt, das die Methoden :meth:`~object.__aiter__` "
"und :meth:`~object.__anext__` implementiert. :meth:`~object.__anext__` muss "
"ein :term:`awaitable`-Objekt zurückgeben. :keyword:`async for` verarbeitet "
"die von der Methode :meth:`~object.__anext__` eines asynchronen Iterators "
"zurückgegebenen `awaitables`, bis eine Ausnahme vom "
"Typ :exc:`StopAsyncIteration` ausgelöst wird. Eingeführt durch :pep:`492`."

#: ../../glossary.rst:140
msgid "atomic operation"
msgstr "atomare Operation"

#: ../../glossary.rst:142
msgid ""
"An operation that appears to execute as a single, indivisible step: no other "
"thread can observe it half-done, and its effects become visible all at "
"once.  Python does not guarantee that high-level statements are atomic (for "
"example, ``x += 1`` performs multiple bytecode operations and is not "
"atomic).  Atomicity is only guaranteed where explicitly documented.  See "
"also :term:`race condition` and :term:`data race`."
msgstr ""
"Eine Operation, die scheinbar als ein einziger, unteilbarer Schritt "
"ausgeführt wird: Kein anderer Thread kann sie in einem unvollendeten Zustand "
"beobachten, und ihre Auswirkungen werden auf einmal sichtbar. Python "
"garantiert nicht, dass Anweisungen auf hoher Ebene atomar sind "
"(beispielsweise führt ``x += 1`` mehrere Bytecode-Operationen aus und ist "
"nicht atomar). Atomarität wird nur dort garantiert, wo dies ausdrücklich "
"dokumentiert ist. Siehe auch :term:`Race Condition <race condition>` "
"und :term:`Data Race <data race>`."

#: ../../glossary.rst:148
msgid "attached thread state"
msgstr "angehängter Thread-Zustand"

#: ../../glossary.rst:151
msgid "A :term:`thread state` that is active for the current OS thread."
msgstr ""
"Ein :term:`Thread-Zustand <thread state>`, der für den aktuellen "
"Betriebssystem-Thread aktiv ist."

#: ../../glossary.rst:153
msgid ""
"When a :term:`thread state` is attached, the OS thread has access to the "
"full Python C API and can safely invoke the bytecode interpreter."
msgstr ""
"Wenn ein :term:`Thread-Zustand <thread state>` angehängt ist, hat der "
"Betriebssystem-Thread Zugriff auf die vollständige Python-C-API und kann den "
"Bytecode-Interpreter sicher aufrufen."

#: ../../glossary.rst:157
msgid ""
"Unless a function explicitly notes otherwise, attempting to call the C API "
"without an attached thread state will result in a fatal error or undefined "
"behavior.  A thread state can be attached and detached explicitly by the "
"user through the C API, or implicitly by the runtime, including during "
"blocking C calls and by the bytecode interpreter in between calls."
msgstr ""
"Sofern in einer Funktion nicht ausdrücklich anders angegeben, führt der "
"Versuch, die C-API ohne angehängten Thread-Zustand aufzurufen, zu einem "
"schwerwiegenden Fehler oder zu undefiniertem Verhalten. Ein Thread-Zustand "
"kann vom Benutzer explizit über die C-API angehängt und entfernt werden oder "
"implizit von der Laufzeitumgebung, unter anderem während blockierender C-"
"Aufrufe und durch den Bytecode-Interpreter zwischen den Aufrufen."

#: ../../glossary.rst:164
msgid ""
"On most builds of Python, having an attached thread state implies that the "
"caller holds the :term:`GIL` for the current interpreter, so only one OS "
"thread can have an attached thread state at a given moment. In :term:`free-"
"threaded builds <free-threaded build>` of Python, threads can concurrently "
"hold an attached thread state, allowing for true parallelism of the bytecode "
"interpreter."
msgstr ""
"Bei den meisten Python-Builds bedeutet ein angehängter Thread-Zustand, dass "
"der Aufrufer den :term:`GIL` für den aktuellen Interpreter hält, sodass zu "
"einem bestimmten Zeitpunkt nur ein Betriebssystem-Thread einen angehängten "
"Thread-Zustand haben kann. In :term:`free-threaded-Versionen <free-threaded "
"build>` von Python können mehrere Threads gleichzeitig einen angehängten "
"Thread-Zustand halten, was eine echte Parallelität des Bytecode-Interpreters "
"ermöglicht."

#: ../../glossary.rst:170
msgid "attribute"
msgstr "Attribut"

#: ../../glossary.rst:172
msgid ""
"A value associated with an object which is usually referenced by name using "
"dotted expressions. For example, if an object *o* has an attribute *a* it "
"would be referenced as *o.a*."
msgstr ""
"Ein Wert, der einem Objekt zugeordnet ist und auf den in der Regel mithilfe "
"von Punktnotation unter Angabe des Namens verwiesen wird. Wenn "
"beispielsweise ein Objekt *o* ein Attribut *a* hat, würde darauf als *o.a* "
"verwiesen werden."

#: ../../glossary.rst:177
msgid ""
"It is possible to give an object an attribute whose name is not an "
"identifier as defined by :ref:`identifiers`, for example "
"using :func:`setattr`, if the object allows it. Such an attribute will not "
"be accessible using a dotted expression, and would instead need to be "
"retrieved with :func:`getattr`."
msgstr ""
"Es ist möglich, einem Objekt ein Attribut zuzuweisen, dessen Name kein "
"Bezeichner im Sinne von :ref:`identifiers` ist, beispielsweise mithilfe "
"von :func:`setattr`, sofern das Objekt dies zulässt. Auf ein solches "
"Attribut kann nicht über einen Punktausdruck zugegriffen werden. Stattdessen "
"muss es mit :func:`getattr` abgerufen werden."

#: ../../glossary.rst:182
msgid "awaitable"
msgstr "abwartbar"

#: ../../glossary.rst:184
msgid ""
"An object that can be used in an :keyword:`await` expression.  Can be "
"a :term:`coroutine` or an object with an :meth:`~object.__await__` method. "
"See also :pep:`492`."
msgstr ""
"Ein Objekt, das in einem Ausdruck vom Typ :keyword:`await` verwendet werden "
"kann. Kann eine :term:`coroutine` oder ein Objekt mit einer Methode vom "
"Typ :meth:`~object.__await__` sein. Siehe auch :pep:`492`."

#: ../../glossary.rst:187
msgid "BDFL"
msgstr "BDFL"

#: ../../glossary.rst:189
msgid ""
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://"
"gvanrossum.github.io/>`_, Python's creator."
msgstr ""
"Wohltätiger Diktator auf Lebenszeit, auch bekannt als `Guido van Rossum "
"<https://gvanrossum.github.io/>`_, der Schöpfer von Python."

#: ../../glossary.rst:191
msgid "binary file"
msgstr "Binärdatei"

#: ../../glossary.rst:193
msgid ""
"A :term:`file object` able to read and write :term:`bytes-like objects "
"<bytes-like object>`. Examples of binary files are files opened in binary "
"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer "
"<sys.stdin>`, :data:`sys.stdout.buffer <sys.stdout>`, and instances "
"of :class:`io.BytesIO` and :class:`gzip.GzipFile`."
msgstr ""
"Ein :term:`Dateiobjekt <file object>`, das :term:`byteähnliche Objekte "
"<bytes-like object>` lesen und schreiben kann. Beispiele für Binärdateien "
"sind Dateien, die im Binärmodus geöffnet wurden (``'rb'``, ``'wb'`` oder "
"``'rb+'``), :data:`sys.stdin.buffer <sys.stdin>`, :data:`sys.stdout.buffer "
"<sys.stdout>` sowie Instanzen von :class:`io.BytesIO` "
"und :class:`gzip.GzipFile`."

#: ../../glossary.rst:200
msgid ""
"See also :term:`text file` for a file object able to read and "
"write :class:`str` objects."
msgstr ""
"Siehe auch :term:`Textdatei <text file>` für ein Dateiobjekt, das Objekte "
"vom Typ :class:`str` lesen und schreiben kann."

#: ../../glossary.rst:202
msgid "borrowed reference"
msgstr "entlehnte Referenz"

#: ../../glossary.rst:204
msgid ""
"In Python's C API, a borrowed reference is a reference to an object, where "
"the code using the object does not own the reference. It becomes a dangling "
"pointer if the object is destroyed. For example, a garbage collection can "
"remove the last :term:`strong reference` to the object and so destroy it."
msgstr ""
"In der C-API von Python ist eine ausgeliehene Referenz eine Referenz auf ein "
"Objekt, wobei der Code, der das Objekt verwendet, nicht Eigentümer der "
"Referenz ist. Sie wird zu einem dangling pointer, wenn das Objekt zerstört "
"wird. Beispielsweise kann eine Garbage Collection die letzte :term:`starke "
"Referenz <strong reference>` auf das Objekt entfernen und es so zerstören."

#: ../../glossary.rst:210
msgid ""
"Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended "
"to convert it to a :term:`strong reference` in-place, except when the object "
"cannot be destroyed before the last usage of the borrowed reference. "
"The :c:func:`Py_NewRef` function can be used to create a new :term:`strong "
"reference`."
msgstr ""
"Es wird empfohlen, die Funktion :c:func:`Py_INCREF` auf die :term:`geliehene "
"Referenz <borrowed reference>` anzuwenden, um diese an Ort und Stelle in "
"eine :term:`starke Referenz <strong reference>` umzuwandeln – es sei denn, "
"das Objekt kann nicht vor der letzten Verwendung der geliehenen Referenz "
"zerstört werden. Mit der Funktion :c:func:`Py_NewRef` kann eine "
"neue :term:`starke Referenz <strong reference>` erstellt werden."

#: ../../glossary.rst:215
msgid "bytes-like object"
msgstr "Byte-ähnliches Objekt"

#: ../../glossary.rst:217
msgid ""
"An object that supports the :ref:`bufferobjects` and can export a "
"C-:term:`contiguous` buffer. This includes "
"all :class:`bytes`, :class:`bytearray`, and :class:`array.array` objects, as "
"well as many common :class:`memoryview` objects.  Bytes-like objects can be "
"used for various operations that work with binary data; these include "
"compression, saving to a binary file, and sending over a socket."
msgstr ""
"Ein Objekt, das die Schnittstelle :ref:`bufferobjects` unterstützt und einen "
"C-:term:`zusammenhängenden <contiguous>` Puffer exportieren kann. Dazu "
"gehören alle Objekte vom Typ :class:`bytes`, :class:`bytearray` "
"und :class:`array.array` sowie viele gängige Objekte vom "
"Typ :class:`memoryview`. Bytes-ähnliche Objekte können für verschiedene "
"Operationen verwendet werden, die mit Binärdaten arbeiten. Dazu gehören "
"Komprimierung, das Speichern in einer Binärdatei und das Senden über einen "
"Socket."

#: ../../glossary.rst:224
msgid ""
"Some operations need the binary data to be mutable.  The documentation often "
"refers to these as \"read-write bytes-like objects\".  Example mutable "
"buffer objects include :class:`bytearray` and a :class:`memoryview` of "
"a :class:`bytearray`. Other operations require the binary data to be stored "
"in immutable objects (\"read-only bytes-like objects\"); examples of these "
"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."
msgstr ""
"Bei einigen Operationen müssen die Binärdaten veränderbar sein. In der "
"Dokumentation werden diese häufig als \"les- und schreibbare byteähnliche "
"Objekte\" bezeichnet. Beispiele für veränderbare Pufferobjekte "
"sind :class:`bytearray` und ein :class:`memoryview` eines :class:`bytearray`-"
"Objekts. Andere Operationen erfordern, dass die Binärdaten in "
"unveränderbaren Objekten (read-only bytes-like objects) gespeichert werden; "
"Beispiele hierfür sind :class:`bytes` und ein :class:`memoryview` "
"eines :class:`bytes`-Objekts."

#: ../../glossary.rst:232
msgid "bytecode"
msgstr "Bytecode"

#: ../../glossary.rst:234
msgid ""
"Python source code is compiled into bytecode, the internal representation of "
"a Python program in the CPython interpreter.  The bytecode is also cached in "
"``.pyc`` files so that executing the same file is faster the second time "
"(recompilation from source to bytecode can be avoided).  This \"intermediate "
"language\" is said to run on a :term:`virtual machine` that executes the "
"machine code corresponding to each bytecode. Do note that bytecodes are not "
"expected to work between different Python virtual machines, nor to be stable "
"between Python releases."
msgstr ""
"Python-Quellcode wird zu Bytecode kompiliert, der internen Darstellung eines "
"Python-Programms im CPython-Interpreter. Der Bytecode wird zudem in ``.pyc``-"
"Dateien zwischengespeichert, sodass die Ausführung derselben Datei beim "
"zweiten Mal schneller erfolgt (eine Neukompilierung vom Quellcode zum "
"Bytecode kann vermieden werden). Diese \"Zwischensprache\" läuft auf "
"einer :term:`virtuellen Maschine <virtual machine>`, die den jedem Bytecode "
"entsprechenden Maschinencode ausführt. Beachte jedoch, dass Bytecodes nicht "
"unbedingt zwischen verschiedenen virtuellen Python-Maschinen funktionieren "
"und auch nicht über Python-Versionen hinweg stabil sind."

#: ../../glossary.rst:244
msgid ""
"A list of bytecode instructions can be found in the documentation "
"for :ref:`the dis module <bytecodes>`."
msgstr ""
"Eine Liste der Bytecode-Befehle findest du in der Dokumentation "
"zum :ref:`dis-Modul <bytecodes>`."

#: ../../glossary.rst:246
msgid "callable"
msgstr "abrufbar"

#: ../../glossary.rst:248
msgid ""
"A callable is an object that can be called, possibly with a set of arguments "
"(see :term:`argument`), with the following syntax::"
msgstr ""
"Ein Callable ist ein Objekt, das aufgerufen werden kann, gegebenenfalls mit "
"einer Reihe von Argumenten (siehe :term:`argument`), und zwar mit folgender "
"Syntax::"

#: ../../glossary.rst:251
msgid "callable(argument1, argument2, argumentN)"
msgstr "callable(argument1, argument2, argumentN)"

#: ../../glossary.rst:253
msgid ""
"A :term:`function`, and by extension a :term:`method`, is a callable. An "
"instance of a class that implements the :meth:`~object.__call__` method is "
"also a callable."
msgstr ""
"Eine :term:`Funktion <function>` und im weiteren Sinne auch "
"eine :term:`Methode <method>` ist ein aufrufbares Objekt. Eine Instanz einer "
"Klasse, die die Methode :meth:`~object.__call__` implementiert, ist "
"ebenfalls ein aufrufbares Objekt."

#: ../../glossary.rst:256
msgid "callback"
msgstr "Callback"

#: ../../glossary.rst:258
msgid ""
"A subroutine function which is passed as an argument to be executed at some "
"point in the future."
msgstr ""
"Eine Unterprogrammfunktion, die als Argument übergeben wird, um zu einem "
"späteren Zeitpunkt ausgeführt zu werden."

#: ../../glossary.rst:260
msgid "class"
msgstr "Klasse"

#: ../../glossary.rst:262
msgid ""
"A template for creating user-defined objects. Class definitions normally "
"contain method definitions which operate on instances of the class."
msgstr ""
"Eine Vorlage zum Erstellen benutzerdefinierter Objekte. Klassendefinitionen "
"enthalten in der Regel Methodendefinitionen, die auf Instanzen der Klasse "
"angewendet werden."

#: ../../glossary.rst:265
msgid "class variable"
msgstr "Klassenvariable"

#: ../../glossary.rst:267
msgid ""
"A variable defined in a class and intended to be modified only at class "
"level (i.e., not in an instance of the class)."
msgstr ""
"Eine Variable, die in einer Klasse definiert ist und nur auf Klassenebene "
"(d.h. nicht in einer Instanz der Klasse) geändert werden soll."

#: ../../glossary.rst:269
msgid "closure variable"
msgstr "Closure-Variable"

#: ../../glossary.rst:271
msgid ""
"A :term:`free variable` referenced from a :term:`nested scope` that is "
"defined in an outer scope rather than being resolved at runtime from the "
"globals or builtin namespaces. May be explicitly defined with "
"the :keyword:`nonlocal` keyword to allow write access, or implicitly defined "
"if the variable is only being read."
msgstr ""
"Eine :term:`freie Variable <free variable>`, auf die aus "
"einem :term:`verschachtelten Geltungsbereich <nested scope>` verwiesen wird "
"und die in einem äußeren Geltungsbereich definiert ist, anstatt zur Laufzeit "
"aus den globalen oder integrierten Namensräumen aufgelöst zu werden. Sie "
"kann explizit mit dem Schlüsselwort :keyword:`nonlocal` definiert werden, um "
"Schreibzugriff zu ermöglichen, oder implizit, wenn die Variable nur gelesen "
"wird."

#: ../../glossary.rst:276
msgid ""
"For example, in the ``inner`` function in the following code, both ``x`` and "
"``print`` are :term:`free variables <free variable>`, but only ``x`` is a "
"*closure variable*::"
msgstr ""
"Beispielsweise sind in der Funktion ``inner`` im folgenden Code sowohl ``x`` "
"als auch ``print`` :term:`freie Variablen <free variable>`, aber nur ``x`` "
"ist eine *Closure-Variable*::"

#: ../../glossary.rst:279
msgid ""
"def outer():\n"
"    x = 0\n"
"    def inner():\n"
"        nonlocal x\n"
"        x += 1\n"
"        print(x)\n"
"    return inner"
msgstr ""
"def outer():\n"
"    x = 0\n"
"    def inner():\n"
"        nonlocal x\n"
"        x += 1\n"
"        print(x)\n"
"    return inner"

#: ../../glossary.rst:287
msgid ""
"Due to the :attr:`codeobject.co_freevars` attribute (which, despite its "
"name, only includes the names of closure variables rather than listing all "
"referenced free variables), the more general :term:`free variable` term is "
"sometimes used even when the intended meaning is to refer specifically to "
"closure variables."
msgstr ""
"Aufgrund des Attributs :attr:`codeobject.co_freevars` (das trotz seines "
"Namens lediglich die Namen von Closure-Variablen enthält, anstatt alle "
"referenzierten freien Variablen aufzulisten) wird der allgemeinere "
"Begriff :term:`freie Variable <free variable>` manchmal verwendet, selbst "
"wenn eigentlich speziell auf Closure-Variablen Bezug genommen werden soll."

#: ../../glossary.rst:291
msgid "complex number"
msgstr "komplexe Zahl"

#: ../../glossary.rst:293
msgid ""
"An extension of the familiar real number system in which all numbers are "
"expressed as a sum of a real part and an imaginary part.  Imaginary numbers "
"are real multiples of the imaginary unit (the square root of ``-1``), often "
"written ``i`` in mathematics or ``j`` in engineering.  Python has built-in "
"support for complex numbers, which are written with this latter notation; "
"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``.  To get "
"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`.  "
"Use of complex numbers is a fairly advanced mathematical feature.  If you're "
"not aware of a need for them, it's almost certain you can safely ignore them."
msgstr ""
"Eine Erweiterung des bekannten Systems der reellen Zahlen, in der alle "
"Zahlen als Summe aus einem reellen und einem imaginären Teil ausgedrückt "
"werden. Imaginäre Zahlen sind reelle Vielfache der imaginären Einheit (der "
"Quadratwurzel von ``-1``), die in der Mathematik häufig als ``i`` und im "
"Ingenieurwesen als ``j`` geschrieben werden. Python bietet integrierte "
"Unterstützung für komplexe Zahlen, die in der letztgenannten Notation "
"geschrieben werden. Der Imaginärteil wird mit dem Suffix ``j`` angegeben, z. "
"B. ``3+1j`` . Um auf die komplexen Entsprechungen des Moduls :mod:`math` "
"zuzugreifen, verwende :mod:`cmath` . Die Verwendung komplexer Zahlen ist "
"eine recht fortgeschrittene mathematische Funktion. Wenn du keinen Bedarf "
"dafür siehst, kannst du diese Funktionen mit ziemlicher Sicherheit getrost "
"ignorieren."

#: ../../glossary.rst:303
msgid "concurrency"
msgstr "Gleichzeitigkeit"

#: ../../glossary.rst:305
msgid ""
"The ability of a computer program to perform multiple tasks at the same "
"time.  Python provides libraries for writing programs that make use of "
"different forms of concurrency.  :mod:`asyncio` is a library for dealing "
"with asynchronous tasks and coroutines.  :mod:`threading` provides access to "
"operating system threads and :mod:`multiprocessing` to operating system "
"processes. Multi-core processors can execute threads and processes on "
"different CPU cores at the same time (see :term:`parallelism`)."
msgstr ""
"Die Fähigkeit eines Computerprogramms, mehrere Aufgaben gleichzeitig "
"auszuführen. Python bietet Bibliotheken zum Schreiben von Programmen, die "
"verschiedene Formen der Gleichzeitigkeit nutzen. :mod:`asyncio` ist eine "
"Bibliothek für den Umgang mit asynchronen Aufgaben und "
"Coroutinen. :mod:`threading` bietet Zugriff auf Betriebssystem-Threads "
"und :mod:`multiprocessing` auf Betriebssystem-Prozesse. Multi-Core-"
"Prozessoren können Threads und Prozesse gleichzeitig auf verschiedenen CPU-"
"Kernen ausführen (siehe :term:`Parallelität <parallelism>`)."

#: ../../glossary.rst:313
msgid "concurrent modification"
msgstr "gleichzeitige Änderung"

#: ../../glossary.rst:315
msgid ""
"When multiple threads modify shared data at the same time.  Concurrent "
"modification without proper synchronization can cause :term:`race conditions "
"<race condition>`, and might also trigger a :term:`data race <data race>`, "
"data corruption, or both."
msgstr ""
"Wenn mehrere Threads gleichzeitig gemeinsam genutzte Daten ändern. Eine "
"gleichzeitige Änderung ohne ordnungsgemäße Synchronisation kann "
"zu :term:`Race Conditions <race condition>` führen und möglicherweise auch "
"einen :term:`Datenkonflikt <data race>`, Datenbeschädigungen oder beides "
"auslösen."

#: ../../glossary.rst:319
msgid "context"
msgstr "Kontext"

#: ../../glossary.rst:321
msgid ""
"This term has different meanings depending on where and how it is used. Some "
"common meanings:"
msgstr ""
"Dieser Begriff hat je nach Kontext und Verwendung unterschiedliche "
"Bedeutungen. Einige gängige Bedeutungen:"

#: ../../glossary.rst:324
msgid ""
"The temporary state or environment established by a :term:`context manager` "
"via a :keyword:`with` statement."
msgstr ""
"Der temporäre Zustand oder die Umgebung, die von einem :term:`Context "
"Manager <context manager>` über eine  :keyword:`with`-Anweisung eingerichtet "
"wird."

#: ../../glossary.rst:326
msgid ""
"The collection of key­value bindings associated with a "
"particular :class:`contextvars.Context` object and accessed "
"via :class:`~contextvars.ContextVar` objects.  Also see :term:`context "
"variable`."
msgstr ""
"Die Sammlung von Schlüssel-Wert-Zuordnungen, die einem "
"bestimmten :class:`contextvars.Context`-Objekt zugeordnet sind und "
"über :class:`~contextvars.ContextVar`-Objekte abgerufen werden. Siehe "
"auch :term:`Kontextvariable <context variable>`."

#: ../../glossary.rst:330
msgid ""
"A :class:`contextvars.Context` object.  Also see :term:`current context`."
msgstr ""
"Ein :class:`contextvars.Context`-Objekt. Siehe auch :term:`aktueller Kontext "
"<current context>`."

#: ../../glossary.rst:332
msgid "context management protocol"
msgstr "Kontextverwaltungsprotokoll"

#: ../../glossary.rst:334
msgid ""
"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "
"the :keyword:`with` statement.  See :pep:`343`."
msgstr ""
"Die Methoden :meth:`~object.__enter__` und :meth:`~object.__exit__` , die "
"von der Anweisung :keyword:`with` aufgerufen werden. Siehe :pep:`343`."

#: ../../glossary.rst:336
msgid "context manager"
msgstr "Kontextmanager"

#: ../../glossary.rst:338
msgid ""
"An object which implements the :term:`context management protocol` and "
"controls the environment seen in a :keyword:`with` statement.  "
"See :pep:`343`."
msgstr ""
"Ein Objekt, das das :term:`Kontextverwaltungsprotokoll <context management "
"protocol>` implementiert und die Umgebung steuert, die in "
"einer :keyword:`with`-Anweisung sichtbar ist. Siehe :pep:`343`."

#: ../../glossary.rst:341
msgid "context variable"
msgstr "Kontextvariable"

#: ../../glossary.rst:343
msgid ""
"A variable whose value depends on which context is the :term:`current "
"context`.  Values are accessed via :class:`contextvars.ContextVar` objects.  "
"Context variables are primarily used to isolate state between concurrent "
"asynchronous tasks."
msgstr ""
"Eine Variable, deren Wert davon abhängt, welcher Kontext gerade aktiv ist, "
"wird als :term:`aktueller Kontext <current context>` bezeichnet. Der Zugriff "
"auf die Werte erfolgt über Objekte vom Typ :class:`contextvars.ContextVar` . "
"Kontextvariablen werden in erster Linie dazu verwendet, den Zustand zwischen "
"parallel laufenden asynchronen Aufgaben zu isolieren."

#: ../../glossary.rst:347
msgid "contiguous"
msgstr "zusammenhängend"

#: ../../glossary.rst:351
msgid ""
"A buffer is considered contiguous exactly if it is either *C-contiguous* or "
"*Fortran contiguous*.  Zero-dimensional buffers are C and Fortran "
"contiguous.  In one-dimensional arrays, the items must be laid out in memory "
"next to each other, in order of increasing indexes starting from zero.  In "
"multidimensional C-contiguous arrays, the last index varies the fastest when "
"visiting items in order of memory address.  However, in Fortran contiguous "
"arrays, the first index varies the fastest."
msgstr ""
"Ein Puffer gilt genau dann als zusammenhängend, wenn er entweder *C-"
"zusammenhängend* oder *Fortran-zusammenhängend* ist. Null-dimensionale "
"Puffer sind sowohl C- als auch Fortran-zusammenhängend. In eindimensionalen "
"Arrays müssen die Elemente im Speicher nebeneinander angeordnet sein, und "
"zwar in aufsteigender Reihenfolge der Indizes, beginnend bei Null. In "
"mehrdimensionalen C-zusammenhängenden Arrays ändert sich der letzte Index am "
"schnellsten, wenn die Elemente in der Reihenfolge ihrer Speicheradressen "
"durchlaufen werden. In Fortran-zusammenhängenden Arrays hingegen ändert sich "
"der erste Index am schnellsten."

#: ../../glossary.rst:359
msgid "coroutine"
msgstr "Coroutine"

#: ../../glossary.rst:361
msgid ""
"Coroutines are a more generalized form of subroutines. Subroutines are "
"entered at one point and exited at another point.  Coroutines can be "
"entered, exited, and resumed at many different points.  They can be "
"implemented with the :keyword:`async def` statement.  See also :pep:`492`."
msgstr ""
"Coroutinen sind eine verallgemeinerte Form von Unterprogrammen. "
"Unterprogramme werden an einer Stelle aufgerufen und an einer anderen Stelle "
"beendet. Coroutinen können an vielen verschiedenen Stellen aufgerufen, "
"beendet und fortgesetzt werden. Sie lassen sich mit der "
"Anweisung :keyword:`async def` implementieren. Siehe auch :pep:`492`."

#: ../../glossary.rst:366
msgid "coroutine function"
msgstr "Coroutinen-Funktion"

#: ../../glossary.rst:368
msgid ""
"A function which returns a :term:`coroutine` object.  A coroutine function "
"may be defined with the :keyword:`async def` statement, and may "
"contain :keyword:`await`, :keyword:`async for`, and :keyword:`async with` "
"keywords.  These were introduced by :pep:`492`."
msgstr ""
"Eine Funktion, die ein :term:`coroutine`-Objekt zurückgibt. Eine Coroutine-"
"Funktion kann mit der Anweisung :keyword:`async def` definiert werden und "
"die Schlüsselwörter :keyword:`await`, :keyword:`async for` "
"sowie :keyword:`async with` enthalten. Diese wurden mit :pep:`492` "
"eingeführt."

#: ../../glossary.rst:373
msgid "CPython"
msgstr "CPython"

#: ../../glossary.rst:375
msgid ""
"The canonical implementation of the Python programming language, as "
"distributed on `python.org <https://www.python.org>`_.  The term \"CPython\" "
"is used when necessary to distinguish this implementation from others such "
"as Jython or IronPython."
msgstr ""
"Die kanonische Implementierung der Programmiersprache Python, wie sie auf "
"`python.org <https://www.python.org>`_ bereitgestellt wird. Der Begriff "
"\"CPython\" wird bei Bedarf verwendet, um diese Implementierung von anderen "
"wie Jython oder IronPython zu unterscheiden."

#: ../../glossary.rst:379
msgid "current context"
msgstr "aktueller Kontext"

#: ../../glossary.rst:381
msgid ""
"The :term:`context` (:class:`contextvars.Context` object) that is currently "
"used by :class:`~contextvars.ContextVar` objects to access (get or set) the "
"values of :term:`context variables <context variable>`.  Each thread has its "
"own current context.  Frameworks for executing asynchronous tasks "
"(see :mod:`asyncio`) associate each task with a context which becomes the "
"current context whenever the task starts or resumes execution."
msgstr ""
"Der :term:`Kontext <context>` (:class:`contextvars.Context`-Objekt), der "
"derzeit von :class:`~contextvars.ContextVar`-Objekten verwendet wird, um auf "
"die Werte von :term:`Kontextvariablen <context variable>` zuzugreifen "
"(abzurufen oder festzulegen). Jeder Thread verfügt über einen eigenen "
"aktuellen Kontext. Frameworks zur Ausführung asynchroner Aufgaben "
"(siehe :mod:`asyncio`) ordnen jeder Aufgabe einen Kontext zu, der zum "
"aktuellen Kontext wird, sobald die Aufgabe ihre Ausführung beginnt oder "
"fortsetzt."

#: ../../glossary.rst:387
msgid "cyclic isolate"
msgstr "zyklisches Isolat"

#: ../../glossary.rst:389
msgid ""
"A subgroup of one or more objects that reference each other in a reference "
"cycle, but are not referenced by objects outside the group.  The goal of "
"the :term:`cyclic garbage collector <garbage collection>` is to identify "
"these groups and break the reference cycles so that the memory can be "
"reclaimed."
msgstr ""
"Eine Untergruppe aus einem oder mehreren Objekten, die sich in einem "
"Referenzzyklus gegenseitig referenzieren, aber von Objekten außerhalb der "
"Gruppe nicht referenziert werden. Das Ziel des :term:`zyklischen Garbage "
"Collectors <garbage collection>` besteht darin, diese Gruppen zu "
"identifizieren und die Referenzzyklen aufzubrechen, damit der Speicher "
"freigegeben werden kann."

#: ../../glossary.rst:393
msgid "data race"
msgstr "Datenkonflikt"

#: ../../glossary.rst:395
msgid ""
"A situation where multiple threads access the same memory location "
"concurrently, at least one of the accesses is a write, and the threads do "
"not use any synchronization to control their access.  Data races lead "
"to :term:`non-deterministic` behavior and can cause data corruption. Proper "
"use of :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` prevents data races.  Note that data races can "
"only happen in native code, but that :term:`native code` might be exposed in "
"a Python API.  See also :term:`race condition` and :term:`thread-safe`."
msgstr ""
"Eine Situation, in der mehrere Threads gleichzeitig auf dieselbe "
"Speicherstelle zugreifen, mindestens einer der Zugriffe ein Schreibzugriff "
"ist und die Threads keine Synchronisierung verwenden, um ihren Zugriff zu "
"steuern. Datenkonflikte führen zu :term:`nicht deterministischem <non-"
"deterministic>` Verhalten und können Datenkorruption verursachen. Der "
"richtige Einsatz von :term:`Sperren <lock>` und "
"anderen :term:`Synchronisationsprimitiven <synchronization primitive>` "
"verhindert Datenkonflikte. Beachte, dass Datenkonflikte nur in nativem Code "
"auftreten können, dass :term:`nativer Code <native code>` jedoch in einer "
"Python-API zugänglich gemacht werden kann. Siehe auch :term:`Race-Condition "
"<race condition>` und :term:`thread-sicher <thread-safe>`."

#: ../../glossary.rst:404
msgid "deadlock"
msgstr "Pattsituation"

#: ../../glossary.rst:406
msgid ""
"A situation in which two or more tasks (threads, processes, or coroutines) "
"wait indefinitely for each other to release resources or complete actions, "
"preventing any from making progress.  For example, if thread A holds lock 1 "
"and waits for lock 2, while thread B holds lock 2 and waits for lock 1, both "
"threads will wait indefinitely.  In Python this often arises from acquiring "
"multiple locks in conflicting orders or from circular join/await "
"dependencies.  Deadlocks can be avoided by always acquiring "
"multiple :term:`locks <lock>` in a consistent order.  See also :term:`lock` "
"and :term:`reentrant`."
msgstr ""
"Eine Situation, in der zwei oder mehr Aufgaben (Threads, Prozesse oder "
"Coroutinen) unbegrenzt darauf warten, dass die jeweils anderen Ressourcen "
"freigeben oder Aktionen abschließen, wodurch keine der Aufgaben vorankommt. "
"Wenn beispielsweise Thread A die Sperre 1 hält und auf die Sperre 2 wartet, "
"während Thread B die Sperre 2 hält und auf die Sperre 1 wartet, werden beide "
"Threads auf unbestimmte Zeit warten. In Python entsteht dies häufig durch "
"das Erlangen mehrerer Sperren in widersprüchlicher Reihenfolge oder durch "
"zirkuläre join/await-Abhängigkeiten. Deadlocks lassen sich vermeiden, indem "
"mehrere :term:`Sperren <lock>` stets in einer konsistenten Reihenfolge "
"erworben werden. Siehe auch :term:`Sperre <lock>` und :term:`reentrant`."

#: ../../glossary.rst:415
msgid "decorator"
msgstr "Dekorator"

#: ../../glossary.rst:417
msgid ""
"A function returning another function, usually applied as a function "
"transformation using the ``@wrapper`` syntax.  Common examples for "
"decorators are :deco:`classmethod` and :deco:`staticmethod`."
msgstr ""
"Eine Funktion, die eine andere Funktion zurückgibt und in der Regel als "
"Funktionstransformation mithilfe der Syntax ``@wrapper`` angewendet wird. "
"Gängige Beispiele für Dekoratoren sind :deco:`classmethod` "
"und :deco:`staticmethod`."

#: ../../glossary.rst:421
msgid ""
"The decorator syntax is merely syntactic sugar, the following two function "
"definitions are semantically equivalent::"
msgstr ""
"Die Dekorator-Syntax ist lediglich Syntactic Sugar. Die folgenden beiden "
"Funktionsdefinitionen sind semantisch gleichbedeutend::"

#: ../../glossary.rst:424
msgid ""
"def f(arg):\n"
"    ...\n"
"f = staticmethod(f)\n"
"\n"
"@staticmethod\n"
"def f(arg):\n"
"    ..."
msgstr ""
"def f(arg):\n"
"    ...\n"
"f = staticmethod(f)\n"
"\n"
"@staticmethod\n"
"def f(arg):\n"
"    ..."

#: ../../glossary.rst:432
msgid ""
"The same concept exists for classes, but is less commonly used there.  See "
"the documentation for :ref:`function definitions <function>` and :ref:`class "
"definitions <class>` for more about decorators."
msgstr ""
"Das gleiche Konzept gibt es auch für Klassen, wird dort jedoch seltener "
"verwendet. Weitere Informationen zu Dekoratoren findest du in der "
"Dokumentation zu :ref:`Funktionsdefinitionen <function>` "
"und :ref:`Klassendefinitionen <class>`."

#: ../../glossary.rst:435
msgid "descriptor"
msgstr "Deskriptor"

#: ../../glossary.rst:437
msgid ""
"Any object which defines the "
"methods :meth:`~object.__get__`, :meth:`~object.__set__`, "
"or :meth:`~object.__delete__`. When a class attribute is a descriptor, its "
"special binding behavior is triggered upon attribute lookup.  Normally, "
"using *a.b* to get, set or delete an attribute looks up the object named *b* "
"in the class dictionary for *a*, but if *b* is a descriptor, the respective "
"descriptor method gets called.  Understanding descriptors is a key to a deep "
"understanding of Python because they are the basis for many features "
"including functions, methods, properties, class methods, static methods, and "
"reference to super classes."
msgstr ""
"Jedes Objekt, das die "
"Methoden :meth:`~object.__get__`, :meth:`~object.__set__` "
"oder :meth:`~object.__delete__` definiert. Wenn ein Klassenattribut ein "
"Deskriptor ist, wird sein spezielles Bindungsverhalten bei der Attributsuche "
"ausgelöst. Normalerweise wird bei der Verwendung von *a.b* zum Abrufen, "
"Setzen oder Löschen eines Attributs das Objekt mit dem Namen *b* im Klassen-"
"Dictionary von *a* nachgeschlagen. Ist *b* jedoch ein Deskriptor, wird die "
"entsprechende Deskriptormethode aufgerufen. Das Verständnis von Deskriptoren "
"ist der Schlüssel zu einem tiefgreifenden Verständnis von Python, da sie die "
"Grundlage für viele Sprachmerkmale bilden, darunter Funktionen, Methoden, "
"Properties, Klassenmethoden, statische Methoden und Verweise auf Oberklassen."

#: ../../glossary.rst:448
msgid ""
"For more information about descriptors' methods, see :ref:`descriptors` or "
"the :ref:`Descriptor How To Guide <descriptorhowto>`."
msgstr ""
"Weitere Informationen zu den Methoden von Deskriptoren findest du "
"unter :ref:`descriptors` oder im :ref:`Descriptor How To Guide "
"<descriptorhowto>`."

#: ../../glossary.rst:450
msgid "dictionary"
msgstr "Dictionary"

#: ../../glossary.rst:452
msgid ""
"An associative array, where arbitrary keys are mapped to values.  The keys "
"can be any object with :meth:`~object.__hash__` and :meth:`~object.__eq__` "
"methods. Called a hash in Perl."
msgstr ""
"Ein assoziatives Array, bei dem beliebige Schlüssel Werten zugeordnet "
"werden. Die Schlüssel können beliebige Objekte sein, die über die "
"Methoden :meth:`~object.__hash__` und :meth:`~object.__eq__` verfügen. In "
"Perl wird dies als Hash bezeichnet."

#: ../../glossary.rst:456
msgid "dictionary comprehension"
msgstr "Dictionary Comprehension"

#: ../../glossary.rst:458
msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a dictionary with the results. ``results = {n: n ** 2 for n in "
"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n "
"** 2``. See :ref:`comprehensions`."
msgstr ""
"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente eines "
"iterierbaren Objekts zu verarbeiten und ein Dictionary mit den Ergebnissen "
"zurückzugeben. ``results = {n: n ** 2 for n in range(10)}`` erzeugt ein "
"Dictionary, in dem der Schlüssel ``n`` auf den Wert ``n ** 2`` abgebildet "
"wird. Siehe :ref:`comprehensions`."

#: ../../glossary.rst:462
msgid "dictionary view"
msgstr "Dictionary-View"

#: ../../glossary.rst:464
msgid ""
"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, "
"and :meth:`dict.items` are called dictionary views. They provide a dynamic "
"view on the dictionary’s entries, which means that when the dictionary "
"changes, the view reflects these changes. To force the dictionary view to "
"become a full list use ``list(dictview)``.  See :ref:`dict-views`."
msgstr ""
"Die Objekte, die von den Methoden :meth:`dict.keys` , :meth:`dict.values` "
"und :meth:`dict.items` zurückgegeben werden, werden als Dictionary-Ansichten "
"bezeichnet. Sie bieten eine dynamische Ansicht der Einträge im Dictionary, "
"was bedeutet, dass sich Änderungen am Dictionary unmittelbar in der Ansicht "
"widerspiegeln. Um die Dictionary-Ansicht zwangsweise in eine vollständige "
"Liste umzuwandeln, verwende ``list(dictview)``. Siehe :ref:`dict-views`."

#: ../../glossary.rst:470
msgid "docstring"
msgstr "Docstring"

#: ../../glossary.rst:472
msgid ""
"A string literal which appears as the first expression in a class, function "
"or module.  While ignored when the suite is executed, it is recognized by "
"the compiler and put into the :attr:`~definition.__doc__` attribute of the "
"enclosing class, function or module.  Since it is available via "
"introspection, it is the canonical place for documentation of the object."
msgstr ""
"Eine Zeichenkette, das als erster Ausdruck in einer Klasse, Funktion oder "
"einem Modul erscheint. Es wird zwar bei der Ausführung der Suite ignoriert, "
"jedoch vom Compiler erkannt und in das Attribut :attr:`~definition.__doc__` "
"der umschließenden Klasse, Funktion oder des Moduls übernommen. Da es über "
"Introspektion verfügbar ist, stellt es den kanonischen Ort für die "
"Dokumentation des Objekts dar."

#: ../../glossary.rst:478
msgid "duck-typing"
msgstr "Duck-Typing"

#: ../../glossary.rst:480
msgid ""
"A programming style which does not look at an object's type to determine if "
"it has the right interface; instead, the method or attribute is simply "
"called or used (\"If it looks like a duck and quacks like a duck, it must be "
"a duck.\")  By emphasizing interfaces rather than specific types, well-"
"designed code improves its flexibility by allowing polymorphic "
"substitution.  Duck-typing avoids tests using :func:`type` "
"or :func:`isinstance`.  (Note, however, that duck-typing can be complemented "
"with :term:`abstract base classes <abstract base class>`.)  Instead, it "
"typically employs :func:`hasattr` tests or :term:`EAFP` programming."
msgstr ""
"Ein Programmierstil, bei dem nicht der Typ eines Objekts herangezogen wird, "
"um festzustellen, ob es über die richtige Schnittstelle verfügt. Stattdessen "
"wird die Methode oder das Attribut einfach aufgerufen bzw. verwendet (\"Wenn "
"es wie eine Ente aussieht und wie eine Ente quakt, muss es eine Ente sein."
"\") Durch die Betonung von Schnittstellen anstelle spezifischer Typen "
"verbessert gut gestalteter Code seine Flexibilität, indem er polymorphe "
"Substitution ermöglicht. Duck-Typing vermeidet Tests mit :func:`type` "
"oder :func:`isinstance` . (Beachte jedoch, dass Duck-Typing "
"durch :term:`abstrakte Basisklassen <abstract base class>` ergänzt werden "
"kann.) Stattdessen werden typischerweise :func:`hasattr`-Tests "
"oder :term:`EAFP`-Programmierung eingesetzt."

#: ../../glossary.rst:489
msgid "dunder"
msgstr "Dunder"

#: ../../glossary.rst:491
msgid ""
"An informal short-hand for \"double underscore\", used when talking about "
"a :term:`special method`. For example, ``__init__`` is often pronounced "
"\"dunder init\"."
msgstr ""
"Eine umgangssprachliche Abkürzung für \"doppelter Unterstrich\", die "
"verwendet wird, wenn von einer :term:`speziellen Methode <special method>` "
"die Rede ist. So wird beispielsweise  ``__init__``  oft als \"dunder init\" "
"ausgesprochen."

#: ../../glossary.rst:494
msgid "EAFP"
msgstr "EAFP"

#: ../../glossary.rst:496
msgid ""
"Easier to ask for forgiveness than permission.  This common Python coding "
"style assumes the existence of valid keys or attributes and catches "
"exceptions if the assumption proves false.  This clean and fast style is "
"characterized by the presence of many :keyword:`try` and :keyword:`except` "
"statements.  The technique contrasts with the :term:`LBYL` style common to "
"many other languages such as C."
msgstr ""
"Es ist einfacher, um Verzeihung zu bitten als um Erlaubnis. Dieser gängige "
"Python-Programmierstil geht von der Existenz gültiger Schlüssel oder "
"Attribute aus und fängt Ausnahmen ab, falls sich diese Annahme als falsch "
"erweist. Dieser übersichtliche und schnelle Stil zeichnet sich durch das "
"häufige Vorkommen von :keyword:`try`- und :keyword:`except`-Anweisungen aus. "
"Diese Technik steht im Gegensatz zum :term:`LBYL`-Stil, der in vielen "
"anderen Sprachen wie beispielsweise C üblich ist."

#: ../../glossary.rst:502
msgid "evaluate function"
msgstr "Funktion auswerten"

#: ../../glossary.rst:504
msgid ""
"A function that can be called to evaluate a lazily evaluated attribute of an "
"object, such as the value of type aliases created with the :keyword:`type` "
"statement."
msgstr ""
"Eine Funktion, die aufgerufen werden kann, um ein verzögert ausgewertetes "
"Attribut eines Objekts zu berechnen, beispielsweise den Wert von Typaliasen, "
"die mit der Anweisung  :keyword:`type` erstellt wurden."

#: ../../glossary.rst:507
msgid "exhausted"
msgstr "erschöpft"

#: ../../glossary.rst:509
msgid ""
"An :term:`iterator` that has produced all of its values is said to "
"be :dfn:`exhausted`. Further attempts to get the next value (for example, "
"calls to :func:`next`) raise :exc:`StopIteration` "
"(or :exc:`StopAsyncIteration` in the case of an :term:`asynchronous "
"iterator`)."
msgstr ""
"Ein :term:`iterator`, der alle seine Werte produziert hat, wird "
"als :dfn:`exhausted` bezeichnet. Weitere Versuche, den nächsten Wert "
"abzurufen (zum Beispiel Aufrufe von :func:`next`), "
"lösen :exc:`StopIteration` aus (bzw. :exc:`StopAsyncIteration` im Fall "
"eines :term:`asynchronous iterator`)."

#: ../../glossary.rst:515
msgid "expression"
msgstr "Ausdruck"

#: ../../glossary.rst:517
msgid ""
"A piece of syntax which can be evaluated to some value.  In other words, an "
"expression is an accumulation of expression elements like literals, names, "
"attribute access, operators or function calls which all return a value.  Not "
"all language constructs are expressions.  There are "
"also :term:`statement`\\s which cannot be used as expressions, such "
"as :keyword:`while`.  Assignments are also statements, not expressions."
msgstr ""
"Ein Syntaxelement, das zu einem Wert ausgewertet werden kann. Mit anderen "
"Worten: Ein Ausdruck ist eine Zusammenstellung von Ausdruckselementen wie "
"Literalen, Namen, Attributzugriffen, Operatoren oder Funktionsaufrufen, die "
"alle einen Wert zurückgeben. Nicht alle Sprachkonstrukte sind Ausdrücke. Es "
"gibt auch :term:`Anweisungen <statement>`\\s, die nicht als Ausdrücke "
"verwendet werden können, wie beispielsweise :keyword:`while`. Auch "
"Zuweisungen sind Anweisungen und keine Ausdrücke."

#: ../../glossary.rst:524
msgid "extension module"
msgstr "Erweiterungsmodul"

#: ../../glossary.rst:526
msgid ""
"A module written in C or C++, using Python's C API to interact with the core "
"and with user code."
msgstr ""
"Ein in C oder C++ geschriebenes Modul, das die C-API von Python nutzt, um "
"mit dem Kern und dem Anwendercode zu interagieren."

#: ../../glossary.rst:528
msgid "f-string"
msgstr "f-String"

#: ../../glossary.rst:529
msgid "f-strings"
msgstr "f-Strings"

#: ../../glossary.rst:531
msgid ""
"String literals prefixed with ``f`` or ``F`` are commonly called \"f-"
"strings\" which is short for :ref:`formatted string literals <f-strings>`.  "
"See also :pep:`498`."
msgstr ""
"Zeichenketten, denen  ``f``  oder  ``F``  vorangestellt ist, werden "
"gemeinhin als \"f-Strings\" bezeichnet, was die Abkürzung "
"für :ref:`formatierte Zeichenfolgenliterale <f-strings>` ist. Siehe "
"auch :pep:`498`."

#: ../../glossary.rst:534
msgid "file object"
msgstr "Dateiobjekt"

#: ../../glossary.rst:536
msgid ""
"An object exposing a file-oriented API (with methods such as :meth:`!read` "
"or :meth:`!write`) to an underlying resource.  Depending on the way it was "
"created, a file object can mediate access to a real on-disk file or to "
"another type of storage or communication device (for example standard input/"
"output, in-memory buffers, sockets, pipes, etc.).  File objects are also "
"called :dfn:`file-like objects` or :dfn:`streams`."
msgstr ""
"Ein Objekt, das eine dateiorientierte API (mit Methoden wie :meth:`!read` "
"oder :meth:`!write` ) für eine zugrunde liegende Ressource bereitstellt. Je "
"nach Art seiner Erstellung kann ein Dateiobjekt den Zugriff auf eine echte "
"Datei auf der Festplatte oder auf eine andere Art von Speicher- oder "
"Kommunikationsgerät vermitteln (z. B. Standardeingabe/-ausgabe, Puffer im "
"Arbeitsspeicher, Sockets, Pipes usw.). Dateiobjekte werden auch "
"als :dfn:`dateiähnliche Objekte <file-like objects>` oder :dfn:`Streams "
"<streams>` bezeichnet."

#: ../../glossary.rst:544
msgid ""
"There are actually three categories of file objects: raw :term:`binary files "
"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "
"files <text file>`. Their interfaces are defined in the :mod:`io` module.  "
"The canonical way to create a file object is by using the :func:`open` "
"function."
msgstr ""
"Es gibt insgesamt drei Kategorien von Dateiobjekten: "
"rohe :term:`Binärdateien <binary file>`, gepufferte :term:`Binärdateien "
"<binary file>` und :term:`Textdateien <text file>`. Deine Schnittstellen "
"sind im Modul :mod:`io` definiert. Die übliche Vorgehensweise zum Erstellen "
"eines Dateiobjekts ist die Verwendung der Funktion :func:`open` ."

#: ../../glossary.rst:549
msgid "file-like object"
msgstr "dateiähnliches Objekt"

#: ../../glossary.rst:551
msgid "A synonym for :term:`file object`."
msgstr "Ein Synonym für :term:`Dateiobjekt <file object>`."

#: ../../glossary.rst:552
msgid "filesystem encoding and error handler"
msgstr "Dateisystem-Kodierung und Fehlerbehandlung"

#: ../../glossary.rst:554
msgid ""
"Encoding and error handler used by Python to decode bytes from the operating "
"system and encode Unicode to the operating system."
msgstr ""
"Von Python verwendete Kodierung und Fehlerbehandlung zum Dekodieren von "
"Bytes aus dem Betriebssystem und zum Kodieren von Unicode für das "
"Betriebssystem."

#: ../../glossary.rst:557
msgid ""
"The filesystem encoding must guarantee to successfully decode all bytes "
"below 128. If the file system encoding fails to provide this guarantee, API "
"functions can raise :exc:`UnicodeError`."
msgstr ""
"Die Dateisystemkodierung muss gewährleisten, dass alle Bytes unter 128 "
"erfolgreich dekodiert werden. Wenn die Dateisystemkodierung diese Garantie "
"nicht bieten kann, können API-Funktionen die Ausnahme :exc:`UnicodeError` "
"auslösen."

#: ../../glossary.rst:561
msgid ""
"The :func:`sys.getfilesystemencoding` "
"and :func:`sys.getfilesystemencodeerrors` functions can be used to get the "
"filesystem encoding and error handler."
msgstr ""
"Mit den Funktionen :func:`sys.getfilesystemencoding` "
"und :func:`sys.getfilesystemencodeerrors` lassen sich die Kodierung des "
"Dateisystems und der Fehlerbehandler abrufen."

#: ../../glossary.rst:565
msgid ""
"The :term:`filesystem encoding and error handler` are configured at Python "
"startup by the :c:func:`PyConfig_Read` function: "
"see :c:member:`~PyConfig.filesystem_encoding` "
"and :c:member:`~PyConfig.filesystem_errors` members of :c:type:`PyConfig`."
msgstr ""
"Die :term:`Dateisystem-Kodierung und der Fehlerbehandler <filesystem "
"encoding and error handler>` werden beim Start von Python über die "
"Funktion :c:func:`PyConfig_Read` konfiguriert: "
"siehe :c:member:`~PyConfig.filesystem_encoding` "
"und :c:member:`~PyConfig.filesystem_errors`, die zu :c:type:`PyConfig` "
"gehören."

#: ../../glossary.rst:570
msgid "See also the :term:`locale encoding`."
msgstr ""
"Siehe auch den Begriff :term:`Lokalisierungskodierung <locale encoding>`."

#: ../../glossary.rst:571
msgid "finder"
msgstr "Finder"

#: ../../glossary.rst:573
msgid ""
"An object that tries to find the :term:`loader` for a module that is being "
"imported."
msgstr ""
"Ein Objekt, das versucht, den :term:`loader` für ein Modul zu finden, das "
"gerade importiert wird."

#: ../../glossary.rst:576
msgid ""
"There are two types of finder: :term:`meta path finders <meta path finder>` "
"for use with :data:`sys.meta_path`, and :term:`path entry finders <path "
"entry finder>` for use with :data:`sys.path_hooks`."
msgstr ""
"Es gibt zwei Arten von Suchfunktionen: :term:`Meta-Pfad-Suchfunktionen <meta "
"path finder>` zur Verwendung mit :data:`sys.meta_path` sowie :term:`Pfad-"
"Eingabe-Suchfunktionen <path entry finder>` zur Verwendung "
"mit :data:`sys.path_hooks`."

#: ../../glossary.rst:580
msgid ""
"See :ref:`finders-and-loaders` and :mod:`importlib` for much more detail."
msgstr ""
"Weitere Informationen findest du unter :ref:`finders-and-loaders` "
"und :mod:`importlib`."

#: ../../glossary.rst:581
msgid "floor division"
msgstr "Ganzzahldivision"

#: ../../glossary.rst:583
msgid ""
"Mathematical division that rounds down to nearest integer.  The floor "
"division operator is ``//``.  For example, the expression ``11 // 4`` "
"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "
"division.  Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "
"rounded *downward*. See :pep:`238`."
msgstr ""
"Mathematische Division, bei der auf die nächste ganze Zahl abgerundet wird. "
"Der Operator für die Floor-Division lautet ``//``. Der Ausdruck ``11 // 4`` "
"ergibt beispielsweise ``2`` – im Gegensatz zu ``2.75``, das bei einer echten "
"Float-Division zurückgegeben wird. Beachte, dass ``(-11) // 4`` gleich "
"``-3`` ist, da es sich dabei um ``-2.75`` handelt, das *nach unten* "
"abgerundet wurde. Siehe :pep:`238`."

#: ../../glossary.rst:588
msgid "free threading"
msgstr "freies Threading"

#: ../../glossary.rst:590
msgid ""
"A threading model where multiple threads can run Python bytecode "
"simultaneously within the same interpreter.  This is in contrast to "
"the :term:`global interpreter lock` which allows only one thread to execute "
"Python bytecode at a time.  See :pep:`703`."
msgstr ""
"Ein Threading-Modell, bei dem mehrere Threads Python-Bytecode gleichzeitig "
"innerhalb desselben Interpreters ausführen können. Dies steht im Gegensatz "
"zum :term:`global interpreter lock`, bei dem jeweils nur ein Thread Python-"
"Bytecode ausführen kann. Siehe :pep:`703`."

#: ../../glossary.rst:594
msgid "free-threaded build"
msgstr "Build mit freien Threads"

#: ../../glossary.rst:597
msgid ""
"A build of :term:`CPython` that supports :term:`free threading`, configured "
"using the :option:`--disable-gil` option before compilation."
msgstr ""
"Eine Version von :term:`CPython`, die :term:`Free Threading <free "
"threading>` unterstützt und vor der Kompilierung mit der Option :option:`--"
"disable-gil` konfiguriert wurde."

#: ../../glossary.rst:600
msgid "See :ref:`freethreading-python-howto`."
msgstr "Siehe :ref:`freethreading-python-howto`."

#: ../../glossary.rst:601
msgid "free variable"
msgstr "freie Variable"

#: ../../glossary.rst:603
msgid ""
"Formally, as defined in the :ref:`language execution model <bind_names>`, a "
"free variable is any variable used in a namespace which is not a local "
"variable in that namespace. See :term:`closure variable` for an example. "
"Pragmatically, due to the name of the :attr:`codeobject.co_freevars` "
"attribute, the term is also sometimes used as a synonym for :term:`closure "
"variable`."
msgstr ""
"Formal gesehen ist, gemäß der Definition im :ref:`Sprachausführungsmodell "
"<bind_names>`, eine freie Variable jede Variable, die in einem Namensraum "
"verwendet wird und keine lokale Variable in diesem Namensraum ist. Ein "
"Beispiel findest du unter :term:`Closure-Variable <closure variable>`. In "
"der Praxis wird der Begriff aufgrund des Namens des "
"Attributs :attr:`codeobject.co_freevars` manchmal auch als Synonym "
"für :term:`Closure-Variable <closure variable>` verwendet."

#: ../../glossary.rst:608
msgid "function"
msgstr "Funktion"

#: ../../glossary.rst:610
msgid ""
"A series of statements which returns some value to a caller. It can also be "
"passed zero or more :term:`arguments <argument>` which may be used in the "
"execution of the body. See also :term:`parameter`, :term:`method`, and "
"the :ref:`function` section."
msgstr ""
"Eine Anweisungsfolge, die einen Wert an den Aufrufer zurückgibt. Ihr können "
"zudem null oder mehr :term:`Argumente <argument>` übergeben werden, die bei "
"der Ausführung des Hauptteils verwendet werden können. Siehe "
"auch :term:`Parameter <parameter>`, :term:`Methode <method>` sowie den "
"Abschnitt :ref:`function` ."

#: ../../glossary.rst:614
msgid "function annotation"
msgstr "Funktionsannotation"

#: ../../glossary.rst:616
msgid "An :term:`annotation` of a function parameter or return value."
msgstr ""
"Eine :term:`Annotation <annotation>` eines Funktionsparameters oder eines "
"Rückgabewerts."

#: ../../glossary.rst:618
msgid ""
"Function annotations are usually used for :term:`type hints <type hint>`: "
"for example, this function is expected to take two :class:`int` arguments "
"and is also expected to have an :class:`int` return value::"
msgstr ""
"Funktionsannotationen werden in der Regel für :term:`Typangaben <type "
"hint>`: verwendet. Beispielsweise wird erwartet, dass diese Funktion "
"zwei :class:`int` Argumente entgegennimmt und zudem einen :class:`int` "
"Rückgabewert hat::"

#: ../../glossary.rst:623
msgid ""
"def sum_two_numbers(a: int, b: int) -> int:\n"
"   return a + b"
msgstr ""
"def sum_two_numbers(a: int, b: int) -> int:\n"
"   return a + b"

#: ../../glossary.rst:626
msgid "Function annotation syntax is explained in section :ref:`function`."
msgstr ""
"Die Syntax für Funktionsannotationen wird im Abschnitt :ref:`function` "
"erläutert."

#: ../../glossary.rst:628
msgid ""
"See :term:`variable annotation` and :pep:`484`, which describe this "
"functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Siehe :term:`Variablen-Annotation <variable annotation>` und :pep:`484`, wo "
"diese Funktionalität beschrieben wird. Siehe außerdem :ref:`annotations-"
"howto` für bewährte Vorgehensweisen beim Umgang mit Annotationen."

#: ../../glossary.rst:632
msgid "__future__"
msgstr "__Zukunft__"

#: ../../glossary.rst:634
msgid ""
"A :ref:`future statement <future>`, ``from __future__ import <feature>``, "
"directs the compiler to compile the current module using syntax or semantics "
"that will become standard in a future release of Python. "
"The :mod:`__future__` module documents the possible values of *feature*.  By "
"importing this module and evaluating its variables, you can see when a new "
"feature was first added to the language and when it will (or did) become the "
"default::"
msgstr ""
"Eine :ref:`Future-Anweisung <future>`, ``from __future__ import <feature>``, "
"weist den Compiler an, das aktuelle Modul unter Verwendung einer Syntax oder "
"Semantik zu kompilieren, die in einer zukünftigen Version von Python zum "
"Standard werden wird. Das Modul :mod:`__future__` dokumentiert die möglichen "
"Werte von *feature*. Durch Importieren dieses Moduls und Auswerten seiner "
"Variablen kannst du sehen, wann eine neue Funktion erstmals in die Sprache "
"aufgenommen wurde und wann sie zur Standardeinstellung wird (oder wurde)::"

#: ../../glossary.rst:642
msgid ""
">>> import __future__\n"
">>> __future__.division\n"
"_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)"
msgstr ""
">>> import __future__\n"
">>> __future__.division\n"
"_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)"

#: ../../glossary.rst:645
msgid "garbage collection"
msgstr "Garbage Collection"

#: ../../glossary.rst:647
msgid ""
"The process of freeing memory when it is not used anymore.  Python performs "
"garbage collection via reference counting and a cyclic garbage collector "
"that is able to detect and break reference cycles.  The garbage collector "
"can be controlled using the :mod:`gc` module."
msgstr ""
"Der Vorgang, bei dem Speicher freigegeben wird, wenn er nicht mehr benötigt "
"wird. Python führt die Speicherbereinigung mithilfe der Referenzzählung und "
"eines zyklischen Garbage Collectors durch, der Referenzzyklen erkennen und "
"auflösen kann. Der Garbage Collector lässt sich über das Modul :mod:`gc` "
"steuern."

#: ../../glossary.rst:652 ../../glossary.rst:653
msgid "generator"
msgstr "Generator"

#: ../../glossary.rst:655
msgid ""
"Informally used to mean either a :term:`generator function` or "
"a :term:`generator iterator`, depending on context.  The formal "
"terms :term:`generator function` and :term:`generator iterator` are uncommon "
"in practice; \"generator\" alone is almost always sufficient."
msgstr ""
"Wird umgangssprachlich je nach Kontext entweder für "
"eine :term:`Generatorfunktion <generator function>` oder "
"einen :term:`Generator-Iterator <generator iterator>` verwendet. Die "
"formalen Begriffe :term:`Generatorfunktion <generator function>` "
"und :term:`Generator-Iterator <generator iterator>` sind in der Praxis "
"selten. Der Begriff \"Generator\" allein reicht fast immer aus."

#: ../../glossary.rst:660 ../../glossary.rst:661
msgid "generator function"
msgstr "Generatorfunktion"

#: ../../glossary.rst:663
msgid ""
"A function which returns a :term:`generator` object.  It looks like a normal "
"function except that it contains :keyword:`yield` expressions for producing "
"a series of values usable in a :keyword:`for`\\-loop or that can be "
"retrieved one at a time with the :func:`next` function. See :ref:`yieldexpr`."
msgstr ""
"Eine Funktion, die ein :term:`generator`-Objekt zurückgibt. Sie sieht wie "
"eine normale Funktion aus, enthält jedoch Ausdrücke vom "
"Typ :keyword:`yield` , um eine Reihe von Werten zu erzeugen, die in "
"einer :keyword:`for`\\-Schleife verwendet oder mit der Funktion :func:`next` "
"einzeln abgerufen werden können. Siehe :ref:`yieldexpr`."

#: ../../glossary.rst:668
msgid "generator iterator"
msgstr "Generator-Iterator"

#: ../../glossary.rst:670
msgid ""
"An object created by a :term:`generator function` or a :term:`generator "
"expression`."
msgstr ""
"Ein Objekt, das durch eine :term:`Generatorfunktion <generator function>` "
"oder einen :term:`Generatorausdruck <generator expression>` erstellt wurde."

#: ../../glossary.rst:673
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"execution state (including local variables and pending try-statements). When "
"the *generator iterator* resumes, it picks up where it left off (in contrast "
"to functions which start fresh on every invocation)."
msgstr ""
"Jeder :keyword:`yield` unterbricht die Verarbeitung vorübergehend und "
"speichert dabei den Ausführungszustand (einschließlich lokaler Variablen und "
"ausstehender try-Anweisungen). Wenn der *Generator-Iterator* fortgesetzt "
"wird, setzt er dort fort, wo er aufgehört hat (im Gegensatz zu Funktionen, "
"die bei jedem Aufruf von vorne beginnen)."

#: ../../glossary.rst:678
msgid ""
"Generator iterators also implement the :meth:`~generator.send` method to "
"send a value into the suspended generator, and the :meth:`~generator.throw` "
"method to raise an exception at the point where the generator was paused.  "
"See :ref:`generator-methods`."
msgstr ""
"Generator-Iteratoren implementieren außerdem die "
"Methode :meth:`~generator.send` , um einen Wert an den angehaltenen "
"Generator zu übergeben, sowie die Methode :meth:`~generator.throw` , um an "
"der Stelle, an der der Generator angehalten wurde, eine Ausnahme auszulösen. "
"Siehe :ref:`generator-methods`."

#: ../../glossary.rst:683 ../../glossary.rst:684
msgid "generator expression"
msgstr "Generatorausdruck"

#: ../../glossary.rst:686
msgid ""
"An :term:`expression` that returns an :term:`iterator`.  It looks like a "
"normal expression followed by a :keyword:`!for` clause defining a loop "
"variable, range, and an optional :keyword:`!if` clause.  The combined "
"expression generates values for an enclosing function::"
msgstr ""
"Ein :term:`Ausdruck <expression>`, der einen :term:`Iterator <iterator>` "
"zurückgibt. Er sieht aus wie ein normaler Ausdruck, gefolgt von "
"einer :keyword:`!for`-Klausel, die eine Schleifenvariable und einen Bereich "
"definiert, sowie einer optionalen :keyword:`!if`-Klausel. Der kombinierte "
"Ausdruck generiert Werte für eine umschließende Funktion::"

#: ../../glossary.rst:691
msgid ""
">>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81\n"
"285"
msgstr ""
">>> sum(i*i for i in range(10))         # Summe der Quadrate von 0, 1, "
"4, ..., 81\n"
"285"

#: ../../glossary.rst:693
msgid "generic function"
msgstr "generische Funktion"

#: ../../glossary.rst:695
msgid ""
"A function composed of multiple functions implementing the same operation "
"for different types. Which implementation should be used during a call is "
"determined by the dispatch algorithm."
msgstr ""
"Eine Funktion, die aus mehreren Funktionen besteht, welche dieselbe "
"Operation für verschiedene Typen implementieren. Welche Implementierung bei "
"einem Aufruf verwendet werden soll, wird durch den Dispatch-Algorithmus "
"bestimmt."

#: ../../glossary.rst:699
msgid ""
"See also the :term:`single dispatch` glossary entry, "
"the :deco:`functools.singledispatch` decorator, and :pep:`443`."
msgstr ""
"Siehe auch den Glossareintrag :term:`single dispatch`, den "
"Dekorator :deco:`functools.singledispatch` sowie :pep:`443`."

#: ../../glossary.rst:701
msgid "generic type"
msgstr "generischer Typ"

#: ../../glossary.rst:703
msgid ""
"A :term:`type` that can be parameterized; typically a :ref:`container "
"class<sequence-types>` such as :class:`list` or :class:`dict`. Used "
"for :term:`type hints <type hint>` and :term:`annotations <annotation>`."
msgstr ""
"Ein :term:`Typ <type>`, der parametrisiert werden kann. Typischerweise "
"eine :ref:`Containerklasse<sequence-types>` wie beispielsweise :class:`list` "
"oder :class:`dict`. Wird für :term:`Typ-Hinweise <type hint>` "
"und :term:`Annotationen <annotation>` verwendet."

#: ../../glossary.rst:708
msgid ""
"For more details, see :ref:`generic alias types<types-"
"genericalias>`, :pep:`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` "
"module."
msgstr ""
"Weitere Informationen findest du unter :ref:`generische Alias-Typen<types-"
"genericalias>`, :pep:`483`, :pep:`484`, :pep:`585` sowie im "
"Modul :mod:`typing` ."

#: ../../glossary.rst:710
msgid "GIL"
msgstr "GIL"

#: ../../glossary.rst:712
msgid "See :term:`global interpreter lock`."
msgstr "Siehe :term:`Global Interpreter Lock <global interpreter lock>`."

#: ../../glossary.rst:713
msgid "global interpreter lock"
msgstr "Global Interpreter Lock"

#: ../../glossary.rst:715
msgid ""
"The mechanism used by the :term:`CPython` interpreter to assure that only "
"one thread executes Python :term:`bytecode` at a time. This simplifies the "
"CPython implementation by making the object model (including critical built-"
"in types such as :class:`dict`) implicitly safe against concurrent access.  "
"Locking the entire interpreter makes it easier for the interpreter to be "
"multi-threaded, at the expense of much of the parallelism afforded by multi-"
"processor machines."
msgstr ""
"Der Mechanismus, den der :term:`CPython`-Interpreter verwendet, um "
"sicherzustellen, dass jeweils nur ein Thread Python-:term:`Bytecode "
"<bytecode>` ausführt. Dies vereinfacht die CPython-Implementierung, indem "
"das Objektmodell (einschließlich kritischer integrierter Typen "
"wie :class:`dict`) implizit gegen gleichzeitigen Zugriff abgesichert wird. "
"Das Sperren des gesamten Interpreters erleichtert die Multithread-Fähigkeit "
"des Interpreters, geht jedoch zu Lasten eines Großteils der Parallelität, "
"die Multiprozessor-Rechner bieten."

#: ../../glossary.rst:724
msgid ""
"However, some extension modules, either standard or third-party, are "
"designed so as to release the GIL when doing computationally intensive tasks "
"such as compression or hashing.  Also, the GIL is always released when doing "
"I/O."
msgstr ""
"Manche Erweiterungsmodule – aus der Standardbibliothek oder von Dritten – "
"sind allerdings so angelegt, dass sie das GIL freigeben, während sie "
"rechenintensive Aufgaben wie Komprimierung oder Hashing ausführen. Außerdem "
"wird das GIL bei I/O-Operationen immer freigegeben."

#: ../../glossary.rst:729
msgid ""
"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil` "
"build configuration. This feature enables improved performance for multi-"
"threaded applications and makes it easier to use multi-core CPUs "
"efficiently. For more details, see :pep:`703`."
msgstr ""
"Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration :option:`--"
"disable-gil` deaktiviert werden. Diese Funktion ermöglicht eine verbesserte "
"Leistung für Multithread-Anwendungen und erleichtert die effiziente Nutzung "
"von Multi-Core-CPUs. Weitere Details findest du unter :pep:`703`."

#: ../../glossary.rst:734
msgid ""
"In prior versions of Python's C API, a function might declare that it "
"requires the GIL to be held in order to use it. This refers to having "
"an :term:`attached thread state`."
msgstr ""
"In früheren Versionen der C-API von Python konnte eine Funktion angeben, "
"dass für ihre Verwendung das GIL gesperrt sein muss. Dies bezieht sich auf "
"einen :term:`angeschlossenen Thread-Zustand <attached thread state>`."

#: ../../glossary.rst:737
msgid "global state"
msgstr "globaler Zustand"

#: ../../glossary.rst:739
msgid ""
"Data that is accessible throughout a program, such as module-level "
"variables, class variables, or C static variables in :term:`extension "
"modules <extension module>`.  In multi-threaded programs, global state "
"shared between threads typically requires synchronization to "
"avoid :term:`race conditions <race condition>` and :term:`data races <data "
"race>`."
msgstr ""
"Daten, auf die im gesamten Programm zugegriffen werden kann, wie "
"beispielsweise Variablen auf Modulebene, Klassenvariablen oder statische C-"
"Variablen in :term:`Erweiterungsmodulen <extension module>`. In Multithread-"
"Programmen erfordert der zwischen Threads gemeinsam genutzte globale Zustand "
"in der Regel eine Synchronisation, um :term:`Wettlaufbedingungen <race "
"condition>` und :term:`Datenwettläufe <data race>` zu vermeiden."

#: ../../glossary.rst:745
msgid "hash-based pyc"
msgstr "Hash-basierte PYC-Datei"

#: ../../glossary.rst:747
msgid ""
"A bytecode cache file that uses the hash rather than the last-modified time "
"of the corresponding source file to determine its validity. See :ref:`pyc-"
"invalidation`."
msgstr ""
"Eine Bytecode-Cache-Datei, die zur Überprüfung ihrer Gültigkeit den Hashwert "
"anstelle des Zeitstempels der letzten Änderung der entsprechenden Quelldatei "
"heranzieht. Siehe :ref:`pyc-invalidation`."

#: ../../glossary.rst:750
msgid "hashable"
msgstr "hashbar"

#: ../../glossary.rst:752
msgid ""
"An object is *hashable* if it has a hash value which never changes during "
"its lifetime (it needs a :meth:`~object.__hash__` method), and can be "
"compared to other objects (it needs an :meth:`~object.__eq__` method). "
"Hashable objects which compare equal must have the same hash value."
msgstr ""
"Ein Objekt ist *hashbar*, wenn es einen Hash-Wert besitzt, der sich während "
"seiner Lebensdauer nicht ändert (es benötigt eine :meth:`~object.__hash__`-"
"Methode), und wenn es mit anderen Objekten verglichen werden kann (es "
"benötigt eine :meth:`~object.__eq__`-Methode). Hashbare Objekte, die als "
"gleich verglichen werden, müssen denselben Hashwert haben."

#: ../../glossary.rst:758
msgid ""
"Hashability makes an object usable as a dictionary key and a set member, "
"because these data structures use the hash value internally."
msgstr ""
"Dank der Hashbarkeit kann ein Objekt als Schlüssel in einem Dictionary und "
"als Element in einer Menge verwendet werden, da diese Datenstrukturen intern "
"den Hashwert nutzen."

#: ../../glossary.rst:761
msgid ""
"Most of Python's immutable built-in objects are hashable; mutable containers "
"(such as lists or dictionaries) are not; immutable containers (such as "
"tuples and frozensets) are only hashable if their elements are hashable.  "
"Objects which are instances of user-defined classes are hashable by "
"default.  They all compare unequal (except with themselves), and their hash "
"value is derived from their :func:`id`."
msgstr ""
"Die meisten unveränderlichen, in Python integrierten Objekte sind hashbar. "
"Veränderbare Container (wie Listen oder Dictionarys) sind es nicht. "
"Unveränderliche Container (wie Tupel und Frozensets) sind nur dann hashbar, "
"wenn ihre Elemente hashbar sind. Objekte, die Instanzen benutzerdefinierter "
"Klassen sind, sind standardmäßig hashbar. Sie sind alle ungleich (außer mit "
"sich selbst), und ihr Hashwert wird aus ihrer :func:`id` abgeleitet."

#: ../../glossary.rst:768
msgid "IDLE"
msgstr "IDLE"

#: ../../glossary.rst:770
msgid ""
"An Integrated Development and Learning Environment for Python. :ref:`idle` "
"is a basic editor and interpreter environment which ships with the standard "
"distribution of Python."
msgstr ""
"Eine integrierte Entwicklungs- und Lernumgebung für Python. :ref:`idle` ist "
"eine einfache Editor- und Interpreter-Umgebung, die im Lieferumfang der "
"Standarddistribution von Python enthalten ist."

#: ../../glossary.rst:773
msgid "immortal"
msgstr "unsterblich"

#: ../../glossary.rst:775
msgid ""
"*Immortal objects* are a CPython implementation detail introduced "
"in :pep:`683`."
msgstr ""
"*Unsterbliche Objekte* sind ein Implementierungsdetail von CPython, das "
"in :pep:`683` eingeführt wurde."

#: ../../glossary.rst:778
msgid ""
"If an object is immortal, its :term:`reference count` is never modified, and "
"therefore it is never deallocated while the interpreter is running. For "
"example, :const:`True` and :const:`None` are immortal in CPython."
msgstr ""
"Ist ein Objekt unsterblich, wird seine :term:`Referenzanzahl <reference "
"count>` niemals geändert, sodass es während der Laufzeit des Interpreters "
"niemals freigegeben wird. Beispielsweise sind :const:`True` "
"und :const:`None` in CPython unsterblich."

#: ../../glossary.rst:782
msgid ""
"Immortal objects can be identified via :func:`sys._is_immortal`, or "
"via :c:func:`PyUnstable_IsImmortal` in the C API."
msgstr ""
"Unsterbliche Objekte können über :func:`sys._is_immortal` oder "
"über :c:func:`PyUnstable_IsImmortal` in der C-API identifiziert werden."

#: ../../glossary.rst:784
msgid "immutable"
msgstr "unveränderlich"

#: ../../glossary.rst:786
msgid ""
"An object with a fixed value.  Immutable objects include numbers, strings "
"and tuples.  Such an object cannot be altered.  A new object has to be "
"created if a different value has to be stored.  They play an important role "
"in places where a constant hash value is needed, for example as a key in a "
"dictionary.  Immutable objects are inherently :term:`thread-safe` because "
"their state cannot be modified after creation, eliminating concerns about "
"improperly synchronized :term:`concurrent modification`."
msgstr ""
"Ein Objekt mit einem festen Wert. Zu den unveränderlichen Objekten zählen "
"Zahlen, Zeichenketten und Tupel. Ein solches Objekt kann nicht verändert "
"werden. Wenn ein anderer Wert gespeichert werden soll, muss ein neues Objekt "
"erstellt werden. Sie spielen eine wichtige Rolle in Fällen, in denen ein "
"konstanter Hashwert benötigt wird, beispielsweise als Schlüssel in einem "
"Wörterbuch. Unveränderliche Objekte sind von Natur aus :term:`thread-sicher "
"<thread-safe>`, da ihr Zustand nach der Erstellung nicht mehr geändert "
"werden kann, wodurch Bedenken hinsichtlich unsachgemäß "
"synchronisierter :term:`gleichzeitiger Änderungen <concurrent modification>` "
"entfallen."

#: ../../glossary.rst:793
msgid "import path"
msgstr "Importpfad"

#: ../../glossary.rst:795
msgid ""
"A list of locations (or :term:`path entries <path entry>`) that are searched "
"by the :term:`path based finder` for modules to import. During import, this "
"list of locations usually comes from :data:`sys.path`, but for subpackages "
"it may also come from the parent package's ``__path__`` attribute."
msgstr ""
"Eine Liste von Speicherorten (oder :term:`Pfadeinträge <path entry>`), die "
"vom :term:`Pfad-basierten Finder <path based finder>` nach zu importierenden "
"Modulen durchsucht werden. Beim Import stammt diese Liste der Speicherorte "
"in der Regel aus :data:`sys.path`, bei Unterpaketen kann sie jedoch auch aus "
"dem Attribut ``__path__`` des übergeordneten Pakets stammen."

#: ../../glossary.rst:800
msgid "importing"
msgstr "Importieren"

#: ../../glossary.rst:802
msgid ""
"The process by which Python code in one module is made available to Python "
"code in another module."
msgstr ""
"Der Vorgang, durch den Python-Code in einem Modul für Python-Code in einem "
"anderen Modul verfügbar gemacht wird."

#: ../../glossary.rst:804
msgid "importer"
msgstr "Importeur"

#: ../../glossary.rst:806
msgid ""
"An object that both finds and loads a module; both a :term:`finder` "
"and :term:`loader` object."
msgstr ""
"Ein Objekt, das sowohl ein Modul findet als auch lädt. Es ist sowohl "
"ein :term:`Finder <finder>`- als auch ein :term:`Loader <loader>`-Objekt."

#: ../../glossary.rst:808
msgid "index"
msgstr "Index"

#: ../../glossary.rst:810
msgid ""
"A numeric value that represents the position of an element in "
"a :term:`sequence`."
msgstr ""
"Ein numerischer Wert, der die Position eines Elements in "
"einer :term:`Sequenz <sequence>` angibt."

#: ../../glossary.rst:813
msgid ""
"In Python, indexing starts at zero. For example, ``things[0]`` names the "
"*first* element of ``things``; ``things[1]`` names the second one."
msgstr ""
"In Python beginnt die Indizierung bei Null. So bezeichnet beispielsweise "
"``things[0]`` das *erste* Element von ``things`` ; ``things[1]`` bezeichnet "
"das zweite Element."

#: ../../glossary.rst:817
msgid ""
"In some contexts, Python allows negative indexes for counting from the end "
"of a sequence, and indexing using :term:`slices <slice>`."
msgstr ""
"In bestimmten Kontexten erlaubt Python negative Indizes, um vom Ende einer "
"Sequenz aus zu zählen, sowie die Indizierung mithilfe von :term:`Slices "
"<slice>`."

#: ../../glossary.rst:820
msgid "See also :term:`subscript`."
msgstr "Siehe auch :term:`Index <subscript>`."

#: ../../glossary.rst:821
msgid "interactive"
msgstr "interaktiv"

#: ../../glossary.rst:823
msgid ""
"Python has an interactive interpreter which means you can enter statements "
"and expressions at the interpreter prompt, immediately execute them and see "
"their results.  Just launch ``python`` with no arguments (possibly by "
"selecting it from your computer's main menu). It is a very powerful way to "
"test out new ideas or inspect modules and packages (remember ``help(x)``). "
"For more on interactive mode, see :ref:`tut-interac`."
msgstr ""
"Python hat einen interaktiven Interpreter, das heißt, du kannst Anweisungen "
"und Ausdrücke an der Eingabeaufforderung des Interpreters eingeben, sie "
"sofort ausführen und ihre Ergebnisse sehen. Starte dazu einfach ``python`` "
"ohne Argumente (eventuell über das Hauptmenü deines Rechners). Das ist eine "
"sehr wirkungsvolle Möglichkeit, neue Ideen auszuprobieren oder Module und "
"Pakete zu untersuchen (denk an ``help(x)``). Mehr zum interaktiven Modus "
"findest du unter :ref:`tut-interac`."

#: ../../glossary.rst:830
msgid "interpreted"
msgstr "interpretiert"

#: ../../glossary.rst:832
msgid ""
"Python is an interpreted language, as opposed to a compiled one, though the "
"distinction can be blurry because of the presence of the bytecode compiler.  "
"This means that source files can be run directly without explicitly creating "
"an executable which is then run. Interpreted languages typically have a "
"shorter development/debug cycle than compiled ones, though their programs "
"generally also run more slowly.  See also :term:`interactive`."
msgstr ""
"Python ist eine interpretierte Sprache im Gegensatz zu einer kompilierten "
"Sprache, auch wenn diese Unterscheidung aufgrund des Bytecode-Compilers "
"nicht immer eindeutig ist. Das bedeutet, dass Quelldateien direkt ausgeführt "
"werden können, ohne dass zuvor explizit eine ausführbare Datei erstellt und "
"anschließend ausgeführt werden muss. Interpretierte Sprachen haben in der "
"Regel einen kürzeren Entwicklungs- und Debugging-Zyklus als kompilierte "
"Sprachen, allerdings laufen ihre Programme im Allgemeinen auch langsamer. "
"Siehe auch :term:`interaktiv <interactive>`."

#: ../../glossary.rst:839
msgid "interpreter shutdown"
msgstr "Beenden des Interpreters"

#: ../../glossary.rst:841
msgid ""
"When asked to shut down, the Python interpreter enters a special phase where "
"it gradually releases all allocated resources, such as modules and various "
"critical internal structures.  It also makes several calls to "
"the :term:`garbage collector <garbage collection>`. This can trigger the "
"execution of code in user-defined destructors or weakref callbacks. Code "
"executed during the shutdown phase can encounter various exceptions as the "
"resources it relies on may not function anymore (common examples are library "
"modules or the warnings machinery)."
msgstr ""
"Wenn der Python-Interpreter zum Beenden aufgefordert wird, wechselt er in "
"eine spezielle Phase, in der er nach und nach alle zugewiesenen Ressourcen, "
"wie beispielsweise Module und verschiedene wichtige interne Strukturen, "
"freigibt. Außerdem ruft er mehrmals den :term:`Garbage Collector <garbage "
"collection>` auf. Dies kann die Ausführung von Code in benutzerdefinierten "
"Destruktoren oder weakref-Callbacks auslösen. Bei der Ausführung von Code "
"während der Beendigungsphase können verschiedene Ausnahmen auftreten, da die "
"Ressourcen, auf die er angewiesen ist, möglicherweise nicht mehr "
"funktionieren (häufige Beispiele sind Bibliotheksmodule oder die "
"Warnmechanismen)."

#: ../../glossary.rst:850
msgid ""
"The main reason for interpreter shutdown is that the ``__main__`` module or "
"the script being run has finished executing."
msgstr ""
"Der Hauptgrund für das Beenden des Interpreters ist, dass das Modul "
"``__main__`` oder das ausgeführte Skript die Ausführung abgeschlossen hat."

#: ../../glossary.rst:852
msgid "iterable"
msgstr "iterierbar"

#: ../../glossary.rst:854
msgid ""
"An object capable of returning its members one at a time. Examples of "
"iterables include all sequence types (such as :class:`list`, :class:`str`, "
"and :class:`tuple`) and some non-sequence types "
"like :class:`dict`, :term:`file objects <file object>`, and objects of any "
"classes you define with an :meth:`~object.__iter__` method or with "
"a :meth:`~object.__getitem__` method that implements :term:`sequence` "
"semantics."
msgstr ""
"Ein Objekt, das seine Elemente nacheinander zurückgeben kann. Beispiele für "
"iterierbare Objekte sind alle Sequenztypen (wie :class:`list`, :class:`str` "
"und :class:`tuple`) sowie einige Nicht-Sequenztypen "
"wie :class:`dict`, :term:`Dateiobjekte <file object>` und Objekte beliebiger "
"Klassen, die du mit einer :meth:`~object.__iter__`-Methode oder "
"einer :meth:`~object.__getitem__`-Methode definieren, die "
"die :term:`sequence`-Semantik implementiert."

#: ../../glossary.rst:862
msgid ""
"Iterables can be used in a :keyword:`for` loop and in many other places "
"where a sequence is needed (:func:`zip`, :func:`map`, ...).  When an "
"iterable object is passed as an argument to the built-in "
"function :func:`iter`, it returns an iterator for the object.  This iterator "
"is good for one pass over the set of values.  When using iterables, it is "
"usually not necessary to call :func:`iter` or deal with iterator objects "
"yourself.  The :keyword:`for` statement does that automatically for you, "
"creating a temporary unnamed variable to hold the iterator for the duration "
"of the loop.  See also :term:`iterator`, :term:`sequence`, "
"and :term:`generator`."
msgstr ""
"Iterables können in einer :keyword:`for`-Schleife und an vielen anderen "
"Stellen verwendet werden, an denen eine Sequenz benötigt wird "
"(:func:`zip`, :func:`map`, …). Wenn ein iterierbares Objekt als Argument an "
"die integrierte Funktion :func:`iter` übergeben wird, gibt diese einen "
"Iterator für das Objekt zurück. Dieser Iterator reicht für einen Durchlauf "
"durch die Wertemenge aus. Bei der Verwendung von Iterables ist es in der "
"Regel nicht notwendig, :func:`iter` aufzurufen oder sich selbst um Iterator-"
"Objekte zu kümmern. Die Anweisung :keyword:`for` übernimmt dies automatisch "
"für dich und erstellt eine temporäre, unbenannte Variable, die den Iterator "
"für die Dauer der Schleife enthält. Siehe "
"auch :term:`iterator`, :term:`sequence` und :term:`generator`."

#: ../../glossary.rst:872
msgid "iterator"
msgstr "Iterator"

#: ../../glossary.rst:874
msgid ""
"An object representing a stream of data.  Repeated calls to the "
"iterator's :meth:`~iterator.__next__` method (or passing it to the built-in "
"function :func:`next`) return successive items in the stream.  When no more "
"data are available a :exc:`StopIteration` exception is raised instead.  At "
"this point, the iterator object is :term:`exhausted` and any further calls "
"to its :meth:`!__next__` method just raise :exc:`StopIteration` again.  "
"Iterators are required to have an :meth:`~iterator.__iter__` method that "
"returns the iterator object itself so every iterator is also iterable and "
"may be used in most places where other iterables are accepted.  One notable "
"exception is code which attempts multiple iteration passes.  A container "
"object (such as a :class:`list`) produces a fresh new iterator each time you "
"pass it to the :func:`iter` function or use it in a :keyword:`for` loop.  "
"Attempting this with an iterator will just return the same exhausted "
"iterator object used in the previous iteration pass, making it appear like "
"an empty container."
msgstr ""
"Ein Objekt, das einen Datenstrom darstellt. Wiederholte Aufrufe der "
"Methode :meth:`~iterator.__next__` des Iterators (oder die Übergabe an die "
"integrierte Funktion :func:`next`) geben aufeinanderfolgende Elemente des "
"Datenstroms zurück. Sind keine Daten mehr verfügbar, wird stattdessen die "
"Ausnahme :exc:`StopIteration` ausgelöst. Zu diesem Zeitpunkt ist das "
"Iteratorobjekt :term:`erschöpft <exhausted>`, und weitere Aufrufe seiner "
"Methode :meth:`!__next__` lösen lediglich erneut die "
"Ausnahme :exc:`StopIteration` aus. Iteratoren müssen eine "
"Methode :meth:`~iterator.__iter__` haben, die das Iteratorobjekt selbst "
"zurückgibt, sodass jeder Iterator auch iterierbar ist und an den meisten "
"Stellen verwendet werden kann, an denen andere iterierbare Objekte "
"akzeptiert werden. Eine bemerkenswerte Ausnahme bildet Code, der mehrere "
"Iterationsdurchläufe versucht. Ein Containerobjekt (etwa eine :class:`list`) "
"erzeugt jedes Mal einen neuen Iterator, wenn du es an die "
"Funktion :func:`iter` übergibst oder in einer :keyword:`for`-Schleife "
"verwendest. Versuchst du dies mit einem Iterator, wird lediglich dasselbe "
"erschöpfte Iteratorobjekt zurückgegeben, das bereits im vorherigen "
"Iterationsdurchlauf verwendet wurde, wodurch es so aussieht, als wäre der "
"Container leer."

#: ../../glossary.rst:889
msgid "More information can be found in :ref:`typeiter`."
msgstr "Weitere Informationen findest du unter :ref:`typeiter`."

#: ../../glossary.rst:893
msgid ""
"CPython does not consistently apply the requirement that an iterator "
"define :meth:`~iterator.__iter__`. And also please note that :term:`free-"
"threaded <free threading>` CPython does not guarantee :term:`thread-safe` "
"behavior of iterator operations."
msgstr ""
"CPython wendet die Anforderung, dass ein Iterator :meth:`~iterator.__iter__` "
"definieren muss, nicht konsequent an. Beachte außerdem, dass :term:`free-"
"threaded <free threading>` CPython kein :term:`thread-sicheres <thread-"
"safe>` Verhalten von Iterator-Operationen garantiert."

#: ../../glossary.rst:898
msgid "key"
msgstr "Schlüssel"

#: ../../glossary.rst:900
msgid ""
"A value that identifies an entry in a :term:`mapping`. See "
"also :term:`subscript`."
msgstr ""
"Ein Wert, der einen Eintrag in einem :term:`Mapping <mapping>` "
"identifiziert. Siehe auch :term:`Index <subscript>`."

#: ../../glossary.rst:902
msgid "key function"
msgstr "Schlüsselfunktion"

#: ../../glossary.rst:904
msgid ""
"A key function or collation function is a callable that returns a value used "
"for sorting or ordering.  For example, :func:`locale.strxfrm` is used to "
"produce a sort key that is aware of locale specific sort conventions."
msgstr ""
"Eine Schlüsselfunktion oder Sortierfunktion ist ein aufrufbares Objekt, das "
"einen Wert zurückgibt, der zum Sortieren oder Ordnen verwendet wird. "
"Beispielsweise wird :func:`locale.strxfrm` verwendet, um einen "
"Sortierschlüssel zu erzeugen, der die lokalspezifischen Sortierkonventionen "
"berücksichtigt."

#: ../../glossary.rst:909
msgid ""
"A number of tools in Python accept key functions to control how elements are "
"ordered or grouped.  They "
"include :func:`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq.nlargest`, "
"and :func:`itertools.groupby`."
msgstr ""
"Eine Reihe von Tools in Python unterstützt Schlüssel-Funktionen, mit denen "
"sich die Anordnung oder Gruppierung von Elementen steuern lässt. Dazu "
"gehören :func:`min` , :func:`max` , :func:`sorted` , :meth:`list.sort` , :func:`heapq.merge` , :func:`heapq.nsmallest` , :func:`heapq.nlargest` "
"und :func:`itertools.groupby` ."

#: ../../glossary.rst:915
msgid ""
"There are several ways to create a key function.  For example. "
"the :meth:`str.casefold` method can serve as a key function for case "
"insensitive sorts.  Alternatively, a key function can be built from "
"a :keyword:`lambda` expression such as ``lambda r: (r[0], r[2])``.  "
"Also, :func:`operator.attrgetter`, :func:`operator.itemgetter`, "
"and :func:`operator.methodcaller` are three key function constructors.  See "
"the :ref:`Sorting HOW TO <sortinghowto>` for examples of how to create and "
"use key functions."
msgstr ""
"Es gibt verschiedene Möglichkeiten, eine Schlüsselfunktion zu erstellen. "
"Beispielsweise kann die Methode :meth:`str.casefold` als Schlüsselfunktion "
"für die Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung dienen. "
"Alternativ kann eine Schlüsselfunktion aus einem Ausdruck vom "
"Typ :keyword:`lambda` erstellt werden, wie beispielsweise ``lambda r: (r[0], "
"r[2])``. Außerdem "
"sind :func:`operator.attrgetter`, :func:`operator.itemgetter` "
"und :func:`operator.methodcaller` drei Konstruktoren für "
"Schlüsselfunktionen. Beispiele für die Erstellung und Verwendung von "
"Schlüsselfunktionen findest du im :ref:`Sorting HOW TO <sortinghowto>`."

#: ../../glossary.rst:922
msgid "keyword argument"
msgstr "Schlüsselwortargument"

#: ../../glossary.rst:924 ../../glossary.rst:1311
msgid "See :term:`argument`."
msgstr "Siehe :term:`Argument <argument>`."

#: ../../glossary.rst:925
msgid "lambda"
msgstr "Lambda"

#: ../../glossary.rst:927
msgid ""
"An anonymous inline function consisting of a single :term:`expression` which "
"is evaluated when the function is called.  The syntax to create a lambda "
"function is ``lambda [parameters]: expression``"
msgstr ""
"Eine anonyme Inline-Funktion, die aus einem einzigen :term:`Ausdruck "
"<expression>` besteht, der beim Aufruf der Funktion ausgewertet wird. Die "
"Syntax zum Erstellen einer Lambda-Funktion lautet ``lambda [parameters]: "
"expression``"

#: ../../glossary.rst:930
msgid "LBYL"
msgstr "LBYL"

#: ../../glossary.rst:932
msgid ""
"Look before you leap.  This coding style explicitly tests for pre-conditions "
"before making calls or lookups.  This style contrasts with the :term:`EAFP` "
"approach and is characterized by the presence of many :keyword:`if` "
"statements."
msgstr ""
"Look before you leap (schau hin, bevor du springst). Dieser Programmierstil "
"prüft Vorbedingungen ausdrücklich, bevor Aufrufe oder Zugriffe erfolgen. Er "
"bildet den Gegensatz zum Ansatz :term:`EAFP` und ist durch "
"viele :keyword:`if`-Anweisungen gekennzeichnet."

#: ../../glossary.rst:937
msgid ""
"In a multi-threaded environment, the LBYL approach can risk introducing "
"a :term:`race condition` between \"the looking\" and \"the leaping\".  For "
"example, the code, ``if key in mapping: return mapping[key]`` can fail if "
"another thread removes *key* from *mapping* after the test, but before the "
"lookup. This issue can be solved with :term:`locks <lock>` or by using "
"the :term:`EAFP` approach.  See also :term:`thread-safe`."
msgstr ""
"In einer Multithread-Umgebung besteht bei dem LBYL-Ansatz die Gefahr, dass "
"eine :term:`Race-Condition <race condition>` zwischen dem \"Nachschlagen\" "
"und dem \"Springen\" entsteht. Beispielsweise kann der Code ``if key in "
"mapping: return mapping[key]`` fehlschlagen, wenn ein anderer Thread *key* "
"nach dem Test, aber vor der Suche aus *mapping* entfernt. Dieses Problem "
"lässt sich mit :term:`Sperren <lock>` oder durch Verwendung des :term:`EAFP`-"
"Ansatzes lösen. Siehe auch :term:`thread-sicher <thread-safe>`."

#: ../../glossary.rst:943
msgid "lexical analyzer"
msgstr "Lexikalischer Analysator"

#: ../../glossary.rst:946
msgid "Formal name for the *tokenizer*; see :term:`token`."
msgstr "Formale Bezeichnung für den *Tokenizer*. Siehe :term:`token`."

#: ../../glossary.rst:947
msgid "list"
msgstr "Liste"

#: ../../glossary.rst:949
msgid ""
"A built-in Python :term:`sequence`.  Despite its name it is more akin to an "
"array in other languages than to a linked list since access to elements is "
"*O*\\ (1).  See :ref:`time-complexity`."
msgstr ""
"Eine integrierte Python-:term:`Sequenz <sequence>`. Trotz ihres Namens "
"ähnelt sie eher einem Array in anderen Sprachen als einer verketteten Liste, "
"da der Zugriff auf Elemente *O*\\ (1) ist. Siehe :ref:`time-complexity`."

#: ../../glossary.rst:952
msgid "list comprehension"
msgstr "List Comprehension"

#: ../../glossary.rst:954
msgid ""
"A compact way to process all or part of the elements in a sequence and "
"return a list with the results.  ``result = ['{:#04x}'.format(x) for x in "
"range(256) if x % 2 == 0]`` generates a list of strings containing even hex "
"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is "
"optional.  If omitted, all elements in ``range(256)`` are processed."
msgstr ""
"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer Sequenz "
"zu verarbeiten und eine Liste mit den Ergebnissen zurückzugeben. ``result = "
"['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`` generiert eine "
"Liste von Zeichenketten, die gerade Hexadezimalzahlen (0x..) im Bereich von "
"0 bis 255 enthalten. Die Klausel :keyword:`if` ist optional. Wird sie "
"weggelassen, werden alle Elemente in ``range(256)`` verarbeitet."

#: ../../glossary.rst:960
msgid "lock"
msgstr "Sperre"

#: ../../glossary.rst:962
msgid ""
"A :term:`synchronization primitive` that allows only one thread at a time to "
"access a shared resource.  A thread must acquire a lock before accessing the "
"protected resource and release it afterward.  If a thread attempts to "
"acquire a lock that is already held by another thread, it will block until "
"the lock becomes available.  Python's :mod:`threading` module "
"provides :class:`~threading.Lock` (a basic lock) "
"and :class:`~threading.RLock` (a :term:`reentrant` lock).  Locks are used to "
"prevent :term:`race conditions <race condition>` and ensure :term:`thread-"
"safe` access to shared data.  Alternative design patterns to locks exist "
"such as queues, producer/consumer patterns, and thread-local state. See "
"also :term:`deadlock`, and :term:`reentrant`."
msgstr ""
"Eine :term:`Synchronisationsprimitive <synchronization primitive>`, die es "
"nur einem Thread gleichzeitig erlaubt, auf eine gemeinsam genutzte Ressource "
"zuzugreifen. Ein Thread muss vor dem Zugriff auf die geschützte Ressource "
"eine Sperre erwerben und diese anschließend wieder freigeben. Versucht ein "
"Thread, eine Sperre zu erwerben, die bereits von einem anderen Thread "
"gehalten wird, wird er blockiert, bis die Sperre verfügbar wird. Das Python-"
"Modul :mod:`threading` stellt :class:`~threading.Lock` (eine einfache "
"Sperre) und :class:`~threading.RLock` (eine :term:`reentrante <reentrant>` "
"Sperre) bereit. Sperren werden verwendet, um :term:`Race-Conditions <race "
"condition>` zu verhindern und einen :term:`thread-sicheren <thread-safe>` "
"Zugriff auf gemeinsam genutzte Daten zu gewährleisten. Es gibt alternative "
"Entwurfsmuster zu Sperren, wie z. B. Warteschlangen, Produzenten-Konsumenten-"
"Muster und thread-lokale Zustände. Siehe auch :term:`Deadlock <deadlock>` "
"und :term:`reentrant <reentrant>`."

#: ../../glossary.rst:973
msgid "lock-free"
msgstr "sperrfrei"

#: ../../glossary.rst:975
msgid ""
"An operation that does not acquire any :term:`lock` and uses atomic CPU "
"instructions to ensure correctness. Lock-free operations can execute "
"concurrently without blocking each other and cannot be blocked by operations "
"that hold locks. In :term:`free-threaded <free threading>` Python, built-in "
"types like :class:`dict` and :class:`list` provide lock-free read "
"operations, which means other threads may observe intermediate states during "
"multi-step modifications even when those modifications hold the :term:`per-"
"object lock`."
msgstr ""
"Eine Operation, die keine :term:`Sperre <lock>` erwirbt und atomare CPU-"
"Befehle verwendet, um die Korrektheit zu gewährleisten. Sperrfreie "
"Operationen können parallel ausgeführt werden, ohne sich gegenseitig zu "
"blockieren, und können nicht durch Operationen blockiert werden, die Sperren "
"halten. In :term:`free-threaded <free threading>` Python bieten integrierte "
"Typen wie :class:`dict` und :class:`list` lock-freie Leseoperationen, was "
"bedeutet, dass andere Threads bei mehrstufigen Änderungen Zwischenzustände "
"beobachten können, selbst wenn diese Änderungen die :term:`per-object lock` "
"halten."

#: ../../glossary.rst:983
msgid "loader"
msgstr "Lader"

#: ../../glossary.rst:985
msgid ""
"An object that loads a module. It must define the :meth:`!exec_module` "
"and :meth:`!create_module` methods to implement "
"the :class:`~importlib.abc.Loader` interface. A loader is typically returned "
"by a :term:`finder`. See also:"
msgstr ""
"Ein Objekt, das ein Modul lädt. Es muss die Methoden :meth:`!exec_module` "
"und :meth:`!create_module` definieren, um die "
"Schnittstelle :class:`~importlib.abc.Loader` zu implementieren. Ein Loader "
"wird in der Regel von einem :term:`finder` zurückgegeben. Siehe auch:"

#: ../../glossary.rst:991
msgid ":ref:`finders-and-loaders`"
msgstr ":ref:`finders-and-loaders`"

#: ../../glossary.rst:992
msgid ":class:`importlib.abc.Loader`"
msgstr ":class:`importlib.abc.Loader`"

#: ../../glossary.rst:993
msgid ":pep:`302`"
msgstr ":pep:`302`"

#: ../../glossary.rst:994
msgid "locale encoding"
msgstr "Ländereinstellung, Kodierung"

#: ../../glossary.rst:996
msgid ""
"On Unix, it is the encoding of the LC_CTYPE locale. It can be set "
"with :func:`locale.setlocale(locale.LC_CTYPE, new_locale) "
"<locale.setlocale>`."
msgstr ""
"Unter Unix handelt es sich um die Kodierung der Locale LC_CTYPE. Sie kann "
"mit :func:`locale.setlocale(locale.LC_CTYPE, new_locale) <locale.setlocale>` "
"festgelegt werden."

#: ../../glossary.rst:999
msgid "On Windows, it is the ANSI code page (ex: ``\"cp1252\"``)."
msgstr "Unter Windows ist dies die ANSI-Codepage (z. B.: ``\"cp1252\"``)."

#: ../../glossary.rst:1001
msgid ""
"On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding."
msgstr ""
"Unter Android und VxWorks verwendet Python ``\"utf-8\"`` als Locale-"
"Kodierung."

#: ../../glossary.rst:1003
msgid ":func:`locale.getencoding` can be used to get the locale encoding."
msgstr ""
":func:`locale.getencoding` kann verwendet werden, um die Kodierung der "
"Ländereinstellung abzurufen."

#: ../../glossary.rst:1005
msgid "See also the :term:`filesystem encoding and error handler`."
msgstr ""
"Siehe auch den Eintrag :term:`Dateisystem-Kodierung und Fehlerbehandlung "
"<filesystem encoding and error handler>`."

#: ../../glossary.rst:1006
msgid "magic method"
msgstr "magische Methode"

#: ../../glossary.rst:1010
msgid "An informal synonym for :term:`special method`."
msgstr ""
"Ein umgangssprachliches Synonym für :term:`Spezialmethode <special method>`."

#: ../../glossary.rst:1011
msgid "mapping"
msgstr "Mapping"

#: ../../glossary.rst:1013
msgid ""
"A container object that supports arbitrary key lookups and implements the "
"methods specified in the :class:`collections.abc.Mapping` "
"or :class:`collections.abc.MutableMapping` :ref:`abstract base classes "
"<collections-abstract-base-classes>`.  Examples "
"include :class:`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` "
"and :class:`collections.Counter`."
msgstr ""
"Ein Container-Objekt, das die Suche nach beliebigen Schlüsseln unterstützt "
"und die Methoden implementiert, die in den :class:`collections.abc.Mapping` "
"oder :class:`collections.abc.MutableMapping`:ref:`abstrakten Basisklassen "
"<collections-abstract-base-classes>` festgelegt sind. Beispiele hierfür "
"sind :class:`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` "
"und :class:`collections.Counter`."

#: ../../glossary.rst:1019
msgid "meta path finder"
msgstr "Meta-Pfadfinder"

#: ../../glossary.rst:1021
msgid ""
"A :term:`finder` returned by a search of :data:`sys.meta_path`.  Meta path "
"finders are related to, but different from :term:`path entry finders <path "
"entry finder>`."
msgstr ""
"Ein :term:`Finder <finder>`, der bei einer Suche auf :data:`sys.meta_path` "
"zurückgegeben wird. Meta-Pfadfinder stehen in Zusammenhang "
"mit :term:`Pfadeintrags-Findern <path entry finder>`, unterscheiden sich "
"jedoch von diesen."

#: ../../glossary.rst:1025
msgid ""
"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path "
"finders implement."
msgstr ""
"Unter :class:`importlib.abc.MetaPathFinder` findest du die Methoden, die "
"Meta-Path-Finder implementieren."

#: ../../glossary.rst:1027
msgid "metaclass"
msgstr "Metaklasse"

#: ../../glossary.rst:1029
msgid ""
"The class of a class.  Class definitions create a class name, a class "
"dictionary, and a list of base classes.  The metaclass is responsible for "
"taking those three arguments and creating the class.  Most object oriented "
"programming languages provide a default implementation.  What makes Python "
"special is that it is possible to create custom metaclasses.  Most users "
"never need this tool, but when the need arises, metaclasses can provide "
"powerful, elegant solutions.  They have been used for logging attribute "
"access, adding thread-safety, tracking object creation, implementing "
"singletons, and many other tasks."
msgstr ""
"Die Klasse einer Klasse. Klassendefinitionen legen einen Klassennamen, ein "
"Klassen-Dictionary und eine Liste von Basisklassen fest. Die Metaklasse ist "
"dafür zuständig, diese drei Argumente zu übernehmen und die Klasse zu "
"erstellen. Die meisten objektorientierten Programmiersprachen bieten eine "
"Standardimplementierung. Das Besondere an Python ist, dass es möglich ist, "
"benutzerdefinierte Metaklassen zu erstellen. Die meisten Nutzer benötigen "
"dieses Werkzeug nie, doch wenn der Bedarf entsteht, können Metaklassen "
"leistungsstarke und elegante Lösungen bieten. Sie wurden bereits zur "
"Protokollierung des Zugriffs auf Attribute, zur Gewährleistung der Thread-"
"Sicherheit, zur Verfolgung der Objekterstellung, zur Implementierung von "
"Singletons und für viele andere Aufgaben eingesetzt."

#: ../../glossary.rst:1039
msgid "More information can be found in :ref:`metaclasses`."
msgstr "Weitere Informationen findest du unter :ref:`metaclasses`."

#: ../../glossary.rst:1008 ../../glossary.rst:1040 ../../glossary.rst:1494
msgid "method"
msgstr "Methode"

#: ../../glossary.rst:1042
msgid ""
"A function which is defined inside a class body.  If called as an attribute "
"of an instance of that class, the method will get the instance object as its "
"first :term:`argument` (which is usually called ``self``). "
"See :term:`function` and :term:`nested scope`."
msgstr ""
"Eine Funktion, die innerhalb des Klassenkörpers definiert ist. Wird sie als "
"Attribut einer Instanz dieser Klasse aufgerufen, erhält die Methode das "
"Instanzobjekt als erstes :term:`Argument <argument>` (das üblicherweise als "
"``self`` bezeichnet wird). Siehe :term:`function` und :term:`nested scope`."

#: ../../glossary.rst:1046
msgid "method resolution order"
msgstr "Reihenfolge der Methodenauflösung"

#: ../../glossary.rst:1048
msgid ""
"Method Resolution Order is the order in which base classes are searched for "
"a member during lookup. See :ref:`python_2.3_mro` for details of the "
"algorithm used by the Python interpreter since the 2.3 release."
msgstr ""
"Die Auflösungsreihenfolge von Methoden ist die Reihenfolge, in der bei der "
"Suche nach einem Mitglied die Basisklassen durchsucht werden. Weitere "
"Informationen zu dem Algorithmus, der seit der Version 2.3 vom Python-"
"Interpreter verwendet wird, findest du unter :ref:`python_2.3_mro`."

#: ../../glossary.rst:1051
msgid "module"
msgstr "Modul"

#: ../../glossary.rst:1053
msgid ""
"An object that serves as an organizational unit of Python code.  Modules "
"have a namespace containing arbitrary Python objects.  Modules are loaded "
"into Python by the process of :term:`importing`."
msgstr ""
"Ein Objekt, das als Organisationseinheit für Python-Code dient. Module "
"verfügen über einen Namensraum, der beliebige Python-Objekte enthält. Module "
"werden durch den Vorgang des :term:`Importierens <importing>` in Python "
"geladen."

#: ../../glossary.rst:1057
msgid "See also :term:`package`."
msgstr "Siehe auch :term:`Paket <package>`."

#: ../../glossary.rst:1058
msgid "module spec"
msgstr "Modulspezifikation"

#: ../../glossary.rst:1060
msgid ""
"A namespace containing the import-related information used to load a module. "
"An instance of :class:`importlib.machinery.ModuleSpec`."
msgstr ""
"Ein Namespace, der die Import-bezogenen Informationen enthält, die zum Laden "
"eines Moduls verwendet werden. Eine Instanz "
"von :class:`importlib.machinery.ModuleSpec`."

#: ../../glossary.rst:1063
msgid "See also :ref:`module-specs`."
msgstr "Siehe auch :ref:`module-specs`."

#: ../../glossary.rst:1064
msgid "MRO"
msgstr "MRO"

#: ../../glossary.rst:1066
msgid "See :term:`method resolution order`."
msgstr ""
"Siehe :term:`Reihenfolge der Methodenauflösung <method resolution order>`."

#: ../../glossary.rst:1067
msgid "mutable"
msgstr "veränderlich"

#: ../../glossary.rst:1069
msgid ""
"An :term:`object` with state that is allowed to change during the course of "
"the program.  In multi-threaded programs, mutable objects that are shared "
"between threads require careful synchronization to avoid :term:`race "
"conditions <race condition>`.  See also :term:`immutable`, :term:`thread-"
"safe`, and :term:`concurrent modification`."
msgstr ""
"Ein :term:`Objekt <object>` mit einem Zustand, der sich im Verlauf des "
"Programms ändern darf. In Multithread-Programmen erfordern veränderbare "
"Objekte, die von mehreren Threads gemeinsam genutzt werden, eine sorgfältige "
"Synchronisation, um :term:`Race-Conditions <race condition>` zu vermeiden. "
"Siehe auch :term:`unveränderlich <immutable>`, :term:`thread-sicher <thread-"
"safe>` und :term:`parallele Änderung <concurrent modification>`."

#: ../../glossary.rst:1074
msgid "named tuple"
msgstr "benanntes Tupel"

#: ../../glossary.rst:1076
msgid ""
"The term \"named tuple\" applies to any type or class that inherits from "
"tuple and whose indexable elements are also accessible using named "
"attributes.  The type or class may have other features as well."
msgstr ""
"Der Begriff \"benanntes Tupel\" bezieht sich auf jeden Typ oder jede Klasse, "
"die von \"Tupel\" erbt und deren indizierbare Elemente auch über benannte "
"Attribute zugänglich sind. Der Typ oder die Klasse kann darüber hinaus noch "
"weitere Merkmale aufweisen."

#: ../../glossary.rst:1080
msgid ""
"Several built-in types are named tuples, including the values returned "
"by :func:`time.localtime` and :func:`os.stat`.  Another example "
"is :data:`sys.float_info`::"
msgstr ""
"Mehrere integrierte Datentypen werden als Tupel bezeichnet, darunter die "
"von :func:`time.localtime` und :func:`os.stat` zurückgegebenen Werte. Ein "
"weiteres Beispiel ist :data:`sys.float_info`: ::"

#: ../../glossary.rst:1084
msgid ""
">>> sys.float_info[1]                   # indexed access\n"
"1024\n"
">>> sys.float_info.max_exp              # named field access\n"
"1024\n"
">>> isinstance(sys.float_info, tuple)   # kind of tuple\n"
"True"
msgstr ""
">>> sys.float_info[1]                   # indizierter Zugriff\n"
"1024\n"
">>> sys.float_info.max_exp              # Zugriff auf ein benanntes Feld\n"
"1024\n"
">>> isinstance(sys.float_info, tuple)   # Typ eines Tupels\n"
"True"

#: ../../glossary.rst:1091
msgid ""
"Some named tuples are built-in types (such as the above examples). "
"Alternatively, a named tuple can be created from a regular class definition "
"that inherits from :class:`tuple` and that defines named fields.  Such a "
"class can be written by hand, or it can be created by "
"inheriting :class:`typing.NamedTuple`, or with the factory "
"function :func:`collections.namedtuple`.  The latter techniques also add "
"some extra methods that may not be found in hand-written or built-in named "
"tuples."
msgstr ""
"Einige benannte Tupel sind integrierte Typen (wie die obigen Beispiele). "
"Alternativ kann ein benanntes Tupel aus einer regulären Klassendefinition "
"erstellt werden, die von :class:`tuple` erbt und benannte Felder definiert. "
"Eine solche Klasse kann manuell geschrieben werden oder durch Vererbung "
"von :class:`typing.NamedTuple` bzw. mit der Factory-"
"Funktion :func:`collections.namedtuple` erstellt werden. Die letztgenannten "
"Techniken fügen zudem einige zusätzliche Methoden hinzu, die in manuell "
"geschriebenen oder integrierten benannten Tupeln möglicherweise nicht "
"vorhanden sind."

#: ../../glossary.rst:1099
msgid "namespace"
msgstr "Namensraum"

#: ../../glossary.rst:1101
msgid ""
"The place where a variable is stored.  Namespaces are implemented as "
"dictionaries.  There are the local, global and built-in namespaces as well "
"as nested namespaces in objects (in methods).  Namespaces support modularity "
"by preventing naming conflicts.  For instance, the "
"functions :func:`builtins.open <.open>` and :func:`os.open` are "
"distinguished by their namespaces.  Namespaces also aid readability and "
"maintainability by making it clear which module implements a function.  For "
"instance, writing :func:`random.seed` or :func:`itertools.islice` makes it "
"clear that those functions are implemented by the :mod:`random` "
"and :mod:`itertools` modules, respectively."
msgstr ""
"Der Ort, an dem eine Variable gespeichert wird. Namensräume werden als "
"Dictionarys implementiert. Es gibt lokale, globale und integrierte "
"Namensräume sowie verschachtelte Namensräume in Objekten (in Methoden). "
"Namensräume unterstützen die Modularität, indem sie Namenskonflikte "
"verhindern. Beispielsweise unterscheiden sich die "
"Funktionen :func:`builtins.open <.open>` und :func:`os.open` durch ihre "
"Namensräume. Namensräume tragen zudem zur Lesbarkeit und Wartbarkeit bei, "
"indem sie deutlich machen, welches Modul eine Funktion implementiert. Wenn "
"du beispielsweise :func:`random.seed` oder :func:`itertools.islice` "
"schreibst, wird deutlich, dass diese Funktionen jeweils von den "
"Modulen :mod:`random` und :mod:`itertools` implementiert werden."

#: ../../glossary.rst:1111
msgid "namespace package"
msgstr "Namespace-Paket"

#: ../../glossary.rst:1113
msgid ""
"A :term:`package` which serves only as a container for subpackages. "
"Namespace packages may have no physical representation, and specifically are "
"not like a :term:`regular package` because they have no ``__init__.py`` file."
msgstr ""
"Ein :term:`Paket <package>`, das ausschließlich als Container für "
"Unterpakete dient. Namespace-Pakete haben möglicherweise keine physische "
"Darstellung und unterscheiden sich insbesondere von einem :term:`normalen "
"Paket <regular package>`, da sie keine Datei ``__init__.py`` enthalten."

#: ../../glossary.rst:1118
msgid ""
"Namespace packages allow several individually installable packages to have a "
"common parent package. Otherwise, it is recommended to use a :term:`regular "
"package`."
msgstr ""
"Namespace-Pakete ermöglichen es, dass mehrere einzeln installierbare Pakete "
"ein gemeinsames übergeordnetes Paket haben. Andernfalls wird empfohlen, "
"ein :term:`normales Paket <regular package>` zu verwenden."

#: ../../glossary.rst:1121
msgid ""
"For more information, see :pep:`420` and :ref:`reference-namespace-package`."
msgstr ""
"Weitere Informationen findest du unter :pep:`420` und :ref:`reference-"
"namespace-package`."

#: ../../glossary.rst:1123
msgid "See also :term:`module`."
msgstr "Siehe auch :term:`Modul <module>`."

#: ../../glossary.rst:1124
msgid "native code"
msgstr "Nativcode"

#: ../../glossary.rst:1126
msgid ""
"Code that is compiled to machine instructions and runs directly on the "
"processor, as opposed to code that is interpreted or runs in a virtual "
"machine.  In the context of Python, native code typically refers to C, C++, "
"Rust or Fortran code in :term:`extension modules <extension module>` that "
"can be called from Python.  See also :term:`extension module`."
msgstr ""
"Code, der zu Maschinenbefehlen kompiliert wird und direkt auf dem Prozessor "
"ausgeführt wird, im Gegensatz zu Code, der interpretiert wird oder in einer "
"virtuellen Maschine läuft. Im Zusammenhang mit Python bezieht sich \"nativer "
"Code\" in der Regel auf C-, C++-, Rust- oder Fortran-Code "
"in :term:`Erweiterungsmodulen <extension module>`, der von Python aus "
"aufgerufen werden kann. Siehe auch :term:`Erweiterungsmodul <extension "
"module>`."

#: ../../glossary.rst:1131
msgid "nested scope"
msgstr "verschachtelter Geltungsbereich"

#: ../../glossary.rst:1133
msgid ""
"The ability to refer to a variable in an enclosing definition.  For "
"instance, a function defined inside another function can refer to variables "
"in the outer function.  Note that nested scopes by default work only for "
"reference and not for assignment.  Local variables both read and write in "
"the innermost scope.  Likewise, global variables read and write to the "
"global namespace.  The :keyword:`nonlocal` allows writing to outer scopes."
msgstr ""
"Die Möglichkeit, in einer umschließenden Definition auf eine Variable zu "
"verweisen. So kann beispielsweise eine innerhalb einer anderen Funktion "
"definierte Funktion auf Variablen in der äußeren Funktion verweisen. "
"Beachte, dass verschachtelte Geltungsbereiche standardmäßig nur für Verweise "
"und nicht für Zuweisungen gelten. Lokale Variablen lesen und schreiben im "
"innersten Geltungsbereich. Ebenso lesen und schreiben globale Variablen im "
"globalen Namensraum. Die Anweisung :keyword:`nonlocal` ermöglicht das "
"Schreiben in äußere Geltungsbereiche."

#: ../../glossary.rst:1140
msgid "new-style class"
msgstr "New-Style-Klasse"

#: ../../glossary.rst:1142
msgid ""
"Old name for the flavor of classes now used for all class objects.  In "
"earlier Python versions, only new-style classes could use Python's newer, "
"versatile features like :attr:`~object.__slots__`, descriptors, "
"properties, :meth:`~object.__getattribute__`, class methods, and static "
"methods."
msgstr ""
"Alte Bezeichnung für den \"Flavor\" von Klassen, der nun für alle "
"Klassenobjekte verwendet wird. In früheren Python-Versionen konnten nur "
"Klassen des neuen Stils die neueren, vielseitigen Funktionen von Python "
"nutzen, wie beispielsweise :attr:`~object.__slots__` , Deskriptoren, "
"Eigenschaften, :meth:`~object.__getattribute__` , Klassenmethoden und "
"statische Methoden."

#: ../../glossary.rst:1147
msgid "non-deterministic"
msgstr "nicht deterministisch"

#: ../../glossary.rst:1149
msgid ""
"Behavior where the outcome of a program can vary between executions with the "
"same inputs.  In multi-threaded programs, non-deterministic behavior often "
"results from :term:`race conditions <race condition>` where the relative "
"timing or interleaving of threads affects the result. Proper synchronization "
"using :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` helps ensure deterministic behavior."
msgstr ""
"Verhalten, bei dem das Ergebnis eines Programms zwischen einzelnen "
"Ausführungen schwanken kann, obwohl die Eingaben dieselben sind. In "
"Programmen mit mehreren Threads entsteht nichtdeterministisches Verhalten "
"häufig durch :term:`Wettlaufsituationen <race condition>`, bei denen die "
"zeitliche Abfolge oder Verschränkung der Threads das Ergebnis beeinflusst. "
"Eine saubere Synchronisation mit :term:`Locks <lock>` und "
"anderen :term:`Synchronisationsprimitiven <synchronization primitive>` "
"hilft, deterministisches Verhalten sicherzustellen."

#: ../../glossary.rst:1156
msgid "object"
msgstr "Objekt"

#: ../../glossary.rst:1158
msgid ""
"Any data with state (attributes or value) and defined behavior (methods).  "
"Also the ultimate base class of any :term:`new-style class`."
msgstr ""
"Jede Dateninstanz mit einem Zustand (Attribute oder Wert) und definiertem "
"Verhalten (Methoden). Außerdem die oberste Basisklasse jeder :term:`Klasse "
"neuen Stils <new-style class>`."

#: ../../glossary.rst:1161
msgid "optimized scope"
msgstr "optimierter Umfang"

#: ../../glossary.rst:1163
msgid ""
"A scope where target local variable names are reliably known to the compiler "
"when the code is compiled, allowing optimization of read and write access to "
"these names. The local namespaces for functions, generators, coroutines, "
"comprehensions, and generator expressions are optimized in this fashion. "
"Note: most interpreter optimizations are applied to all scopes, only those "
"relying on a known set of local and nonlocal variable names are restricted "
"to optimized scopes."
msgstr ""
"Ein Geltungsbereich, in dem die Namen der lokalen Zielvariablen dem Compiler "
"zum Zeitpunkt der Kompilierung zuverlässig bekannt sind, wodurch der Lese- "
"und Schreibzugriff auf diese Namen optimiert werden kann. Die lokalen "
"Namensräume für Funktionen, Generatoren, Coroutinen, Comprehensions und "
"Generatorausdrücke werden auf diese Weise optimiert. Hinweis: Die meisten "
"Interpreter-Optimierungen werden auf alle Geltungsbereiche angewendet. Nur "
"diejenigen, die auf einer bekannten Menge lokaler und nichtlokaler "
"Variablennamen beruhen, sind auf optimierte Geltungsbereiche beschränkt."

#: ../../glossary.rst:1170
msgid "optional module"
msgstr "optionales Modul"

#: ../../glossary.rst:1172
msgid ""
"An :term:`extension module` that is part of the :term:`standard library`, "
"but may be absent in some builds of :term:`CPython`, usually due to missing "
"third-party libraries or because the module is not available for a given "
"platform."
msgstr ""
"Ein :term:`Erweiterungsmodul <extension module>`, das Teil "
"der :term:`Standardbibliothek <standard library>` ist, jedoch in einigen "
"Builds von :term:`CPython` möglicherweise fehlt – in der Regel aufgrund "
"fehlender Bibliotheken von Drittanbietern oder weil das Modul für eine "
"bestimmte Plattform nicht verfügbar ist."

#: ../../glossary.rst:1177
msgid ""
"See :ref:`optional-module-requirements` for a list of optional modules that "
"require third-party libraries."
msgstr ""
"Eine Liste der optionalen Module, für die Bibliotheken von Drittanbietern "
"erforderlich sind, findest du unter :ref:`optional-module-requirements`."

#: ../../glossary.rst:1179
msgid "package"
msgstr "Paket"

#: ../../glossary.rst:1181
msgid ""
"A Python :term:`module` which can contain submodules or recursively, "
"subpackages.  Technically, a package is a Python module with a ``__path__`` "
"attribute."
msgstr ""
"Ein Python-:term:`Modul <module>`, das Untermodule oder – rekursiv – "
"Unterpakete enthalten kann. Technisch gesehen ist ein Paket ein Python-Modul "
"mit einem Attribut vom Typ ``__path__`` ."

#: ../../glossary.rst:1185
msgid "See also :term:`regular package` and :term:`namespace package`."
msgstr ""
"Siehe auch :term:`reguläres Paket <regular package>` und :term:`Namensraum-"
"Paket <namespace package>`."

#: ../../glossary.rst:1186
msgid "parallelism"
msgstr "Parallelität"

#: ../../glossary.rst:1188
msgid ""
"Executing multiple operations at the same time (e.g. on multiple CPU "
"cores).  In Python builds with the :term:`global interpreter lock (GIL) "
"<global interpreter lock>`, only one thread runs Python bytecode at a time, "
"so taking advantage of multiple CPU cores typically involves multiple "
"processes (e.g. :mod:`multiprocessing`) or native extensions that release "
"the GIL. In :term:`free-threaded <free threading>` Python, multiple Python "
"threads can run Python code simultaneously on different cores."
msgstr ""
"Die gleichzeitige Ausführung mehrerer Operationen (z. B. auf mehreren CPU-"
"Kernen). In Python-Builds mit dem :term:`global interpreter lock (GIL) "
"<global interpreter lock>` führt jeweils nur ein Thread Python-Bytecode aus. "
"Um die Vorteile mehrerer CPU-Kerne nutzen zu können, sind daher in der Regel "
"mehrere Prozesse (z. B. :mod:`multiprocessing`) oder native Erweiterungen "
"erforderlich, die das GIL aufheben. In :term:`free-threaded <free "
"threading>` Python können mehrere Python-Threads Python-Code gleichzeitig "
"auf verschiedenen Kernen ausführen."

#: ../../glossary.rst:1196
msgid "parameter"
msgstr "Parameter"

#: ../../glossary.rst:1198
msgid ""
"A named entity in a :term:`function` (or method) definition that specifies "
"an :term:`argument` (or in some cases, arguments) that the function can "
"accept.  There are five kinds of parameter:"
msgstr ""
"Eine benannte Entität in einer :term:`Funktions <function>`- (oder "
"Methoden-)Definition, die ein :term:`Argument <argument>` (oder in manchen "
"Fällen mehrere Argumente) angibt, das bzw. die die Funktion entgegennehmen "
"kann. Es gibt fünf Arten von Parametern:"

#: ../../glossary.rst:1202
msgid ""
":dfn:`positional-or-keyword`: specifies an argument that can be passed "
"either :term:`positionally <argument>` or as a :term:`keyword argument "
"<argument>`.  This is the default kind of parameter, for example *foo* and "
"*bar* in the following::"
msgstr ""
":dfn:`positional-or-keyword`: bezeichnet ein Argument, das "
"entweder :term:`über die Position <argument>` oder "
"als :term:`Schlüsselwortargument <argument>` übergeben werden kann. Das ist "
"die Standardart von Parametern, zum Beispiel *foo* und *bar* im Folgenden::"

#: ../../glossary.rst:1207
msgid "def func(foo, bar=None): ..."
msgstr "def func(foo, bar=None): ..."

#: ../../glossary.rst:1211
msgid ""
":dfn:`positional-only`: specifies an argument that can be supplied only by "
"position. Positional-only parameters can be defined by including a ``/`` "
"character in the parameter list of the function definition after them, for "
"example *posonly1* and *posonly2* in the following::"
msgstr ""
":dfn:`positional-only`: Gibt ein Argument an, das nur über die Position "
"übergeben werden kann. Parameter, die ausschließlich über die Position "
"übergeben werden können, lassen sich definieren, indem man in der "
"Parameterliste der Funktionsdefinition hinter ihnen das Zeichen ``/`` "
"einfügt, zum Beispiel *posonly1* und *posonly2* im folgenden Beispiel::"

#: ../../glossary.rst:1216
msgid "def func(posonly1, posonly2, /, positional_or_keyword): ..."
msgstr "def func(posonly1, posonly2, /, positional_or_keyword): ..."

#: ../../glossary.rst:1220
msgid ""
":dfn:`keyword-only`: specifies an argument that can be supplied only by "
"keyword.  Keyword-only parameters can be defined by including a single var-"
"positional parameter or bare ``*`` in the parameter list of the function "
"definition before them, for example *kw_only1* and *kw_only2* in the "
"following::"
msgstr ""
":dfn:`keyword-only`: bezeichnet ein Argument, das nur über ein Schlüsselwort "
"übergeben werden kann. Keyword-only-Parameter lassen sich festlegen, indem "
"in der Parameterliste der Funktionsdefinition vor ihnen ein einzelner var-"
"positional-Parameter oder ein bloßes ``*`` steht, zum Beispiel *kw_only1* "
"und *kw_only2* im Folgenden::"

#: ../../glossary.rst:1226
msgid "def func(arg, *, kw_only1, kw_only2): ..."
msgstr "def func(arg, *, kw_only1, kw_only2): ..."

#: ../../glossary.rst:1228
msgid ""
":dfn:`var-positional`: specifies that an arbitrary sequence of positional "
"arguments can be provided (in addition to any positional arguments already "
"accepted by other parameters).  Such a parameter can be defined by "
"prepending the parameter name with ``*``, for example *args* in the "
"following::"
msgstr ""
":dfn:`var-positional`: Gibt an, dass eine beliebige Folge von "
"Positionsargumenten angegeben werden kann (zusätzlich zu den "
"Positionsargumenten, die bereits von anderen Parametern akzeptiert werden). "
"Ein solcher Parameter kann definiert werden, indem dem Parameternamen ``*`` "
"vorangestellt wird, zum Beispiel *args* im folgenden Beispiel::"

#: ../../glossary.rst:1234
msgid "def func(*args, **kwargs): ..."
msgstr "def func(*args, **kwargs): ..."

#: ../../glossary.rst:1236
msgid ""
":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be "
"provided (in addition to any keyword arguments already accepted by other "
"parameters).  Such a parameter can be defined by prepending the parameter "
"name with ``**``, for example *kwargs* in the example above."
msgstr ""
":dfn:`var-keyword`: Gibt an, dass beliebig viele Schlüsselwortargumente "
"angegeben werden können (zusätzlich zu den Schlüsselwortargumenten, die "
"bereits von anderen Parametern akzeptiert werden). Ein solcher Parameter "
"kann definiert werden, indem dem Parameternamen ``**`` vorangestellt wird, "
"beispielsweise *kwargs* im obigen Beispiel."

#: ../../glossary.rst:1242
msgid ""
"Parameters can specify both optional and required arguments, as well as "
"default values for some optional arguments."
msgstr ""
"Parameter können sowohl optionale als auch erforderliche Argumente sowie "
"Standardwerte für einige optionale Argumente festlegen."

#: ../../glossary.rst:1245
msgid ""
"See also the :term:`argument` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"the :class:`inspect.Parameter` class, the :ref:`function` section, "
"and :pep:`362`."
msgstr ""
"Siehe auch den Glossareintrag :term:`argument`, die FAQ-Frage zu :ref:`dem "
"Unterschied zwischen Argumenten und Parametern <faq-argument-vs-parameter>`, "
"die Klasse :class:`inspect.Parameter`, den Abschnitt :ref:`function` "
"sowie :pep:`362`."

#: ../../glossary.rst:1249
msgid "per-object lock"
msgstr "objektspezifische Sperre"

#: ../../glossary.rst:1251
msgid ""
"A :term:`lock` associated with an individual object instance rather than a "
"global lock shared across all objects. In :term:`free-threaded <free "
"threading>` Python, built-in types like :class:`dict` and :class:`list` use "
"per-object locks to allow concurrent operations on different objects while "
"serializing operations on the same object. Operations that hold the per-"
"object lock prevent other locking operations on the same object from "
"proceeding, but do not block :term:`lock-free` operations."
msgstr ""
"Ein :term:`Lock <lock>`, der mit einer einzelnen Objektinstanz verknüpft "
"ist, im Gegensatz zu einem globalen Lock, der von allen Objekten gemeinsam "
"genutzt wird. In :term:`free-threaded <free threading>` Python verwenden "
"integrierte Typen wie :class:`dict` und :class:`list` objektbezogene "
"Sperren, um parallele Operationen an verschiedenen Objekten zu ermöglichen, "
"während Operationen am selben Objekt serialisiert werden. Operationen, die "
"die objektbezogene Sperre halten, verhindern, dass andere Sperroperationen "
"am selben Objekt fortgesetzt werden, blockieren jedoch keine :term:`lock-"
"free`-Operationen."

#: ../../glossary.rst:1259
msgid "path entry"
msgstr "Pfadeintrag"

#: ../../glossary.rst:1261
msgid ""
"A single location on the :term:`import path` which the :term:`path based "
"finder` consults to find modules for importing."
msgstr ""
"Ein einzelner Speicherort im :term:`Importpfad <import path>`, den "
"der :term:`pfadbasierte Finder <path based finder>` abfragt, um Module zum "
"Importieren zu finden."

#: ../../glossary.rst:1263
msgid "path entry finder"
msgstr "Pfadeintrags-Finder"

#: ../../glossary.rst:1265
msgid ""
"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. "
"a :term:`path entry hook`) which knows how to locate modules given "
"a :term:`path entry`."
msgstr ""
"Ein :term:`finder`, der von einer auf :data:`sys.path_hooks` aufrufbaren "
"Funktion (d. h. einem :term:`path entry hook`) zurückgegeben wird, die weiß, "
"wie man Module anhand eines :term:`path entry` findet."

#: ../../glossary.rst:1269
msgid ""
"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry "
"finders implement."
msgstr ""
"Unter :class:`importlib.abc.PathEntryFinder` findest du die Methoden, die "
"von Path-Entry-Findern implementiert werden."

#: ../../glossary.rst:1271
msgid "path entry hook"
msgstr "Pfadeintrag-Hook"

#: ../../glossary.rst:1273
msgid ""
"A callable on the :data:`sys.path_hooks` list which returns a :term:`path "
"entry finder` if it knows how to find modules on a specific :term:`path "
"entry`."
msgstr ""
"Eine auf der Liste :data:`sys.path_hooks` aufrufbare Funktion, die "
"einen :term:`Pfadeintrag-Finder <path entry finder>` zurückgibt, sofern sie "
"weiß, wie Module auf einem bestimmten :term:`Pfadeintrag <path entry>` "
"gefunden werden können."

#: ../../glossary.rst:1276
msgid "path based finder"
msgstr "pfadbasierter Finder"

#: ../../glossary.rst:1278
msgid ""
"One of the default :term:`meta path finders <meta path finder>` which "
"searches an :term:`import path` for modules."
msgstr ""
"Einer der standardmäßigen :term:`Meta-Pfadfinder <meta path finder>`, der "
"einen :term:`Importpfad <import path>` nach Modulen durchsucht."

#: ../../glossary.rst:1280
msgid "path-like object"
msgstr "pfadähnliches Objekt"

#: ../../glossary.rst:1282
msgid ""
"An object representing a file system path. A path-like object is either "
"a :class:`str` or :class:`bytes` object representing a path, or an object "
"implementing the :class:`os.PathLike` protocol. An object that supports "
"the :class:`os.PathLike` protocol can be converted to a :class:`str` "
"or :class:`bytes` file system path by calling the :func:`os.fspath` "
"function; :func:`os.fsdecode` and :func:`os.fsencode` can be used to "
"guarantee a :class:`str` or :class:`bytes` result instead, respectively. "
"Introduced by :pep:`519`."
msgstr ""
"Ein Objekt, das einen Dateisystempfad darstellt. Ein pfadähnliches Objekt "
"ist entweder ein :class:`str`- oder ein :class:`bytes`-Objekt, das einen "
"Pfad darstellt, oder ein Objekt, das das :class:`os.PathLike`-Protokoll "
"implementiert. Ein Objekt, das das :class:`os.PathLike`-Protokoll "
"unterstützt, kann durch Aufruf der Funktion :func:`os.fspath` in "
"einen :class:`str`- oder :class:`bytes`-Dateisystempfad umgewandelt werden. "
"Mit :func:`os.fsdecode` bzw. :func:`os.fsencode` lässt sich stattdessen "
"ein :class:`str`- bzw. :class:`bytes`-Ergebnis gewährleisten. Eingeführt "
"durch :pep:`519` ."

#: ../../glossary.rst:1290
msgid "PEP"
msgstr "PEP"

#: ../../glossary.rst:1292
msgid ""
"Python Enhancement Proposal. A PEP is a design document providing "
"information to the Python community, or describing a new feature for Python "
"or its processes or environment. PEPs should provide a concise technical "
"specification and a rationale for proposed features."
msgstr ""
"Python Enhancement Proposal. Ein PEP ist ein Entwurfsdokument, das der "
"Python-Community Informationen liefert oder eine neue Funktion für Python, "
"dessen Prozesse oder dessen Umgebung beschreibt. PEPs sollten eine prägnante "
"technische Spezifikation sowie eine Begründung für die vorgeschlagenen "
"Funktionen enthalten."

#: ../../glossary.rst:1298
msgid ""
"PEPs are intended to be the primary mechanisms for proposing major new "
"features, for collecting community input on an issue, and for documenting "
"the design decisions that have gone into Python. The PEP author is "
"responsible for building consensus within the community and documenting "
"dissenting opinions."
msgstr ""
"PEPs sollen als primäre Mechanismen dienen, um wichtige neue Funktionen "
"vorzuschlagen, Rückmeldungen der Community zu einem Thema einzuholen und die "
"Designentscheidungen zu dokumentieren, die in Python eingeflossen sind. Der "
"PEP-Autor ist dafür verantwortlich, einen Konsens innerhalb der Community "
"herzustellen und abweichende Meinungen zu dokumentieren."

#: ../../glossary.rst:1304
msgid "See :pep:`1`."
msgstr "Siehe :pep:`1`."

#: ../../glossary.rst:1305
msgid "portion"
msgstr "Anteil"

#: ../../glossary.rst:1307
msgid ""
"A set of files in a single directory (possibly stored in a zip file) that "
"contribute to a namespace package, as defined in :pep:`420`."
msgstr ""
"Eine Sammlung von Dateien in einem einzigen Verzeichnis (die möglicherweise "
"in einer ZIP-Datei gespeichert sind), die zu einem Namespace-Paket "
"beitragen, wie unter :pep:`420` definiert."

#: ../../glossary.rst:1309
msgid "positional argument"
msgstr "Positionsargument"

#: ../../glossary.rst:1312
msgid "provisional API"
msgstr "vorläufige API"

#: ../../glossary.rst:1314
msgid ""
"A provisional API is one which has been deliberately excluded from the "
"standard library's backwards compatibility guarantees.  While major changes "
"to such interfaces are not expected, as long as they are marked provisional, "
"backwards incompatible changes (up to and including removal of the "
"interface) may occur if deemed necessary by core developers.  Such changes "
"will not be made gratuitously -- they will occur only if serious fundamental "
"flaws are uncovered that were missed prior to the inclusion of the API."
msgstr ""
"Eine vorläufige API ist eine Schnittstelle, die bewusst von den "
"Rückwärtskompatibilitätsgarantien der Standardbibliothek ausgenommen wurde. "
"Zwar sind größere Änderungen an solchen Schnittstellen nicht zu erwarten, "
"solange sie als vorläufig gekennzeichnet sind, doch können "
"rückwärtsinkompatible Änderungen (bis hin zur Entfernung der Schnittstelle) "
"vorgenommen werden, wenn dies von den Kernentwicklern als notwendig erachtet "
"wird. Solche Änderungen werden nicht ohne triftigen Grund vorgenommen – sie "
"erfolgen nur, wenn schwerwiegende grundlegende Mängel aufgedeckt werden, die "
"vor der Aufnahme der API übersehen wurden."

#: ../../glossary.rst:1323
msgid ""
"Even for provisional APIs, backwards incompatible changes are seen as a "
"\"solution of last resort\" - every attempt will still be made to find a "
"backwards compatible resolution to any identified problems."
msgstr ""
"Auch bei vorläufigen APIs gelten nicht rückwärtskompatible Änderungen als "
"„letztes Mittel\" – es wird weiterhin jeder Versuch unternommen, für "
"erkannte Probleme eine rückwärtskompatible Lösung zu finden."

#: ../../glossary.rst:1327
msgid ""
"This process allows the standard library to continue to evolve over time, "
"without locking in problematic design errors for extended periods of time.  "
"See :pep:`411` for more details."
msgstr ""
"Dieser Prozess ermöglicht es, dass sich die Standardbibliothek im Laufe der "
"Zeit weiterentwickeln kann, ohne dass problematische Konstruktionsfehler "
"über längere Zeiträume hinweg festgeschrieben werden. Weitere Einzelheiten "
"findest du unter :pep:`411`."

#: ../../glossary.rst:1330
msgid "provisional package"
msgstr "vorläufiges Paket"

#: ../../glossary.rst:1332
msgid "See :term:`provisional API`."
msgstr "Siehe :term:`vorläufige API <provisional API>`."

#: ../../glossary.rst:1333
msgid "Python 3000"
msgstr "Python 3000"

#: ../../glossary.rst:1335
msgid ""
"Nickname for the Python 3.x release line (coined long ago when the release "
"of version 3 was something in the distant future.)  This is also abbreviated "
"\"Py3k\"."
msgstr ""
"Spitzname für die Python-3.x-Versionsreihe (der vor langer Zeit geprägt "
"wurde, als die Veröffentlichung von Version 3 noch in ferner Zukunft lag). "
"Er wird auch mit \"Py3k\" abgekürzt."

#: ../../glossary.rst:1338
msgid "Pythonic"
msgstr "pythonisch"

#: ../../glossary.rst:1340
msgid ""
"An idea or piece of code which closely follows the most common idioms of the "
"Python language, rather than implementing code using concepts common to "
"other languages.  For example, a common idiom in Python is to loop over all "
"elements of an iterable using a :keyword:`for` statement.  Many other "
"languages don't have this type of construct, so people unfamiliar with "
"Python sometimes use a numerical counter instead::"
msgstr ""
"Eine Idee oder ein Codeabschnitt, der sich eng an die gängigsten "
"Konventionen der Programmiersprache Python hält, anstatt Code unter "
"Verwendung von Konzepten zu implementieren, die in anderen Sprachen üblich "
"sind. Ein gängiges Beispiel in Python ist beispielsweise die "
"Durchlaufschleife über alle Elemente eines iterierbaren Objekts mithilfe "
"einer :keyword:`for` Anweisung. Viele andere Sprachen verfügen nicht über "
"eine solche Konstruktion, sodass Personen, die mit Python nicht vertraut "
"sind, manchmal stattdessen einen numerischen Zähler verwenden::"

#: ../../glossary.rst:1347
msgid ""
"for i in range(len(food)):\n"
"    print(food[i])"
msgstr ""
"for i in range(len(food)):\n"
"    print(food[i])"

#: ../../glossary.rst:1350
msgid "As opposed to the cleaner, Pythonic method::"
msgstr "Im Gegensatz zu der übersichtlicheren, pythonischen Methode::"

#: ../../glossary.rst:1352
msgid ""
"for piece in food:\n"
"    print(piece)"
msgstr ""
"für Stück in Essen:\n"
"    print(Stück)"

#: ../../glossary.rst:1354
msgid "qualified name"
msgstr "qualifizierter Name"

#: ../../glossary.rst:1356
msgid ""
"A dotted name showing the \"path\" from a module's global scope to a class, "
"function or method defined in that module, as defined in :pep:`3155`.  For "
"top-level functions and classes, the qualified name is the same as the "
"object's name::"
msgstr ""
"Ein gepunkteter Name, der den \"Pfad\" vom globalen "
"GeltungsbereichGeltungsbereich eines Moduls zu einer in diesem Modul "
"definierten Klasse, Funktion oder Methode angibt, wie in :pep:`3155` "
"definiert. Bei Funktionen und Klassen der obersten Ebene entspricht der "
"qualifizierte Name dem Namen des Objekts::"

#: ../../glossary.rst:1361
msgid ""
">>> class C:\n"
"...     class D:\n"
"...         def meth(self):\n"
"...             pass\n"
"...\n"
">>> C.__qualname__\n"
"'C'\n"
">>> C.D.__qualname__\n"
"'C.D'\n"
">>> C.D.meth.__qualname__\n"
"'C.D.meth'"
msgstr ""
">>> class C:\n"
"...     class D:\n"
"...         def meth(self):\n"
"...             pass\n"
"...\n"
">>> C.__qualname__\n"
"'C'\n"
">>> C.D.__qualname__\n"
"'C.D'\n"
">>> C.D.meth.__qualname__\n"
"'C.D.meth'"

#: ../../glossary.rst:1373
msgid ""
"When used to refer to modules, the *fully qualified name* means the entire "
"dotted path to the module, including any parent packages, e.g. "
"``email.mime.text``::"
msgstr ""
"Im Zusammenhang mit Modulen bezeichnet der *vollständige Name* den gesamten, "
"durch Punkte getrennten Pfad zum Modul, einschließlich aller übergeordneten "
"Pakete, z. B. ``email.mime.text``::"

#: ../../glossary.rst:1377
msgid ""
">>> import email.mime.text\n"
">>> email.mime.text.__name__\n"
"'email.mime.text'"
msgstr ""
">>> import email.mime.text\n"
">>> email.mime.text.__name__\n"
"'email.mime.text'"

#: ../../glossary.rst:1380
msgid "race condition"
msgstr "Race-Condition"

#: ../../glossary.rst:1382
msgid ""
"A condition of a program where the behavior depends on the relative timing "
"or ordering of events, particularly in multi-threaded programs.  Race "
"conditions can lead to :term:`non-deterministic` behavior and bugs that are "
"difficult to reproduce.  A :term:`data race` is a specific type of race "
"condition involving unsynchronized access to shared memory.  "
"The :term:`LBYL` coding style is particularly susceptible to race conditions "
"in multi-threaded code.  Using :term:`locks <lock>` and "
"other :term:`synchronization primitives <synchronization primitive>` helps "
"prevent race conditions."
msgstr ""
"Ein Zustand eines Programms, bei dem das Verhalten vom relativen zeitlichen "
"Ablauf oder der Reihenfolge von Ereignissen abhängt, insbesondere in "
"Multithread-Programmen. Race-Bedingungen können zu :term:`nicht-"
"deterministischem <non-deterministic>` Verhalten und schwer reproduzierbaren "
"Fehlern führen. Ein :term:`Datenrennen <data race>` ist eine spezielle Art "
"von Race Condition, bei der es um den nicht synchronisierten Zugriff auf "
"gemeinsam genutzten Speicher geht. Der :term:`LBYL`-Programmierstil ist in "
"Multithread-Code besonders anfällig für Race Conditions. Die Verwendung "
"von :term:`Locks <lock>` und anderen :term:`Synchronisationsprimitiven "
"<synchronization primitive>` hilft, Race Conditions zu vermeiden."

#: ../../glossary.rst:1392
msgid "reference count"
msgstr "Referenzanzahl"

#: ../../glossary.rst:1394
msgid ""
"The number of references to an object.  When the reference count of an "
"object drops to zero, it is deallocated.  Some objects are :term:`immortal` "
"and have reference counts that are never modified, and therefore the objects "
"are never deallocated.  Reference counting is generally not visible to "
"Python code, but it is a key element of the :term:`CPython` implementation.  "
"Programmers can call the :func:`sys.getrefcount` function to return the "
"reference count for a particular object."
msgstr ""
"Die Anzahl der Verweise auf ein Objekt. Wenn die Referenzanzahl eines "
"Objekts auf null sinkt, wird es freigegeben. Einige Objekte "
"sind :term:`unsterblich <immortal>` und haben Referenzanzahlen, die niemals "
"geändert werden. Daher werden diese Objekte niemals freigegeben. Die "
"Referenzzählung ist für Python-Code im Allgemeinen nicht sichtbar, stellt "
"jedoch ein Schlüsselelement der :term:`CPython`-Implementierung dar. "
"Programmierer können die Funktion :func:`sys.getrefcount` aufrufen, um die "
"Referenzanzahl für ein bestimmtes Objekt abzurufen."

#: ../../glossary.rst:1403
msgid ""
"In :term:`CPython`, reference counts are not considered to be stable or well-"
"defined values; the number of references to an object, and how that number "
"is affected by Python code, may be different between versions."
msgstr ""
"In :term:`CPython` gelten Referenzzähler nicht als stabile oder genau "
"definierte Werte. Die Anzahl der Verweise auf ein Objekt und die Art und "
"Weise, wie diese Anzahl durch Python-Code beeinflusst wird, kann je nach "
"Version variieren."

#: ../../glossary.rst:1407
msgid "regular package"
msgstr "Standardpaket"

#: ../../glossary.rst:1409
msgid ""
"A traditional :term:`package`, such as a directory containing an "
"``__init__.py`` file."
msgstr ""
"Ein herkömmliches :term:`Paket <package>`, beispielsweise ein Verzeichnis, "
"das eine Datei vom Typ ``__init__.py`` enthält."

#: ../../glossary.rst:1412
msgid "See also :term:`namespace package`."
msgstr "Siehe auch: :term:`Namespace-Paket <namespace package>`."

#: ../../glossary.rst:1413
msgid "reentrant"
msgstr "wiederkehrend"

#: ../../glossary.rst:1415
msgid ""
"A property of a function or :term:`lock` that allows it to be called or "
"acquired multiple times by the same thread without causing errors or "
"a :term:`deadlock`."
msgstr ""
"Eine Eigenschaft einer Funktion oder eines :term:`lock`, die es ermöglicht, "
"dass diese mehrfach vom selben Thread aufgerufen bzw. erworben wird, ohne "
"dass dabei Fehler oder ein :term:`Deadlock <deadlock>` auftreten."

#: ../../glossary.rst:1419
msgid ""
"For functions, reentrancy means the function can be safely called again "
"before a previous invocation has completed, which is important when "
"functions may be called recursively or from signal handlers. Thread-unsafe "
"functions may be :term:`non-deterministic` if they're called reentrantly in "
"a multithreaded program."
msgstr ""
"Bei Funktionen bedeutet Reentranz, dass die Funktion sicher erneut "
"aufgerufen werden kann, bevor ein vorheriger Aufruf abgeschlossen ist. Dies "
"ist wichtig, wenn Funktionen rekursiv oder aus Signal-Handlern heraus "
"aufgerufen werden können. Thread-unsichere Funktionen können :term:`nicht "
"deterministisch <non-deterministic>` sein, wenn sie in einem Multithread-"
"Programm reentrant aufgerufen werden."

#: ../../glossary.rst:1425
msgid ""
"For locks, Python's :class:`threading.RLock` (reentrant lock) is reentrant, "
"meaning a thread that already holds the lock can acquire it again without "
"blocking.  In contrast, :class:`threading.Lock` is not reentrant - "
"attempting to acquire it twice from the same thread will cause a deadlock."
msgstr ""
"Bei Locks ist Pythons :class:`threading.RLock` (wiedereintrittsfähiges Lock) "
"reentrant, das heißt, ein Thread, der das Lock bereits hält, kann es erneut "
"erwerben, ohne zu blockieren. Im Gegensatz dazu ist :class:`threading.Lock` "
"nicht reentrant – der Versuch, es zweimal aus demselben Thread zu erwerben, "
"führt zu einem Deadlock."

#: ../../glossary.rst:1431
msgid "See also :term:`lock` and :term:`deadlock`."
msgstr "Siehe auch :term:`lock` und :term:`deadlock`."

#: ../../glossary.rst:1432
msgid "REPL"
msgstr "REPL"

#: ../../glossary.rst:1434
msgid ""
"An acronym for the \"read–eval–print loop\", another name for "
"the :term:`interactive` interpreter shell."
msgstr ""
"Eine Abkürzung für \"read–eval–print loop\" (Lesen–Auswerten–Ausgeben-"
"Schleife), eine andere Bezeichnung für die :term:`interaktive <interactive>` "
"Interpreter-Shell."

#: ../../glossary.rst:1436
msgid "__slots__"
msgstr "__slots__"

#: ../../glossary.rst:1438
msgid ""
"A declaration inside a class that saves memory by pre-declaring space for "
"instance attributes and eliminating instance dictionaries.  Though popular, "
"the technique is somewhat tricky to get right and is best reserved for rare "
"cases where there are large numbers of instances in a memory-critical "
"application."
msgstr ""
"Eine Deklaration innerhalb einer Klasse, die Speicherplatz spart, indem "
"Speicherplatz für Instanzattribute vorab reserviert und Instanz-Dictionaries "
"vermieden werden. Obwohl diese Technik weit verbreitet ist, ist ihre "
"korrekte Anwendung etwas knifflig und sollte am besten nur in seltenen "
"Fällen eingesetzt werden, in denen in einer speicherintensiven Anwendung "
"eine große Anzahl von Instanzen vorliegt."

#: ../../glossary.rst:1443
msgid "sequence"
msgstr "Sequenz"

#: ../../glossary.rst:1445
msgid ""
"An :term:`iterable` which supports efficient element access using integer "
"indices via the :meth:`~object.__getitem__` special method and defines "
"a :meth:`~object.__len__` method that returns the length of the sequence. "
"Some built-in sequence types "
"are :class:`list`, :class:`str`, :class:`tuple`, and :class:`bytes`. Note "
"that :class:`dict` also supports :meth:`~object.__getitem__` and :meth:`!"
"__len__`, but is considered a mapping rather than a sequence because the "
"lookups use arbitrary :term:`hashable` keys rather than integers."
msgstr ""
"Ein :term:`iterable`, das einen effizienten Zugriff auf Elemente mithilfe "
"ganzzahliger Indizes über die spezielle Methode :meth:`~object.__getitem__` "
"unterstützt und eine Methode :meth:`~object.__len__` definiert, die die "
"Länge der Sequenz zurückgibt. Einige integrierte Sequenztypen "
"sind :class:`list`, :class:`str`, :class:`tuple` und :class:`bytes`. "
"Beachte, dass :class:`dict` ebenfalls :meth:`~object.__getitem__` "
"und :meth:`!__len__` unterstützt, jedoch eher als Mapping denn als Sequenz "
"betrachtet wird, da die Suchvorgänge beliebige :term:`hashable`-Schlüssel "
"anstelle von Ganzzahlen verwenden."

#: ../../glossary.rst:1454
msgid ""
"The :class:`collections.abc.Sequence` abstract base class defines a much "
"richer interface that goes beyond just :meth:`~object.__getitem__` "
"and :meth:`~object.__len__`, "
"adding :meth:`~sequence.count`, :meth:`~sequence.index`, :meth:`~object.__contains__`, "
"and :meth:`~object.__reversed__`. Types that implement this expanded "
"interface can be registered explicitly using :func:`~abc.ABCMeta.register`. "
"For more documentation on sequence methods generally, see :ref:`Common "
"Sequence Operations <typesseq-common>`."
msgstr ""
"Die abstrakte Basisklasse :class:`collections.abc.Sequence` definiert eine "
"wesentlich umfangreichere Schnittstelle, die über die "
"Methoden :meth:`~object.__getitem__` und :meth:`~object.__len__` hinausgeht "
"und um die "
"Methoden :meth:`~sequence.count`, :meth:`~sequence.index`, :meth:`~object.__contains__` "
"sowie :meth:`~object.__reversed__` erweitert wird. Typen, die diese "
"erweiterte Schnittstelle implementieren, können explizit "
"mit :func:`~abc.ABCMeta.register` registriert werden. Weitere Informationen "
"zu Sequenzmethoden im Allgemeinen findest du unter :ref:`Common Sequence "
"Operations <typesseq-common>`."

#: ../../glossary.rst:1464
msgid "set comprehension"
msgstr "Set Comprehension"

#: ../../glossary.rst:1466
msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a set with the results. ``results = {c for c in 'abracadabra' if c "
"not in 'abc'}`` generates the set of strings ``{'r', 'd'}``.  "
"See :ref:`comprehensions`."
msgstr ""
"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer "
"iterierbares Objekt zu verarbeiten und eine Menge mit den Ergebnissen "
"zurückzugeben. ``results = {c for c in 'abracadabra' if c not in 'abc'}`` "
"erzeugt die Menge der Zeichenfolgen ``{'r', 'd'}``. "
"Siehe :ref:`comprehensions`."

#: ../../glossary.rst:1470
msgid "single dispatch"
msgstr "Single Dispatch"

#: ../../glossary.rst:1472
msgid ""
"A form of :term:`generic function` dispatch where the implementation is "
"chosen based on the type of a single argument."
msgstr ""
"Eine Form der :term:`generischen Funktionsauswahl <generic function>`, bei "
"der die Implementierung anhand des Typs eines einzelnen Arguments ausgewählt "
"wird."

#: ../../glossary.rst:1474
msgid "slice"
msgstr "Slice"

#: ../../glossary.rst:1476
msgid ""
"An object of type :class:`slice`, used to describe a portion of "
"a :term:`sequence`. A slice object is created when using the :ref:`slicing "
"<slicings>` form of :ref:`subscript notation <subscriptions>`, with colons "
"inside square brackets, such as in ``variable_name[1:3:5]``."
msgstr ""
"Ein Objekt vom Typ :class:`slice`, das zur Beschreibung eines Teils "
"einer :term:`Sequenz <sequence>` dient. Ein Slice-Objekt wird erstellt, wenn "
"die Form des :ref:`Slicings <slicings>` der :ref:`Indexnotation "
"<subscriptions>` verwendet wird, bei der Doppelpunkte in eckigen Klammern "
"stehen, wie beispielsweise in ``variable_name[1:3:5]``."

#: ../../glossary.rst:1481
msgid "soft deprecated"
msgstr "sanft abgekündigt"

#: ../../glossary.rst:1483
msgid ""
"A soft deprecated API should not be used in new code, but it is safe for "
"already existing code to use it. The API remains documented and tested, but "
"will not be enhanced further."
msgstr ""
"Eine soft deprecated API sollte in neuem Code nicht mehr verwendet werden, "
"bei bereits vorhandenem Code ist ihre Verwendung jedoch unbedenklich. Die "
"API bleibt dokumentiert und wird weiterhin getestet, wird jedoch nicht mehr "
"weiterentwickelt."

#: ../../glossary.rst:1487
msgid ""
"Soft deprecation, unlike normal deprecation, does not plan on removing the "
"API and will not emit warnings."
msgstr ""
"Im Gegensatz zur normalen Veralterung ist bei einer Soft Deprecation nicht "
"vorgesehen, die API zu entfernen, und es werden keine Warnungen ausgegeben."

#: ../../glossary.rst:1490
msgid ""
"See `PEP 387: Soft Deprecation <https://peps.python.org/pep-0387/#soft-"
"deprecation>`_."
msgstr ""
"Siehe `PEP 387: Soft Deprecation <https://peps.python.org/pep-0387/#soft-"
"deprecation>`_."

#: ../../glossary.rst:1492
msgid "special method"
msgstr "spezielle Methode"

#: ../../glossary.rst:1496
msgid ""
"A method that is called implicitly by Python to execute a certain operation "
"on a type, such as addition.  Such methods have names starting and ending "
"with double underscores.  Special methods are documented "
"in :ref:`specialnames`."
msgstr ""
"Eine Methode, die von Python implizit aufgerufen wird, um eine bestimmte "
"Operation auf einem Typ auszuführen, beispielsweise eine Addition. Die Namen "
"solcher Methoden beginnen und enden mit zwei Unterstrichen. Spezielle "
"Methoden sind unter :ref:`specialnames` dokumentiert."

#: ../../glossary.rst:1500
msgid "standard library"
msgstr "Standardbibliothek"

#: ../../glossary.rst:1502
msgid ""
"The collection of :term:`packages <package>`, :term:`modules <module>` "
"and :term:`extension modules <extension module>` distributed as a part of "
"the official Python interpreter package.  The exact membership of the "
"collection may vary based on platform, available system libraries, or other "
"criteria.  Documentation can be found at :ref:`library-index`."
msgstr ""
"Die Sammlung von :term:`Paketen <package>`, :term:`Modulen <module>` "
"und :term:`Erweiterungsmodulen <extension module>`, die als Teil des "
"offiziellen Python-Interpreter-Pakets bereitgestellt wird. Der genaue Umfang "
"der Sammlung kann je nach Plattform, verfügbaren Systembibliotheken oder "
"anderen Kriterien variieren. Die Dokumentation findest du "
"unter :ref:`library-index`."

#: ../../glossary.rst:1508
msgid ""
"See also :data:`sys.stdlib_module_names` for a list of all possible standard "
"library module names."
msgstr ""
"Eine Liste aller möglichen Namen von Standardbibliotheksmodulen findest du "
"unter :data:`sys.stdlib_module_names`."

#: ../../glossary.rst:1510
msgid "statement"
msgstr "Erklärung"

#: ../../glossary.rst:1512
msgid ""
"A statement is part of a suite (a \"block\" of code).  A statement is either "
"an :term:`expression` or one of several constructs with a keyword, such "
"as :keyword:`if`, :keyword:`while` or :keyword:`for`."
msgstr ""
"Eine Anweisung ist Teil einer Suite (eines \"Code-Blocks\"). Eine Anweisung "
"ist entweder ein :term:`Ausdruck <expression>` oder eine von mehreren "
"Konstrukten mit einem Schlüsselwort, wie "
"beispielsweise :keyword:`if` , :keyword:`while` oder :keyword:`for` ."

#: ../../glossary.rst:1515
msgid "static type checker"
msgstr "statischer Typprüfer"

#: ../../glossary.rst:1517
msgid ""
"An external tool that reads Python code and analyzes it, looking for issues "
"such as incorrect types. See also :term:`type hints <type hint>` and "
"the :mod:`typing` module."
msgstr ""
"Ein externes Tool, das Python-Code ausliest und analysiert, um Probleme wie "
"beispielsweise falsche Typen zu erkennen. Siehe auch :term:`Typangaben <type "
"hint>` und das Modul :mod:`typing` ."

#: ../../glossary.rst:1520
msgid "stdlib"
msgstr "stdlib"

#: ../../glossary.rst:1522
msgid "An abbreviation of :term:`standard library`."
msgstr "Eine Abkürzung für :term:`Standardbibliothek <standard library>`."

#: ../../glossary.rst:1523
msgid "steal"
msgstr "stehlen"

#: ../../glossary.rst:1525
msgid ""
"In Python's C API, \"*stealing*\" an argument means that ownership of the "
"argument is transferred to the called function. The caller must not use that "
"reference after the call. Generally, functions that \"steal\" an argument do "
"so even if they fail."
msgstr ""
"In der C-API von Python bedeutet das *Stehlen* eines Arguments, dass das "
"Eigentumsrecht an dem Argument auf die aufgerufene Funktion übertragen wird. "
"Der Aufrufer darf diese Referenz nach dem Aufruf nicht mehr verwenden. Im "
"Allgemeinen tun Funktionen, die ein Argument stehlen, dies auch dann, wenn "
"sie fehlschlagen."

#: ../../glossary.rst:1530
msgid "See :ref:`api-refcountdetails` for a full explanation."
msgstr ""
"Eine ausführliche Erläuterung findest du unter :ref:`api-refcountdetails`."

#: ../../glossary.rst:1531
msgid "strong reference"
msgstr "starke Referenz"

#: ../../glossary.rst:1533
msgid ""
"In Python's C API, a strong reference is a reference to an object which is "
"owned by the code holding the reference.  The strong reference is taken by "
"calling :c:func:`Py_INCREF` when the reference is created and released "
"with :c:func:`Py_DECREF` when the reference is deleted."
msgstr ""
"In der C-API von Python ist eine starke Referenz eine Referenz auf ein "
"Objekt, das dem Code gehört, der die Referenz enthält. Die starke Referenz "
"wird durch den Aufruf von  :c:func:`Py_INCREF`  beim Erstellen der Referenz "
"hergestellt und durch den Aufruf von  :c:func:`Py_DECREF`  beim Löschen der "
"Referenz freigegeben."

#: ../../glossary.rst:1539
msgid ""
"The :c:func:`Py_NewRef` function can be used to create a strong reference to "
"an object. Usually, the :c:func:`Py_DECREF` function must be called on the "
"strong reference before exiting the scope of the strong reference, to avoid "
"leaking one reference."
msgstr ""
"Mit der Funktion :c:func:`Py_NewRef` lässt sich eine starke Referenz auf ein "
"Objekt erstellen. In der Regel muss die Funktion :c:func:`Py_DECREF` für die "
"starke Referenz aufgerufen werden, bevor der Geltungsbereich der starken "
"Referenz verlassen wird, um ein Referenzleck zu vermeiden."

#: ../../glossary.rst:1544
msgid "See also :term:`borrowed reference`."
msgstr "Siehe auch: :term:`entlehnte Referenz <borrowed reference>`."

#: ../../glossary.rst:1545
msgid "subscript"
msgstr "Indexzugriff"

#: ../../glossary.rst:1547
msgid ""
"The expression in square brackets of a :ref:`subscription expression "
"<subscriptions>`, for example, the ``3`` in ``items[3]``. Usually used to "
"select an element of a container. Also called a :term:`key` when "
"subscripting a :term:`mapping`, or an :term:`index` when subscripting "
"a :term:`sequence`."
msgstr ""
"Der Ausdruck in eckigen Klammern eines :ref:`Indexausdrucks "
"<subscriptions>`, zum Beispiel die ``3`` in ``items[3]``. Wird in der Regel "
"verwendet, um ein Element eines Containers auszuwählen. Wird auch "
"als :term:`Schlüssel <key>` bezeichnet, wenn auf ein :term:`Mapping "
"<mapping>` zugegriffen wird, oder als :term:`Index <index>`, wenn auf "
"eine :term:`Sequenz <sequence>` zugegriffen wird."

#: ../../glossary.rst:1553
msgid "synchronization primitive"
msgstr "Synchronisationsprimitiv"

#: ../../glossary.rst:1555
msgid ""
"A basic building block for coordinating (synchronizing) the execution of "
"multiple threads to ensure :term:`thread-safe` access to shared resources. "
"Python's :mod:`threading` module provides several synchronization primitives "
"including :class:`~threading.Lock`, :class:`~threading.RLock`, :class:`~threading.Semaphore`, :class:`~threading.Condition`, :class:`~threading.Event`, "
"and :class:`~threading.Barrier`.  Additionally, the :mod:`queue` module "
"provides multi-producer, multi-consumer queues that are especially useful in "
"multithreaded programs. These primitives help prevent :term:`race conditions "
"<race condition>` and coordinate thread execution.  See also :term:`lock`."
msgstr ""
"Ein grundlegender Baustein zur Koordination (Synchronisation) der Ausführung "
"mehrerer Threads, um einen :term:`thread-sicheren <thread-safe>` Zugriff auf "
"gemeinsam genutzte Ressourcen zu gewährleisten. Das Python-"
"Modul :mod:`threading` stellt mehrere Synchronisationsprimitive bereit, "
"darunter :class:`~threading.Lock`, :class:`~threading.RLock`, :class:`~threading.Semaphore`, :class:`~threading.Condition`, :class:`~threading.Event` "
"und :class:`~threading.Barrier`. Darüber hinaus bietet das "
"Modul :mod:`queue` Multi-Producer- und Multi-Consumer-Warteschlangen, die "
"besonders in Multithread-Programmen nützlich sind. Diese Primitive tragen "
"dazu bei, :term:`Race-Conditions <race condition>` zu verhindern und die "
"Thread-Ausführung zu koordinieren. Siehe auch :term:`Sperre <lock>`."

#: ../../glossary.rst:1565
msgid "t-string"
msgstr "t-String"

#: ../../glossary.rst:1566
msgid "t-strings"
msgstr "t-Strings"

#: ../../glossary.rst:1568
msgid ""
"String literals prefixed with ``t`` or ``T`` are commonly called \"t-"
"strings\" which is short for :ref:`template string literals <t-strings>`."
msgstr ""
"Zeichenkette, denen ``t`` oder ``T`` vorangestellt ist, werden gemeinhin als "
"t-Strings bezeichnet, was die Abkürzung für :ref:`Template-"
"Zeichenfolgenliterale <t-strings>` ist."

#: ../../glossary.rst:1571
msgid "text encoding"
msgstr "Textkodierung"

#: ../../glossary.rst:1573
msgid ""
"A string in Python is a sequence of Unicode code points (in range "
"``U+0000``--``U+10FFFF``). To store or transfer a string, it needs to be "
"serialized as a sequence of bytes."
msgstr ""
"Eine Zeichenkette in Python ist eine Folge von Unicode-Codepunkten (im "
"Bereich ``U+0000``--``U+10FFFF``). Um eine Zeichenkette zu speichern oder zu "
"übertragen, muss sie als Bytefolge serialisiert werden."

#: ../../glossary.rst:1577
msgid ""
"Serializing a string into a sequence of bytes is known as \"encoding\", and "
"recreating the string from the sequence of bytes is known as \"decoding\"."
msgstr ""
"Die Umwandlung einer Zeichenkette in eine Bytefolge wird als \"Kodierung\" "
"bezeichnet, und die Rekonstruktion der Zeichenkette aus der Bytefolge wird "
"als \"Dekodierung\" bezeichnet."

#: ../../glossary.rst:1580
msgid ""
"There are a variety of different text serialization :ref:`codecs <standard-"
"encodings>`, which are collectively referred to as \"text encodings\"."
msgstr ""
"Es gibt eine Vielzahl verschiedener Text-"
"Serialisierungsverfahren :ref:`Codecs <standard-encodings>`, die "
"zusammenfassend als \"Textkodierungen\" bezeichnet werden."

#: ../../glossary.rst:1583
msgid "text file"
msgstr "Textdatei"

#: ../../glossary.rst:1585
msgid ""
"A :term:`file object` able to read and write :class:`str` objects. Often, a "
"text file actually accesses a byte-oriented datastream and handles "
"the :term:`text encoding` automatically. Examples of text files are files "
"opened in text mode (``'r'`` or "
"``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and instances "
"of :class:`io.StringIO`."
msgstr ""
"Ein :term:`Dateiobjekt <file object>`, das :class:`str`-Objekte lesen und "
"schreiben kann. Häufig greift eine Textdatei tatsächlich auf einen "
"byteorientierten Datenstrom zu und übernimmt die :term:`Textkodierung <text "
"encoding>` automatisch. Beispiele für Textdateien sind Dateien, die im "
"Textmodus geöffnet wurden (``'r'`` oder "
"``'w'``), :data:`sys.stdin`, :data:`sys.stdout` sowie Instanzen "
"von :class:`io.StringIO`."

#: ../../glossary.rst:1592
msgid ""
"See also :term:`binary file` for a file object able to read and "
"write :term:`bytes-like objects <bytes-like object>`."
msgstr ""
"Siehe auch :term:`Binärdatei <binary file>` für ein Dateiobjekt, "
"das :term:`byteähnliche Objekte <bytes-like object>` lesen und schreiben "
"kann."

#: ../../glossary.rst:1594
msgid "thread state"
msgstr "Thread-Zustand"

#: ../../glossary.rst:1597
msgid ""
"The information used by the :term:`CPython` runtime to run in an OS thread. "
"For example, this includes the current exception, if any, and the state of "
"the bytecode interpreter."
msgstr ""
"Die Informationen, die von der :term:`CPython`-Laufzeitumgebung verwendet "
"werden, um in einem Betriebssystem-Thread ausgeführt zu werden. Dazu gehören "
"beispielsweise die aktuelle Ausnahme (falls vorhanden) und der Zustand des "
"Bytecode-Interpreters."

#: ../../glossary.rst:1601
msgid ""
"Each thread state is bound to a single OS thread, but threads may have many "
"thread states available.  At most, one of them may be :term:`attached "
"<attached thread state>` at once."
msgstr ""
"Jeder Thread-Zustand ist an genau einen Betriebssystem-Thread gebunden, "
"einem Thread können aber mehrere Thread-Zustände zur Verfügung stehen. "
"Höchstens einer von ihnen darf zugleich :term:`angehängt <attached thread "
"state>` sein."

#: ../../glossary.rst:1605
msgid ""
"An :term:`attached thread state` is required to call most of Python's C API, "
"unless a function explicitly documents otherwise. The bytecode interpreter "
"only runs under an attached thread state."
msgstr ""
"Für den Aufruf der meisten Funktionen der Python-C-API ist "
"ein :term:`angeschlossener Thread-Zustand <attached thread state>` "
"erforderlich, sofern in der Dokumentation einer Funktion nicht ausdrücklich "
"etwas anderes angegeben ist. Der Bytecode-Interpreter läuft nur unter einem "
"angeschlossenen Thread-Zustand."

#: ../../glossary.rst:1609
msgid ""
"Each thread state belongs to a single interpreter, but each interpreter may "
"have many thread states, including multiple for the same OS thread. Thread "
"states from multiple interpreters may be bound to the same thread, but only "
"one can be :term:`attached <attached thread state>` in that thread at any "
"given moment."
msgstr ""
"Jeder Thread-Zustand gehört zu einem einzelnen Interpreter, aber jeder "
"Interpreter kann viele Thread-Zustände haben, darunter auch mehrere für "
"denselben Betriebssystem-Thread. Thread-Zustände aus mehreren Interpretern "
"können an denselben Thread gebunden sein, aber zu jedem Zeitpunkt kann nur "
"einer in diesem Thread :term:`angeschlossen <attached thread state>` sein."

#: ../../glossary.rst:1615
msgid ""
"See :ref:`Thread State and the Global Interpreter Lock <threads>` for more "
"information."
msgstr ""
"Weitere Informationen findest du unter :ref:`Thread-Zustand und das Global "
"Interpreter Lock <threads>`."

#: ../../glossary.rst:1617
msgid "thread-safe"
msgstr "thread-sicher"

#: ../../glossary.rst:1619
msgid ""
"A module, function, or class that behaves correctly when used by multiple "
"threads concurrently.  Thread-safe code uses "
"appropriate :term:`synchronization primitives <synchronization primitive>` "
"like :term:`locks <lock>` to protect shared mutable state, or is designed to "
"avoid shared mutable state entirely.  In the :term:`free-threaded <free "
"threading>` build, built-in types like :class:`dict`, :class:`list`, "
"and :class:`set` use internal locking to make many operations thread-safe, "
"although thread safety is not necessarily guaranteed.  Code that is not "
"thread-safe may experience :term:`race conditions <race condition>` "
"and :term:`data races <data race>` when used in multi-threaded programs."
msgstr ""
"Ein Modul, eine Funktion oder eine Klasse, die sich bei gleichzeitiger "
"Nutzung durch mehrere Threads korrekt verhält. Thread-sicherer Code "
"verwendet geeignete :term:`Synchronisationsprimitive <synchronization "
"primitive>` wie :term:`Locks <lock>`, um gemeinsam genutzte, veränderbare "
"Zustände zu schützen, oder ist so konzipiert, dass gemeinsam genutzte, "
"veränderbare Zustände gänzlich vermieden werden. In der :term:`free-threaded "
"<free threading>`-Version verwenden integrierte Typen "
"wie :class:`dict`, :class:`list` und :class:`set` interne Sperren, um viele "
"Operationen threadsicher zu machen, obwohl die Threadsicherheit nicht "
"unbedingt garantiert ist. Code, der nicht threadsicher ist, kann bei der "
"Verwendung in Multithread-Programmen zu :term:`Race-Conditions <race "
"condition>` und :term:`Datenkonflikten <data race>` führen."

#: ../../glossary.rst:1630
msgid "token"
msgstr "Token"

#: ../../glossary.rst:1633
msgid ""
"A small unit of source code, generated by the :ref:`lexical analyzer "
"<lexical>` (also called the *tokenizer*). Names, numbers, strings, "
"operators, newlines and similar are represented by tokens."
msgstr ""
"Eine kleine Einheit des Quellcodes, die vom :ref:`lexikalischen Analysator "
"<lexical>` (auch *Tokenizer* genannt) generiert wird. Namen, Zahlen, "
"Zeichenketten, Operatoren, Zeilenumbrüche und Ähnliches werden durch Token "
"dargestellt."

#: ../../glossary.rst:1638
msgid ""
"The :mod:`tokenize` module exposes Python's lexical analyzer. "
"The :mod:`token` module contains information on the various types of tokens."
msgstr ""
"Das Modul  :mod:`tokenize`  stellt den lexikalischen Analysator von Python "
"bereit. Das Modul  :mod:`token`  enthält Informationen zu den verschiedenen "
"Token-Typen."

#: ../../glossary.rst:1641
msgid "triple-quoted string"
msgstr "Zeichenkette in dreifachen Anführungszeichen"

#: ../../glossary.rst:1643
msgid ""
"A string which is bound by three instances of either a quotation mark (\") "
"or an apostrophe (').  While they don't provide any functionality not "
"available with single-quoted strings, they are useful for a number of "
"reasons.  They allow you to include unescaped single and double quotes "
"within a string and they can span multiple lines without the use of the "
"continuation character, making them especially useful when writing "
"docstrings."
msgstr ""
"Eine Zeichenkette, die durch drei aufeinanderfolgende einfache "
"Anführungszeichen (\") oder Apostrophe (') begrenzt wird. Obwohl sie keine "
"Funktionen bieten, die bei Zeichenketten in einfachen Anführungszeichen "
"nicht verfügbar sind, sind sie aus verschiedenen Gründen nützlich. Sie "
"ermöglichen es, nicht maskierte einfache und doppelte Anführungszeichen in "
"eine Zeichenkette einzufügen, und sie können sich über mehrere Zeilen "
"erstrecken, ohne dass das Fortsetzungszeichen verwendet werden muss, was sie "
"besonders nützlich beim Schreiben von Docstrings macht."

#: ../../glossary.rst:1650
msgid "type"
msgstr "Typ"

#: ../../glossary.rst:1652
msgid ""
"The type of a Python object determines what kind of object it is; every "
"object has a type.  An object's type is accessible as "
"its :attr:`~object.__class__` attribute or can be retrieved with "
"``type(obj)``."
msgstr ""
"Der Typ eines Python-Objekts bestimmt, um welche Art von Objekt es sich "
"handelt. Jedes Objekt hat einen Typ. Der Typ eines Objekts ist über das "
"Attribut :attr:`~object.__class__` zugänglich oder kann mit ``type(obj)`` "
"abgerufen werden."

#: ../../glossary.rst:1656
msgid "type alias"
msgstr "Typalias"

#: ../../glossary.rst:1658
msgid "A synonym for a type, created by assigning the type to an identifier."
msgstr ""
"Ein Synonym für einen Typ, das durch die Zuweisung des Typs zu einem "
"Bezeichner erstellt wird."

#: ../../glossary.rst:1660
msgid ""
"Type aliases are useful for simplifying :term:`type hints <type hint>`. For "
"example::"
msgstr ""
"Typ-Aliase sind nützlich, um :term:`Typ-Hinweise <type hint>` zu "
"vereinfachen. Zum Beispiel::"

#: ../../glossary.rst:1663
msgid ""
"def remove_gray_shades(\n"
"        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n"
"    pass"
msgstr ""
"def remove_gray_shades(\n"
"        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n"
"    pass"

#: ../../glossary.rst:1667
msgid "could be made more readable like this::"
msgstr "könnte so lesbarer gestaltet werden::"

#: ../../glossary.rst:1669
msgid ""
"Color = tuple[int, int, int]\n"
"\n"
"def remove_gray_shades(colors: list[Color]) -> list[Color]:\n"
"    pass"
msgstr ""
"Farbe = Tupel[int, int, int]\n"
"\n"
"def remove_gray_shades(colors: Liste[Farbe]) -> Liste[Farbe]:\n"
"    pass"

#: ../../glossary.rst:1674 ../../glossary.rst:1688
msgid "See :mod:`typing` and :pep:`484`, which describe this functionality."
msgstr ""
"Siehe :mod:`typing` und :pep:`484`, wo diese Funktion beschrieben wird."

#: ../../glossary.rst:1675
msgid "type hint"
msgstr "Typhinweis"

#: ../../glossary.rst:1677
msgid ""
"An :term:`annotation` that specifies the expected type for a variable, a "
"class attribute, or a function parameter or return value."
msgstr ""
"Eine :term:`Annotation <annotation>`, die den erwarteten Typ für eine "
"Variable, ein Klassenattribut oder einen Funktionsparameter bzw. "
"Rückgabewert angibt."

#: ../../glossary.rst:1680
msgid ""
"Type hints are optional and are not enforced by Python but they are useful "
"to :term:`static type checkers <static type checker>`. They can also aid "
"IDEs with code completion and refactoring."
msgstr ""
"Typangaben sind optional und werden von Python nicht erzwungen, sind jedoch "
"für :term:`statische Typprüfer <static type checker>` nützlich. Außerdem "
"können sie IDEs bei der Code-Vervollständigung und beim Refactoring "
"unterstützen."

#: ../../glossary.rst:1684
msgid ""
"Type hints of global variables, class attributes, and functions, but not "
"local variables, can be accessed using :func:`typing.get_type_hints`."
msgstr ""
"Typhinweise für globale Variablen, Klassenattribute und Funktionen, nicht "
"jedoch für lokale Variablen, können über :func:`typing.get_type_hints` "
"abgerufen werden."

#: ../../glossary.rst:1689
msgid "universal newlines"
msgstr "universelle Zeilenumbrüche"

#: ../../glossary.rst:1691
msgid ""
"A manner of interpreting text streams in which all of the following are "
"recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the "
"Windows convention ``'\\r\\n'``, and the old Macintosh convention "
"``'\\r'``.  See :pep:`278` and :pep:`3116`, as well "
"as :func:`bytes.splitlines` for an additional use."
msgstr ""
"Eine Methode zur Interpretation von Textströmen, bei der alle folgenden "
"Zeichenfolgen als Zeilenende erkannt werden: die Unix-Zeilenende-Konvention "
"``'\\n'``, die Windows-Konvention ``'\\r\\n'`` und die alte Macintosh-"
"Konvention ``'\\r'``. Siehe :pep:`278` und :pep:`3116` "
"sowie :func:`bytes.splitlines` für eine weitere Anwendungsmöglichkeit."

#: ../../glossary.rst:1696
msgid "variable annotation"
msgstr "Variablenbeschriftung"

#: ../../glossary.rst:1698
msgid "An :term:`annotation` of a variable or a class attribute."
msgstr ""
"Eine :term:`Annotation <annotation>` einer Variablen oder eines "
"Klassenattributs."

#: ../../glossary.rst:1700
msgid ""
"When annotating a variable or a class attribute, assignment is optional::"
msgstr ""
"Bei der Annotation einer Variablen oder eines Klassenattributs ist die "
"Zuweisung optional::"

#: ../../glossary.rst:1702
msgid ""
"class C:\n"
"    field: 'annotation'"
msgstr ""
"class C:\n"
"    field: 'annotation'"

#: ../../glossary.rst:1705
msgid ""
"Variable annotations are usually used for :term:`type hints <type hint>`: "
"for example this variable is expected to take :class:`int` values::"
msgstr ""
"Variablenannotationen werden in der Regel für :term:`Typangaben <type hint>` "
"verwendet – beispielsweise wird erwartet, dass diese Variable Werte vom "
"Typ :class:`int` annimmt::"

#: ../../glossary.rst:1709
msgid "count: int = 0"
msgstr "Zähler: int = 0"

#: ../../glossary.rst:1711
msgid "Variable annotation syntax is explained in section :ref:`annassign`."
msgstr ""
"Die Syntax für die Annotation von Variablen wird im "
"Abschnitt :ref:`annassign` erläutert."

#: ../../glossary.rst:1713
msgid ""
"See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe "
"this functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Siehe :term:`Funktionsannotation <function annotation>`, :pep:`484` "
"und :pep:`526`, wo diese Funktionalität beschrieben wird. Siehe "
"auch :ref:`annotations-howto` für bewährte Vorgehensweisen beim Umgang mit "
"Annotationen."

#: ../../glossary.rst:1717
msgid "virtual environment"
msgstr "virtuelle Umgebung"

#: ../../glossary.rst:1719
msgid ""
"A cooperatively isolated runtime environment that allows Python users and "
"applications to install and upgrade Python distribution packages without "
"interfering with the behaviour of other Python applications running on the "
"same system."
msgstr ""
"Eine kooperativ isolierte Laufzeitumgebung, die es Python-Anwendern und-"
"Anwendungen ermöglicht, Python-Distributionspakete zu installieren und zu "
"aktualisieren, ohne das Verhalten anderer Python-Anwendungen zu "
"beeinträchtigen, die auf demselben System ausgeführt werden."

#: ../../glossary.rst:1724
msgid "See also :mod:`venv`."
msgstr "Siehe auch :mod:`venv`."

#: ../../glossary.rst:1725
msgid "virtual machine"
msgstr "virtuelle Maschine"

#: ../../glossary.rst:1727
msgid ""
"A computer defined entirely in software.  Python's virtual machine executes "
"the :term:`bytecode` emitted by the bytecode compiler."
msgstr ""
"Ein vollständig in Software definierter Computer. Die virtuelle Maschine von "
"Python führt den vom Bytecode-Compiler erzeugten :term:`Bytecode <bytecode>` "
"aus."

#: ../../glossary.rst:1729
msgid "walrus operator"
msgstr "Walross-Betreiber"

#: ../../glossary.rst:1731
msgid ""
"A light-hearted way to refer to the :ref:`assignment expression <assignment-"
"expressions>` operator ``:=`` because it looks a bit like a walrus if you "
"turn your head."
msgstr ""
"Eine scherzhafte Bezeichnung für den :ref:`Zuweisungsausdruck <assignment-"
"expressions>` Operator ``:=``, da er ein bisschen wie ein Walross aussieht, "
"wenn man den Kopf etwas dreht."

#: ../../glossary.rst:1734
msgid "Zen of Python"
msgstr "Zen von Python"

#: ../../glossary.rst:1736
msgid ""
"Listing of Python design principles and philosophies that are helpful in "
"understanding and using the language.  The listing can be found by typing "
"\"``import this``\" at the interactive prompt."
msgstr ""
"Eine Auflistung der Python-Entwurfsprinzipien und -Philosophien, die zum "
"Verständnis und zur Anwendung der Sprache hilfreich sind. Die Auflistung "
"kann durch Eingabe von \"``import this`` \" an der interaktiven "
"Eingabeaufforderung aufgerufen werden."

#: ../../glossary.rst:24
msgid "..."
msgstr "..."

#: ../../glossary.rst:24
msgid "ellipsis literal"
msgstr "Ellipsis-Literal"

#: ../../glossary.rst:349
msgid "C-contiguous"
msgstr "C-zusammenhängend"

#: ../../glossary.rst:349
msgid "Fortran contiguous"
msgstr "Fortran–zusammenhängend"

#: ../../glossary.rst:1008
msgid "magic"
msgstr "Magie"

#: ../../glossary.rst:1494
msgid "special"
msgstr "besonders"