glossary.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Swen Bachmann, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-22 12:07+0200\n"
"PO-Revision-Date: 2026-08-30 00:02+0000\n"
"Last-Translator: Swen Bachmann <142266608+sba72@users.noreply.github.com>\n"
"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../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 ""
"Eine Callable-Funktion, die aufgerufen werden kann, um die :term:"
"`Annotationen <annotation>` eines Objekts abzurufen. Annotate-Funktionen "
"sind in der Regel :term:`Funktionen <function>`, die automatisch als "
"Attribut  :attr:`~object.__annotate__`  von Funktionen, Klassen und Modulen "
"generiert werden. Annotate-Funktionen sind eine Teilmenge der :term:"
"`Evaluate-Funktionen <evaluate function>`."

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

#: ../../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 <keyword argument>`: Ein Argument, dem in einem "
"Funktionsaufruf ein Bezeichner vorangestellt ist (z. B. ``name=``) oder das "
"in einem Wörterbuch 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>` "
"sowie :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 Iterabel"

#: ../../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 "Zustand des angehängten Threads"

#: ../../glossary.rst:151
msgid "A :term:`thread state` that is active for the current OS thread."
msgstr ""
"Ein :term:`Thread-Status <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-Status <thread state>` zugeordnet 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-Status aufzurufen, zu einem "
"schwerwiegenden Fehler oder zu undefiniertem Verhalten. Ein Thread-Status "
"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 zugeordneter 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 zugeordneten "
"Thread-Zustand haben kann. In :term:`free-threaded-Versionen <free-threaded "
"build>` von Python können mehrere Threads gleichzeitig einen angehängten "
"Thread-Status 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:`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 Gültigkeitsbereich <nested scope>` verwiesen wird und die "
"in einem äußeren Gültigkeitsbereich definiert ist, anstatt zur Laufzeit aus "
"den globalen oder eingebauten 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 "Koroutine"

#: ../../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:`Schlössern <lock>` und anderen :term:"
"`Synchronisationsprimitiven <synchronization primitive>` verhindert "
"Datenkonflikte. Beachte, dass Datenkonflikte nur in nativem Code auftreten "
"können, dass :term:`Nativcode <native code>` jedoch in einer Python-API "
"zugänglich gemacht werden kann. Siehe auch :term:`Race-Condition <race "
"condition>` und :term:`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 "Dekorateur"

#: ../../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 Klassenwörterbuch 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 Funktionen bilden, "
"darunter Funktionen, Methoden, Eigenschaften, 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 "Wörterbuch"

#: ../../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 "Wörterbuchverständnis"

#: ../../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 Wörterbuch mit den Ergebnissen "
"zurückzugeben.  ``results = {n: n ** 2 for n in range(10)}``  generiert ein "
"Wörterbuch, das Schlüssel- ``n`` enthält, die den Wert- ``n ** 2`` "
"zugeordnet sind. Siehe :ref:`comprehensions`."

#: ../../glossary.rst:462
msgid "dictionary view"
msgstr "Wörterbuchansicht"

#: ../../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 ""
"Ein String-Literal, das als erster Ausdruck in einer Klasse, Funktion oder "
"einem Modul erscheint. Es wird zwar bei der Ausführung der Testsuite "
"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 "expression"
msgstr "Ausdruck"

#: ../../glossary.rst:509
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.  In "
"contrast to many other languages, 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.  Im Gegensatz zu vielen anderen Sprachen sind "
"nicht alle Sprachkonstrukte 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:516
msgid "extension module"
msgstr "Erweiterungsmodul"

#: ../../glossary.rst:518
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:520
msgid "f-string"
msgstr "f-String"

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

#: ../../glossary.rst:523
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 ""
"Zeichenfolgenliterale, 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:526
msgid "file object"
msgstr "Dateiobjekt"

#: ../../glossary.rst:528
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:536
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:541
msgid "file-like object"
msgstr "dateiähnliches Objekt"

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

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

#: ../../glossary.rst:546
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:549
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:553
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:557
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:562
msgid "See also the :term:`locale encoding`."
msgstr ""
"Siehe auch den Begriff :term:`Lokalisierungskodierung <locale encoding>`."

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

#: ../../glossary.rst:565
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:568
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:572
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:573
msgid "floor division"
msgstr "Etagenaufteilung"

#: ../../glossary.rst:575
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:580
msgid "free threading"
msgstr "freies Einfädeln"

#: ../../glossary.rst:582
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:586
msgid "free-threaded build"
msgstr "Build mit freien Threads"

#: ../../glossary.rst:589
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:592
msgid "See :ref:`freethreading-python-howto`."
msgstr "Siehe :ref:`freethreading-python-howto`."

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

#: ../../glossary.rst:595
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:600
msgid "function"
msgstr "Funktion"

#: ../../glossary.rst:602
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:606
msgid "function annotation"
msgstr "Funktionsanmerkung"

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

#: ../../glossary.rst:610
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:615
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:618
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:620
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:624
msgid "__future__"
msgstr "__Zukunft__"

#: ../../glossary.rst:626
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:634
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:637
msgid "garbage collection"
msgstr "Garbage Collection"

#: ../../glossary.rst:639
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:644 ../../glossary.rst:645
msgid "generator"
msgstr "Generator"

#: ../../glossary.rst:647
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:652 ../../glossary.rst:653
msgid "generator function"
msgstr "Generatorfunktion"

#: ../../glossary.rst:655
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:660
msgid "generator iterator"
msgstr "Generator-Iterator"

#: ../../glossary.rst:662
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:665
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:670
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:675 ../../glossary.rst:676
msgid "generator expression"
msgstr "Generatorausdruck"

#: ../../glossary.rst:678
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:683
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:685
msgid "generic function"
msgstr "generische Funktion"

#: ../../glossary.rst:687
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:691
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:693
msgid "generic type"
msgstr "generischer Typ"

#: ../../glossary.rst:695
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:700
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:702
msgid "GIL"
msgstr "GIL"

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

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

#: ../../glossary.rst:707
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:716
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 ""
"Einige Erweiterungsmodule – sei es Standardmodule oder Module von "
"Drittanbietern – sind jedoch so konzipiert, dass sie das GIL bei "
"rechenintensiven Aufgaben wie Komprimierung oder Hashing freigeben. Außerdem "
"wird das GIL bei E/A-Vorgängen stets freigegeben."

#: ../../glossary.rst:721
msgid ""
"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil` "
"build configuration. After building Python with this option, code must be "
"run with :option:`-X gil=0 <-X>` or after setting the :envvar:`PYTHON_GIL=0 "
"<PYTHON_GIL>` environment variable. 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. Nach dem Kompilieren von Python mit dieser "
"Option muss der Code mit der Option :option:`-X gil=0 <-X>`  ausgeführt "
"werden oder nachdem die Umgebungsvariable :envvar:`PYTHON_GIL=0 "
"<PYTHON_GIL>`  gesetzt wurde. 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:728
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:731
msgid "global state"
msgstr "globaler Zustand"

#: ../../glossary.rst:733
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:739
msgid "hash-based pyc"
msgstr "Hash-basierte PYC-Datei"

#: ../../glossary.rst:741
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 Hash-"
"Wert anstelle des Zeitstempels der letzten Änderung der entsprechenden "
"Quelldatei heranzieht. Siehe :ref:`pyc-invalidation`."

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

#: ../../glossary.rst:746
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 Hash-Wert haben."

#: ../../glossary.rst:752
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 Wörterbuch und "
"als Element in einer Menge verwendet werden, da diese Datenstrukturen intern "
"den Hashwert nutzen."

#: ../../glossary.rst:755
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 Wörterbücher) 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 Hash-Wert wird aus ihrem  :func:`id`  abgeleitet."

#: ../../glossary.rst:762
msgid "IDLE"
msgstr "LEERLAUF"

#: ../../glossary.rst:764
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:767
msgid "immortal"
msgstr "unsterblich"

#: ../../glossary.rst:769
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:772
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:776
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:778
msgid "immutable"
msgstr "unveränderlich"

#: ../../glossary.rst:780
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 Hash-Wert benötigt wird, beispielsweise als Schlüssel in einem "
"Wörterbuch.  Unveränderliche Objekte sind von Natur aus :term:`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:787
msgid "import path"
msgstr "Importpfad"

#: ../../glossary.rst:789
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:794
msgid "importing"
msgstr "Importieren"

#: ../../glossary.rst:796
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:798
msgid "importer"
msgstr "Importeur"

#: ../../glossary.rst:800
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:802
msgid "index"
msgstr "Inhaltsverzeichnis"

#: ../../glossary.rst:804
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:807
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:811
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:814
msgid "See also :term:`subscript`."
msgstr "Siehe auch :term:`Index <subscript>`."

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

#: ../../glossary.rst:817
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 verfügt über einen interaktiven Interpreter, d. h., du kannst "
"Anweisungen und Ausdrücke an der Interpreter-Eingabeaufforderung eingeben, "
"diese sofort ausführen und die Ergebnisse anzeigen lassen. Starte einfach  "
"``python``  ohne Argumente (z. B. über das Hauptmenü deines Computers). Dies "
"ist eine sehr leistungsstarke Methode, um neue Ideen auszuprobieren oder "
"Module und Pakete zu untersuchen (siehe auch ``help(x)``). Weitere "
"Informationen zum interaktiven Modus findest du unter :ref:`tut-interac`."

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

#: ../../glossary.rst:826
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:833
msgid "interpreter shutdown"
msgstr "Beenden des Interpreters"

#: ../../glossary.rst:835
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:844
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:846
msgid "iterable"
msgstr "iterierbar"

#: ../../glossary.rst:848
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:856
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:866
msgid "iterator"
msgstr "Iterator"

#: ../../glossary.rst:868
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 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 "
"Iterator-Objekt erschöpft, und weitere Aufrufe seiner Methode  :meth:`!"
"__next__`  lösen lediglich erneut eine  :exc:`StopIteration`-Ausnahme aus.  "
"Iteratoren müssen über eine Methode  :meth:`~iterator.__iter__`  verfügen, "
"die das Iterator-Objekt 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 "
"(wie beispielsweise ein :class:`list`) erzeugt jedes Mal einen neuen "
"Iterator, wenn man es an die Funktion  :func:`iter`  übergibt oder in "
"einer  :keyword:`for`-Schleife verwendet.  Versucht man 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:883
msgid "More information can be found in :ref:`typeiter`."
msgstr "Weitere Informationen finden Sie unter :ref:`typeiter`."

#: ../../glossary.rst:887
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-safe` Verhalten "
"von Iterator-Operationen garantiert."

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

#: ../../glossary.rst:894
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:896
msgid "key function"
msgstr "Schlüsselfunktion"

#: ../../glossary.rst:898
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:903
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:909
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 finden "
"Sie im :ref:`Sorting HOW TO <sortinghowto>`."

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

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

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

#: ../../glossary.rst:921
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:924
msgid "LBYL"
msgstr "LBYL"

#: ../../glossary.rst:926
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 ""
"Erst schauen, dann springen. Bei diesem Programmierstil werden "
"Vorbedingungen explizit geprüft, bevor Funktionen aufgerufen oder Abfragen "
"durchgeführt werden. Dieser Stil steht im Gegensatz zum :term:`EAFP`-Ansatz "
"und zeichnet sich durch das häufige Vorkommen von :keyword:`if` -Anweisungen "
"aus."

#: ../../glossary.rst:931
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:`Locks <lock>` oder durch Verwendung des :term:`EAFP`-"
"Ansatzes lösen. Siehe auch :term:`thread-safe`."

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

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

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

#: ../../glossary.rst:943
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)."
msgstr ""
"Eine in Python integrierte :term:`Sequenz <sequence>`. Trotz ihres Namens "
"ähnelt sie eher einem Array in anderen Sprachen als einer verketteten Liste, "
"da der Zugriff auf die Elemente *O*\\ (1) ist."

#: ../../glossary.rst:946
msgid "list comprehension"
msgstr "Listenkomprimierung"

#: ../../glossary.rst:948
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:954
msgid "lock"
msgstr "Schloss"

#: ../../glossary.rst:956
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-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`."

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

#: ../../glossary.rst:969
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:977
msgid "loader"
msgstr "Lader"

#: ../../glossary.rst:979
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:985
msgid ":ref:`finders-and-loaders`"
msgstr ":ref:`finders-and-loaders`"

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

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

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

#: ../../glossary.rst:990
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:993
msgid "On Windows, it is the ANSI code page (ex: ``\"cp1252\"``)."
msgstr "Unter Windows ist dies die ANSI-Codepage (z. B.: ``\"cp1252\"``)."

#: ../../glossary.rst:995
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:997
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:999
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:1000
msgid "magic method"
msgstr "magische Methode"

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

#: ../../glossary.rst:1005
msgid "mapping"
msgstr "Kartierung"

#: ../../glossary.rst:1007
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:1013
msgid "meta path finder"
msgstr "Meta-Pfadfinder"

#: ../../glossary.rst:1015
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:1019
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:1021
msgid "metaclass"
msgstr "Metaklasse"

#: ../../glossary.rst:1023
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 "
"Klassenwörterbuch 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:1033
msgid "More information can be found in :ref:`metaclasses`."
msgstr "Weitere Informationen finden Sie unter :ref:`metaclasses`."

#: ../../glossary.rst:1002 ../../glossary.rst:1034 ../../glossary.rst:1488
msgid "method"
msgstr "Methode"

#: ../../glossary.rst:1036
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:1040
msgid "method resolution order"
msgstr "Reihenfolge der Methodenauflösung"

#: ../../glossary.rst:1042
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:1045
msgid "module"
msgstr "Modul"

#: ../../glossary.rst:1047
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:1051
msgid "See also :term:`package`."
msgstr "Siehe auch :term:`Paket <package>`."

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

#: ../../glossary.rst:1054
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:1057
msgid "See also :ref:`module-specs`."
msgstr "Siehe auch :ref:`module-specs`."

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

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

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

#: ../../glossary.rst:1063
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:1068
msgid "named tuple"
msgstr "benanntes Tupel"

#: ../../glossary.rst:1070
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:1074
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:1078
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:1085
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:1093
msgid "namespace"
msgstr "Namensraum"

#: ../../glossary.rst:1095
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 "
"Wörterbücher 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 man "
"beispielsweise :func:`random.seed` oder :func:`itertools.islice` schreibt, "
"wird deutlich, dass diese Funktionen jeweils von den Modulen :mod:`random` "
"und :mod:`itertools` implementiert werden."

#: ../../glossary.rst:1105
msgid "namespace package"
msgstr "Namensraum-Paket"

#: ../../glossary.rst:1107
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:1112
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:1115
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:1117
msgid "See also :term:`module`."
msgstr "Siehe auch :term:`Modul <module>`."

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

#: ../../glossary.rst:1120
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:1125
msgid "nested scope"
msgstr "verschachtelter Gültigkeitsbereich"

#: ../../glossary.rst:1127
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 Gültigkeitsbereiche standardmäßig nur für "
"Verweise und nicht für Zuweisungen gelten. Lokale Variablen lesen und "
"schreiben im innersten Gültigkeitsbereich.  Ebenso lesen und schreiben "
"globale Variablen im globalen Namensraum.  Die Anweisung  :keyword:"
"`nonlocal`  ermöglicht das Schreiben in äußere Gültigkeitsbereiche."

#: ../../glossary.rst:1134
msgid "new-style class"
msgstr "Klasse im neuen Stil"

#: ../../glossary.rst:1136
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:1141
msgid "non-deterministic"
msgstr "nicht deterministisch"

#: ../../glossary.rst:1143
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 bei gleichen Eingaben von "
"Ausführung zu Ausführung variieren kann. In Multithread-Programmen "
"resultiert nichtdeterministisches Verhalten häufig aus :term:`Race-"
"Conditions <race condition>`, bei denen der relative zeitliche Ablauf oder "
"die Verflechtung von Threads das Ergebnis beeinflusst. Eine ordnungsgemäße "
"Synchronisation mithilfe von :term:`Locks <lock>` und anderen :term:"
"`Synchronisationsprimitiven <synchronization primitive>` trägt dazu bei, ein "
"deterministisches Verhalten sicherzustellen."

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

#: ../../glossary.rst:1152
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:1155
msgid "optimized scope"
msgstr "optimierter Umfang"

#: ../../glossary.rst:1157
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, Koroutinen, Comprehensions und "
"Generatorausdrücke werden auf diese Weise optimiert. Hinweis: Die meisten "
"Interpreter-Optimierungen werden auf alle Gültigkeitsbereiche angewendet; "
"nur diejenigen, die auf einer bekannten Menge lokaler und nichtlokaler "
"Variablennamen beruhen, sind auf optimierte Gültigkeitsbereiche beschränkt."

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

#: ../../glossary.rst:1166
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:1171
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:1173
msgid "package"
msgstr "Paket"

#: ../../glossary.rst:1175
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:1179
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:1180
msgid "parallelism"
msgstr "Parallelität"

#: ../../glossary.rst:1182
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:1190
msgid "parameter"
msgstr "Parameter"

#: ../../glossary.rst:1192
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:1196
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`: Gibt ein Argument an, das entweder :term:"
"`positionsbezogen <argument>` oder als :term:`Schlüsselwortargument "
"<argument>` übergeben werden kann. Dies ist die Standardart von Parametern, "
"zum Beispiel *foo* und *bar* im Folgenden::"

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

#: ../../glossary.rst:1205
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:1210
msgid "def func(posonly1, posonly2, /, positional_or_keyword): ..."
msgstr "def func(posonly1, posonly2, /, positional_or_keyword): ..."

#: ../../glossary.rst:1214
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`: Gibt ein Argument an, das nur als Schlüsselwort "
"übergeben werden kann. Schlüsselwort-Parameter können definiert werden, "
"indem ein einzelner variabler Positionsparameter oder ein reines Schlüssel "
"``*`` us in die Parameterliste der vorangehenden Funktionsdefinition "
"aufgenommen wird, zum Beispiel *kw_only1* und *kw_only2* im folgenden "
"Beispiel::"

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

#: ../../glossary.rst:1222
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:1228
msgid "def func(*args, **kwargs): ..."
msgstr "def func(*args, **kwargs): ..."

#: ../../glossary.rst:1230
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:1236
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:1239
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:1243
msgid "per-object lock"
msgstr "Objektspezifische Sperre"

#: ../../glossary.rst:1245
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:1253
msgid "path entry"
msgstr "Pfadeintrag"

#: ../../glossary.rst:1255
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:1257
msgid "path entry finder"
msgstr "Pfadeintrags-Finder"

#: ../../glossary.rst:1259
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:1263
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:1265
msgid "path entry hook"
msgstr "Pfadeintrag-Hook"

#: ../../glossary.rst:1267
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:1270
msgid "path based finder"
msgstr "Pfadbasierter Sucher"

#: ../../glossary.rst:1272
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:1274
msgid "path-like object"
msgstr "pfadähnliches Objekt"

#: ../../glossary.rst:1276
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:1284
msgid "PEP"
msgstr "PEP"

#: ../../glossary.rst:1286
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:1292
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:1298
msgid "See :pep:`1`."
msgstr "Siehe :pep:`1`."

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

#: ../../glossary.rst:1301
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:1303
msgid "positional argument"
msgstr "Positionsargument"

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

#: ../../glossary.rst:1308
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:1317
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 ""
"Selbst bei vorläufigen APIs gelten rückwärtsinkompatible Änderungen als "
"\"letzter Ausweg\" – es wird weiterhin alles versucht, um für alle "
"festgestellten Probleme eine rückwärtskompatible Lösung zu finden."

#: ../../glossary.rst:1321
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:1324
msgid "provisional package"
msgstr "vorläufiges Paket"

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

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

#: ../../glossary.rst:1329
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:1332
msgid "Pythonic"
msgstr "Pythonesk"

#: ../../glossary.rst:1334
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:1341
msgid ""
"for i in range(len(food)):\n"
"    print(food[i])"
msgstr ""
"for i in range(len(food)):\n"
"    print(food[i])"

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

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

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

#: ../../glossary.rst:1350
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 Gültigkeitsbereich 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:1355
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:1367
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:1371
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:1374
msgid "race condition"
msgstr "Race-Condition"

#: ../../glossary.rst:1376
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:1386
msgid "reference count"
msgstr "Referenzanzahl"

#: ../../glossary.rst:1388
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:1397
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:1401
msgid "regular package"
msgstr "Standardpaket"

#: ../../glossary.rst:1403
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:1406
msgid "See also :term:`namespace package`."
msgstr "Siehe auch: :term:`Namensraum-Paket <namespace package>`."

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

#: ../../glossary.rst:1409
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:1413
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:1419
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 ""
"Was Sperren betrifft, ist die Python-Sperre  :class:`threading.RLock`  "
"(Reentrant-Sperre) reentrant, was bedeutet, dass ein Thread, der die Sperre "
"bereits hält, sie erneut erwerben kann, ohne zu blockieren. Im Gegensatz "
"dazu ist  :class:`threading.Lock`  nicht reentrant – der Versuch, sie "
"zweimal vom selben Thread aus zu erwerben, führt zu einem Deadlock."

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

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

#: ../../glossary.rst:1428
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:1430
msgid "__slots__"
msgstr "__slots__"

#: ../../glossary.rst:1432
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:1437
msgid "sequence"
msgstr "Sequenz"

#: ../../glossary.rst:1439
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:1448
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:1458
msgid "set comprehension"
msgstr "Mengenkomprimierung"

#: ../../glossary.rst:1460
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 "
"iterierbaren Struktur 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:1464
msgid "single dispatch"
msgstr "Einzelversand"

#: ../../glossary.rst:1466
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:1468
msgid "slice"
msgstr "Scheibe"

#: ../../glossary.rst:1470
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 :"
"ref:`Slicing- <slicings>` -Form der :ref:`Indexnotation <subscriptions>` "
"verwendet wird, bei der Doppelpunkte in eckigen Klammern stehen, wie "
"beispielsweise in ``variable_name[1:3:5]``."

#: ../../glossary.rst:1475
msgid "soft deprecated"
msgstr "weich veraltet"

#: ../../glossary.rst:1477
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:1481
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:1484
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:1486
msgid "special method"
msgstr "spezielle Methode"

#: ../../glossary.rst:1490
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:1494
msgid "standard library"
msgstr "Standardbibliothek"

#: ../../glossary.rst:1496
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:1502
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:1504
msgid "statement"
msgstr "Erklärung"

#: ../../glossary.rst:1506
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:1509
msgid "static type checker"
msgstr "statischer Typprüfer"

#: ../../glossary.rst:1511
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:1514
msgid "stdlib"
msgstr "stdlib"

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

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

#: ../../glossary.rst:1519
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:1524
msgid "See :ref:`api-refcountdetails` for a full explanation."
msgstr ""
"Eine ausführliche Erläuterung findest du unter :ref:`api-refcountdetails`."

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

#: ../../glossary.rst:1527
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:1533
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:1538
msgid "See also :term:`borrowed reference`."
msgstr "Siehe auch: :term:`entlehnte Referenz <borrowed reference>`."

#: ../../glossary.rst:1539
msgid "subscript"
msgstr "Index"

#: ../../glossary.rst:1541
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:`Abonnementausdrucks "
"<subscriptions>`, zum Beispiel der ``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 ein :term:`Mapping <mapping>` indiziert "
"wird, oder als :term:`Index <index>`, wenn eine :term:`Sequenz <sequence>` "
"indiziert wird."

#: ../../glossary.rst:1547
msgid "synchronization primitive"
msgstr "Synchronisationsprimitive"

#: ../../glossary.rst:1549
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-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:`lock`."

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

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

#: ../../glossary.rst:1562
msgid ""
"String literals prefixed with ``t`` or ``T`` are commonly called \"t-"
"strings\" which is short for :ref:`template string literals <t-strings>`."
msgstr ""
"Zeichenfolgenliterale, 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:1565
msgid "text encoding"
msgstr "Textkodierung"

#: ../../glossary.rst:1567
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:1571
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:1574
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:1577
msgid "text file"
msgstr "Textdatei"

#: ../../glossary.rst:1579
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 "
"byteurientierten 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:1586
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:1588
msgid "thread state"
msgstr "Thread-Status"

#: ../../glossary.rst:1591
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:1595
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 einen einzelnen Betriebssystem-Thread gebunden, "
"aber Threads können über mehrere Thread-Zustände verfügen.  Höchstens einer "
"davon darf gleichzeitig :term:`attached <attached thread state>` sein."

#: ../../glossary.rst:1599
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:1603
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:1609
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:1611
msgid "thread-safe"
msgstr "thread-safe"

#: ../../glossary.rst:1613
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:1624
msgid "token"
msgstr "Token"

#: ../../glossary.rst:1627
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:1632
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:1635
msgid "triple-quoted string"
msgstr "Zeichenkette in dreifachen Anführungszeichen"

#: ../../glossary.rst:1637
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:1644
msgid "type"
msgstr "Typ"

#: ../../glossary.rst:1646
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:1650
msgid "type alias"
msgstr "Typalias"

#: ../../glossary.rst:1652
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:1654
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:1657
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:1661
msgid "could be made more readable like this::"
msgstr "könnte so lesbarer gestaltet werden::"

#: ../../glossary.rst:1663
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:1668 ../../glossary.rst:1682
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:1669
msgid "type hint"
msgstr "Typhinweis"

#: ../../glossary.rst:1671
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:1674
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:1678
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:1683
msgid "universal newlines"
msgstr "universelle Zeilenumbrüche"

#: ../../glossary.rst:1685
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:1690
msgid "variable annotation"
msgstr "Variablenbeschriftung"

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

#: ../../glossary.rst:1694
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:1696
msgid ""
"class C:\n"
"    field: 'annotation'"
msgstr ""
"Klasse C:\n"
"    Feld: 'annotation'"

#: ../../glossary.rst:1699
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:1703
msgid "count: int = 0"
msgstr "Zähler: int = 0"

#: ../../glossary.rst:1705
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:1707
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:1711
msgid "virtual environment"
msgstr "virtuelle Umgebung"

#: ../../glossary.rst:1713
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:1718
msgid "See also :mod:`venv`."
msgstr "Siehe auch :mod:`venv`."

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

#: ../../glossary.rst:1721
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:1723
msgid "walrus operator"
msgstr "Walross-Betreiber"

#: ../../glossary.rst:1725
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:1728
msgid "Zen of Python"
msgstr "Zen von Python"

#: ../../glossary.rst:1730
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:1002
msgid "magic"
msgstr "Magie"

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