Glossar
*******

">>>"
   Die Standard-Python-Eingabeaufforderung der *interaktiven* Shell.
   Wird häufig bei Code-Beispielen verwendet, die interaktiv im
   Interpreter ausgeführt werden können.

"..."
   Kann sich beziehen auf:

   * Die Standard-Python-Eingabeaufforderung der *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.

   * Die drei Punkte bilden das Ellipsis- -Objekt.

Abstrakte Basisklasse
   Abstrakte Basisklassen (abstract base class / ABC) ergänzen *Duck-
   Typing*, indem sie eine Möglichkeit bieten, Schnittstellen zu
   definieren, wenn andere Techniken wie "hasattr()" umständlich oder
   in subtiler Weise falsch wären (zum Beispiel bei magischen
   Methoden).  ABCs führen virtuelle Unterklassen ein – das sind
   Klassen, die nicht von einer Klasse erben, aber dennoch von
   "isinstance()" und "issubclass()" erkannt werden; siehe die
   Dokumentation zum Modul "abc".  Python enthält viele integrierte
   ABCs für Datenstrukturen (im Modul  "collections.abc" ), Zahlen (im
   Modul "numbers" ), Streams (im Modul  "io" ) sowie Import-Finder
   und Loader (im Modul  "importlib.abc" ). Mit dem Modul "abc" können
   Sie eigene ABCs erstellen.

Anmerkung
   Eine Bezeichnung, die einer Variablen, einem Klassenattribut oder
   einem Funktionsparameter bzw. Rückgabewert zugeordnet ist und
   üblicherweise als *Typhinweis* verwendet wird.

   Annotations of local variables cannot be accessed at runtime, but
   annotations of global variables, class attributes, and functions
   are stored in the "__annotations__" special attribute of modules,
   classes, and functions, respectively.

   See *variable annotation*, *function annotation*, **PEP 484** and
   **PEP 526**, which describe this functionality. Also see
   Annotations Best Practices for best practices on working with
   annotations.

Argument
   Ein Wert, der beim Aufruf einer *Funktion* (oder *Methode*) an
   diese übergeben wird. Es gibt zwei Arten von Argumenten:

   * *Schlüsselwortargument*: 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  "complex()"

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *Positionsargument*: Ein Argument, das kein Schlüsselwortargument
     ist. Positionsargumente können am Anfang einer Argumentliste
     stehen und/oder als Elemente eines *iterable* übergeben werden,
     dem "*" vorangestellt ist. Beispielsweise sind sowohl  "3"  als
     auch  "5"  Positionsargumente in den folgenden Aufrufen:

        complex(3, 5)
        complex(*(3, 5))

   Argumente werden im Funktionskörper den benannten lokalen Variablen
   zugewiesen. Die Regeln für diese Zuweisung finden Sie im Abschnitt
   Calls . Syntaktisch kann jeder Ausdruck zur Darstellung eines
   Arguments verwendet werden; der ausgewertete Wert wird der lokalen
   Variablen zugewiesen.

   Siehe auch den Glossareintrag zu *parameter*, die FAQ-Frage zum
   Unterschied zwischen Argumenten und Parametern und **PEP 362**.

asynchroner Kontextmanager
   Ein Objekt, das die in einer "async with"-Anweisung angezeigte
   Umgebung steuert, indem es die Methoden  "__aenter__()"  und
   "__aexit__()"  definiert. Eingeführt durch **PEP 492**.

asynchroner Generator
   Wird umgangssprachlich je nach Kontext entweder für eine
   *asynchrone Generatorfunktion* oder einen *asynchronen Generator-
   Iterator* verwendet.  Die formalen Begriffe *asynchrone
   Generatorfunktion* und *asynchroner Generator-Iterator* sind in der
   Praxis selten; "asynchroner Generator" allein reicht fast immer
   aus.

asynchrone Generatorfunktion
   Eine Funktion, die einen *asynchronen Generator-Iterator*
   zurückgibt. Sie ähnelt einer mit "async def" definierten Coroutine-
   Funktion, enthält jedoch Ausdrücke vom Typ "yield", um eine Reihe
   von Werten zu erzeugen, die in einer "async for"-Schleife verwendet
   werden können. Siehe **PEP 525**.

   Eine asynchrone Generatorfunktion kann sowohl  "await" -Ausdrücke
   als auch "async for"- und "async with"-Anweisungen enthalten.

asynchrone Generator-Iterator
   Ein Objekt, das von einer *asynchronen Generatorfunktion* erstellt
   wurde.

   Dies ist ein *asynchroner Iterator*, der beim Aufruf mit der
   Methode  "__anext__()" ein awaitable-Objekt zurückgibt, das den
   Körper der asynchronen Generatorfunktion bis zum nächsten  "yield"
   -Ausdruck ausführt.

   Jeder  "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  "__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**.

asynchrones Iterabel
   Ein Objekt, das in einer "async for"-Anweisung verwendet werden
   kann. Es muss über seine Methode "__aiter__()" einen *asynchronen
   Iterator* zurückgeben.  Eingeführt durch **PEP 492**.

asynchroner Iterator
   Ein Objekt, das die Methoden  "__aiter__()"  und  "__anext__()"
   implementiert.  "__anext__()"  muss ein *awaitable*-Objekt
   zurückgeben. "async for" verarbeitet die von der Methode
   "__anext__()"  eines asynchronen Iterators zurückgegebenen
   *awaitables*, bis eine Ausnahme vom Typ  "StopAsyncIteration"
   ausgelöst wird. Eingeführt durch **PEP 492**.

atomare Operation
   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 *Race Condition* und *Data Race*.

Attribut
   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.

   Es ist möglich, einem Objekt ein Attribut zuzuweisen, dessen Name
   kein Bezeichner im Sinne von Identifiers and keywords ist,
   beispielsweise mithilfe von "setattr()", sofern das Objekt dies
   zulässt. Auf ein solches Attribut kann nicht über einen
   Punktausdruck zugegriffen werden; stattdessen muss es mit
   "getattr()" abgerufen werden.

abwartbar
   Ein Objekt, das in einem Ausdruck vom Typ  "await"  verwendet
   werden kann. Kann eine *coroutine* oder ein Objekt mit einer
   Methode vom Typ  "__await__()"  sein. Siehe auch **PEP 492**.

BDFL
   Wohltätiger Diktator auf Lebenszeit, auch bekannt als Guido van
   Rossum, der Schöpfer von Python.

Binärdatei
   Ein *Dateiobjekt*, das *byteähnliche Objekte* lesen und schreiben
   kann. Beispiele für Binärdateien sind Dateien, die im Binärmodus
   geöffnet wurden ("'rb'", "'wb'" oder "'rb+'"), "sys.stdin.buffer",
   "sys.stdout.buffer" sowie Instanzen von "io.BytesIO" und
   "gzip.GzipFile".

   Siehe auch *Textdatei* für ein Dateiobjekt, das Objekte vom Typ
   "str"  lesen und schreiben kann.

entlehnte Referenz
   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 *starke Referenz* auf das Objekt
   entfernen und es so zerstören.

   Es wird empfohlen, die Funktion  "Py_INCREF()"  auf die *geliehene
   Referenz* anzuwenden, um diese an Ort und Stelle in eine *starke
   Referenz* umzuwandeln – es sei denn, das Objekt kann nicht vor der
   letzten Verwendung der geliehenen Referenz zerstört werden. Mit der
   Funktion  "Py_NewRef()"  kann eine neue *starke Referenz* erstellt
   werden.

Byte-ähnliches Objekt
   Ein Objekt, das die Schnittstelle  Buffer-Protokoll  unterstützt
   und einen C-*contiguous*-Puffer exportieren kann. Dazu gehören alle
   Objekte vom Typ  "bytes" ,  "bytearray"  und  "array.array"  sowie
   viele gängige Objekte vom Typ  "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.

   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  "bytearray"  und ein  "memoryview"  eines
   "bytearray" -Objekts. Andere Operationen erfordern, dass die
   Binärdaten in unveränderbaren Objekten (read-only bytes-like
   objects) gespeichert werden; Beispiele hierfür sind  "bytes"  und
   ein  "memoryview"  eines  "bytes" -Objekts.

Bytecode
   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 *virtuellen
   Maschine*, die den jedem Bytecode entsprechenden Maschinencode
   ausführt. Beachten Sie jedoch, dass Bytecodes nicht unbedingt
   zwischen verschiedenen virtuellen Python-Maschinen funktionieren
   und auch nicht über Python-Versionen hinweg stabil sind.

   Eine Liste der Bytecode-Befehle finden Sie in der Dokumentation zum
   dis-Modul.

abrufbar
   Ein Callable ist ein Objekt, das aufgerufen werden kann,
   gegebenenfalls mit einer Reihe von Argumenten (siehe *argument*),
   und zwar mit folgender Syntax:

      callable(argument1, argument2, argumentN)

   Eine *Funktion* und im weiteren Sinne auch eine *Methode* ist ein
   aufrufbares Objekt. Eine Instanz einer Klasse, die die Methode
   "__call__()"  implementiert, ist ebenfalls ein aufrufbares Objekt.

Callback
   Eine Unterprogrammfunktion, die als Argument übergeben wird, um zu
   einem späteren Zeitpunkt ausgeführt zu werden.

Klasse
   Eine Vorlage zum Erstellen benutzerdefinierter Objekte.
   Klassendefinitionen enthalten in der Regel Methodendefinitionen,
   die auf Instanzen der Klasse angewendet werden.

Klassenvariable
   Eine Variable, die in einer Klasse definiert ist und nur auf
   Klassenebene (d. h. nicht in einer Instanz der Klasse) geändert
   werden soll.

Closure-Variable
   Eine *freie Variable*, auf die aus einem *verschachtelten
   Gültigkeitsbereich* 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 "nonlocal" definiert werden, um
   Schreibzugriff zu ermöglichen, oder implizit, wenn die Variable nur
   gelesen wird.

   Beispielsweise sind in der Funktion  "inner"  im folgenden Code
   sowohl "x" als auch "print"*freie Variablen*, aber nur "x" ist eine
   *Closure-Variable*:

      def outer():
          x = 0
          def inner():
              nonlocal x
              x += 1
              print(x)
          return inner

   Aufgrund des Attributs  "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 *freie Variable* manchmal verwendet, selbst
   wenn eigentlich speziell auf Closure-Variablen Bezug genommen
   werden soll.

komplexe Zahl
   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  "math"
   zuzugreifen, verwenden Sie  "cmath" .  Die Verwendung komplexer
   Zahlen ist eine recht fortgeschrittene mathematische Funktion.
   Wenn Sie keinen Bedarf dafür sehen, können Sie diese Funktionen mit
   ziemlicher Sicherheit getrost ignorieren.

Gleichzeitigkeit
   Die Fähigkeit eines Computerprogramms, mehrere Aufgaben
   gleichzeitig auszuführen. Python bietet Bibliotheken zum Schreiben
   von Programmen, die verschiedene Formen der Gleichzeitigkeit
   nutzen.  "asyncio"  ist eine Bibliothek für den Umgang mit
   asynchronen Aufgaben und Coroutinen.  "threading"  bietet Zugriff
   auf Betriebssystem-Threads und  "multiprocessing"  auf
   Betriebssystem-Prozesse. Multi-Core-Prozessoren können Threads und
   Prozesse gleichzeitig auf verschiedenen CPU-Kernen ausführen (siehe
   *Parallelität*).

gleichzeitige Änderung
   Wenn mehrere Threads gleichzeitig gemeinsam genutzte Daten ändern.
   Eine gleichzeitige Änderung ohne ordnungsgemäße Synchronisation
   kann zu *Race Conditions* führen und möglicherweise auch einen
   *Datenkonflikt*, Datenbeschädigungen oder beides auslösen.

Kontext
   Dieser Begriff hat je nach Kontext und Verwendung unterschiedliche
   Bedeutungen. Einige gängige Bedeutungen:

   * Der temporäre Zustand oder die Umgebung, die von einem *Context
     Manager* über eine  "with" -Anweisung eingerichtet wird.

   * Die Sammlung von Schlüssel-Wert-Zuordnungen, die einem bestimmten
     "contextvars.Context"-Objekt zugeordnet sind und über
     "ContextVar"-Objekte abgerufen werden. Siehe auch
     *Kontextvariable*.

   * Ein  "contextvars.Context" -Objekt. Siehe auch *aktueller
     Kontext*.

Kontextverwaltungsprotokoll
   Die Methoden  "__enter__()"  und  "__exit__()" , die von der
   Anweisung  "with"  aufgerufen werden. Siehe **PEP 343**.

Kontextmanager
   Ein Objekt, das das *Kontextverwaltungsprotokoll* implementiert und
   die Umgebung steuert, die in einer "with" -Anweisung sichtbar ist.
   Siehe **PEP 343**.

Kontextvariable
   Eine Variable, deren Wert davon abhängt, welcher Kontext gerade
   aktiv ist, wird als *aktueller Kontext* bezeichnet. Der Zugriff auf
   die Werte erfolgt über Objekte vom Typ  "contextvars.ContextVar" .
   Kontextvariablen werden in erster Linie dazu verwendet, den Zustand
   zwischen parallel laufenden asynchronen Aufgaben zu isolieren.

zusammenhängend
   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.

Koroutine
   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 "async def" implementieren. Siehe auch **PEP
   492**.

Coroutinen-Funktion
   Eine Funktion, die ein *coroutine*-Objekt zurückgibt. Eine
   Coroutine-Funktion kann mit der Anweisung "async def" definiert
   werden und die Schlüsselwörter "await", "async for" sowie "async
   with" enthalten. Diese wurden mit **PEP 492** eingeführt.

CPython
   Die kanonische Implementierung der Programmiersprache Python, wie
   sie auf python.org bereitgestellt wird. Der Begriff "CPython" wird
   bei Bedarf verwendet, um diese Implementierung von anderen wie
   Jython oder IronPython zu unterscheiden.

aktueller Kontext
   Der *Kontext* ("contextvars.Context"-Objekt), der derzeit von
   "ContextVar"-Objekten verwendet wird, um auf die Werte von
   *Kontextvariablen* zuzugreifen (abzurufen oder festzulegen). Jeder
   Thread verfügt über einen eigenen aktuellen Kontext. Frameworks zur
   Ausführung asynchroner Aufgaben (siehe "asyncio") ordnen jeder
   Aufgabe einen Kontext zu, der zum aktuellen Kontext wird, sobald
   die Aufgabe ihre Ausführung beginnt oder fortsetzt.

Datenkonflikt
   Eine Situation, in der mehrere Threads gleichzeitig auf denselben
   Speicherort zugreifen, wobei mindestens einer der Zugriffe ein
   Schreibzugriff ist und die Threads keine Synchronisation zur
   Steuerung ihres Zugriffs verwenden. Datenkonflikte führen zu
   *nicht-deterministischem* Verhalten und können Datenbeschädigungen
   verursachen. Die korrekte Verwendung von *Locks* und anderen
   *Synchronisationsprimitiven* verhindert Datenrennen.  Beachten Sie,
   dass Datenrennen nur in nativem Code auftreten können, dieser
   *native Code* jedoch möglicherweise in einer Python-API verfügbar
   ist.  Siehe auch *Race Condition* und *thread-safe*.

Pattsituation
   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 *Sperren* stets in einer konsistenten
   Reihenfolge erworben werden. Siehe auch *Sperre* und *reentrant*.

Dekorateur
   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
   "@classmethod" und "@staticmethod".

   Die Dekorator-Syntax ist lediglich Syntactic Sugar; die folgenden
   beiden Funktionsdefinitionen sind semantisch gleichbedeutend:

      def f(arg):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(arg):
          ...

   Das gleiche Konzept gibt es auch für Klassen, wird dort jedoch
   seltener verwendet. Weitere Informationen zu Dekoratoren finden Sie
   in der Dokumentation zu Funktionsdefinitionen und
   Klassendefinitionen.

Deskriptor
   Jedes Objekt, das die Methoden  "__get__()" ,  "__set__()"  oder
   "__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.

   Weitere Informationen zu den Methoden von Deskriptoren finden Sie
   unter Implementierung von Deskriptoren oder im Descriptor How To
   Guide.

Wörterbuch
   Ein assoziatives Array, bei dem beliebige Schlüssel Werten
   zugeordnet werden. Die Schlüssel können beliebige Objekte sein, die
   über die Methoden  "__hash__()"  und  "__eq__()"  verfügen. In Perl
   wird dies als Hash bezeichnet.

Wörterbuchverständnis
   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 Darstellungen für
   Listen, Mengen und Wörterbücher.

Wörterbuchansicht
   Die Objekte, die von den Methoden  "dict.keys()" ,  "dict.values()"
   und  "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, verwenden Sie  "list(dictview)" . Siehe Dictionary-
   View-Objekte.

docstring
   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  "__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.

Duck-Typing
   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  "type()"  oder  "isinstance()" . (Beachten Sie jedoch, dass
   Duck-Typing durch *abstrakte Basisklassen* ergänzt werden kann.)
   Stattdessen werden typischerweise  "hasattr()" -Tests oder
   *EAFP*-Programmierung eingesetzt.

dunder
   Eine umgangssprachliche Abkürzung für "doppelter Unterstrich", die
   verwendet wird, wenn von einer *speziellen Methode* die Rede ist.
   So wird beispielsweise  "__init__"  oft als "dunder init"
   ausgesprochen.

EAFP
   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 "try" -
   und "except" -Anweisungen aus. Diese Technik steht im Gegensatz zum
   *LBYL*-Stil, der in vielen anderen Sprachen wie beispielsweise C
   üblich ist.

Ausdruck
   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 *statement*s, die nicht
   als Ausdrücke verwendet werden können, wie beispielsweise "while".
   Auch Zuweisungen sind Anweisungen und keine Ausdrücke.

Erweiterungsmodul
   Ein in C oder C++ geschriebenes Modul, das die C-API von Python
   nutzt, um mit dem Kern und dem Anwendercode zu interagieren.

f-String
   String literals prefixed with "'f'" or "'F'" are commonly called
   "f-strings" which is short for formatted string literals.  See also
   **PEP 498**.

Dateiobjekt
   Ein Objekt, das eine dateiorientierte API (mit Methoden wie
   "read()"  oder  "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 *dateiähnliche Objekte* oder
   *Streams* bezeichnet.

   Es gibt insgesamt drei Kategorien von Dateiobjekten: rohe
   *Binärdateien*, gepufferte *Binärdateien* und *Textdateien*. Ihre
   Schnittstellen sind im Modul  "io"  definiert. Die übliche
   Vorgehensweise zum Erstellen eines Dateiobjekts ist die Verwendung
   der Funktion  "open()" .

dateiähnliches Objekt
   Ein Synonym für *Dateiobjekt*.

Dateisystem-Kodierung und Fehlerbehandlung
   Von Python verwendete Kodierung und Fehlerbehandlung zum Dekodieren
   von Bytes aus dem Betriebssystem und zum Kodieren von Unicode für
   das Betriebssystem.

   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  "UnicodeError"  auslösen.

   Mit den Funktionen  "sys.getfilesystemencoding()"  und
   "sys.getfilesystemencodeerrors()"  lassen sich die Kodierung des
   Dateisystems und der Fehlerbehandler abrufen.

   Die *Dateisystem-Kodierung und der Fehlerbehandler* werden beim
   Start von Python über die Funktion  "PyConfig_Read()"
   konfiguriert: siehe "filesystem_encoding" und "filesystem_errors",
   die zu "PyConfig" gehören.

   Siehe auch den Begriff *Lokalisierungskodierung*.

Finder
   Ein Objekt, das versucht, den *loader* für ein Modul zu finden, das
   gerade importiert wird.

   Es gibt zwei Arten von Suchfunktionen: *Meta-Pfad-Suchfunktionen*
   zur Verwendung mit "sys.meta_path" sowie *Pfad-Eingabe-
   Suchfunktionen* zur Verwendung mit "sys.path_hooks".

   Weitere Informationen finden Sie unter Finders und Loader und
   "importlib".

Etagenaufteilung
   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.
   Beachten Sie, dass "(-11) // 4" gleich "-3" ist, da es sich dabei
   um "-2.75" handelt, das *nach unten* abgerundet wurde. Siehe **PEP
   238**.

freies Einfädeln
   Ein Threading-Modell, bei dem mehrere Threads Python-Bytecode
   gleichzeitig innerhalb desselben Interpreters ausführen können.
   Dies steht im Gegensatz zum *global interpreter lock*, bei dem
   jeweils nur ein Thread Python-Bytecode ausführen kann. Siehe **PEP
   703**.

freie Variable
   Formal gesehen ist, gemäß der Definition im
   Sprachausführungsmodell, eine freie Variable jede Variable, die in
   einem Namensraum verwendet wird und keine lokale Variable in diesem
   Namensraum ist. Ein Beispiel finden Sie unter *Closure-Variable*.
   In der Praxis wird der Begriff aufgrund des Namens des Attributs
   "codeobject.co_freevars"  manchmal auch als Synonym für *Closure-
   Variable* verwendet.

Funktion
   Eine Anweisungsfolge, die einen Wert an den Aufrufer zurückgibt.
   Ihr können zudem null oder mehr *Argumente* übergeben werden, die
   bei der Ausführung des Hauptteils verwendet werden können. Siehe
   auch *Parameter*, *Methode* sowie den Abschnitt
   Funktionsdefinitionen .

Funktionsanmerkung
   Eine *Annotation* eines Funktionsparameters oder eines
   Rückgabewerts.

   Funktionsannotationen werden in der Regel für *Typangaben*:
   verwendet. Beispielsweise wird erwartet, dass diese Funktion zwei
   "int" Argumente entgegennimmt und zudem einen "int" Rückgabewert
   hat:

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

   Die Syntax für Funktionsannotationen wird im Abschnitt
   Funktionsdefinitionen  erläutert.

   Siehe *Variablen-Annotation* und **PEP 484**, wo diese
   Funktionalität beschrieben wird. Siehe außerdem Annotations Best
   Practices für bewährte Vorgehensweisen beim Umgang mit
   Annotationen.

__Zukunft__
   Eine Future-Anweisung, "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  "__future__"
   dokumentiert die möglichen Werte von *feature*. Durch Importieren
   dieses Moduls und Auswerten seiner Variablen können Sie sehen, wann
   eine neue Funktion erstmals in die Sprache aufgenommen wurde und
   wann sie zur Standardeinstellung wird (oder wurde):

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

Garbage Collection
   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  "gc"  steuern.

Generator
   Wird umgangssprachlich je nach Kontext entweder für eine
   *Generatorfunktion* oder einen *Generator-Iterator* verwendet. Die
   formalen Begriffe *Generatorfunktion* und *Generator-Iterator* sind
   in der Praxis selten; der Begriff "Generator" allein reicht fast
   immer aus.

Generatorfunktion
   Eine Funktion, die ein *generator*-Objekt zurückgibt. Sie sieht wie
   eine normale Funktion aus, enthält jedoch Ausdrücke vom Typ
   "yield" , um eine Reihe von Werten zu erzeugen, die in einer
   "for"-Schleife verwendet oder mit der Funktion "next()" einzeln
   abgerufen werden können. Siehe Yield Ausdrücke.

Generator-Iterator
   Ein Objekt, das durch eine *Generatorfunktion* oder einen
   *Generatorausdruck* erstellt wurde.

   Jeder  "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).

   Generator-Iteratoren implementieren außerdem die Methode  "send()"
   , um einen Wert an den angehaltenen Generator zu übergeben, sowie
   die Methode  "throw()" , um an der Stelle, an der der Generator
   angehalten wurde, eine Ausnahme auszulösen. Siehe Generator-
   Iterator-Methoden.

Generatorausdruck
   Ein *Ausdruck*, der einen *Iterator* zurückgibt. Er sieht aus wie
   ein normaler Ausdruck, gefolgt von einer "for" -Klausel, die eine
   Schleifenvariable und einen Bereich definiert, sowie einer
   optionalen "if" -Klausel. Der kombinierte Ausdruck generiert Werte
   für eine umschließende Funktion:

      >>> sum(i*i for i in range(10))         # Summe der Quadrate von 0, 1, 4, ..., 81
      285

generische Funktion
   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.

   Siehe auch den Glossareintrag *single dispatch*, den Dekorator
   "@functools.singledispatch" sowie **PEP 443**.

generischer Typ
   Ein *Typ*, der parametrisiert werden kann; typischerweise eine
   Containerklasse wie beispielsweise "list" oder "dict". Wird für
   *Typ-Hinweise* und *Annotationen* verwendet.

   Weitere Informationen finden Sie unter generische Alias-Typen,
   **PEP 483**, **PEP 484**, **PEP 585** sowie im Modul "typing" .

GIL
   Siehe *Global Interpreter Lock*.

Global Interpreter Lock
   Der Mechanismus, den der *CPython*-Interpreter verwendet, um
   sicherzustellen, dass jeweils nur ein Thread Python-*Bytecode*
   ausführt. Dies vereinfacht die CPython-Implementierung, indem das
   Objektmodell (einschließlich kritischer integrierter Typen wie
   "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.

   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.

   Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration  "--
   disable-gil"  deaktiviert werden. Nach dem Kompilieren von Python
   mit dieser Option muss der Code mit der Option "-X gil=0"
   ausgeführt werden oder nachdem die Umgebungsvariable "PYTHON_GIL=0"
   gesetzt wurde. Diese Funktion ermöglicht eine verbesserte Leistung
   für Multithread-Anwendungen und erleichtert die effiziente Nutzung
   von Multi-Core-CPUs. Weitere Details finden Sie unter **PEP 703**.

globaler Zustand
   Daten, auf die im gesamten Programm zugegriffen werden kann, wie
   beispielsweise Variablen auf Modulebene, Klassenvariablen oder
   statische C-Variablen in *Erweiterungsmodulen*. In Multithread-
   Programmen erfordert der zwischen Threads gemeinsam genutzte
   globale Zustand in der Regel eine Synchronisation, um
   *Wettlaufbedingungen* und *Datenwettläufe* zu vermeiden.

Hash-basierte PYC-Datei
   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 Ungültigmachung von
   zwischengespeichertem Bytecode.

hashbar
   Ein Objekt ist *hashbar*, wenn es einen Hash-Wert besitzt, der sich
   während seiner Lebensdauer nicht ändert (es benötigt eine
   "__hash__()"-Methode), und wenn es mit anderen Objekten verglichen
   werden kann (es benötigt eine "__eq__()"-Methode). Hashbare
   Objekte, die als gleich verglichen werden, müssen denselben Hash-
   Wert haben.

   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.

   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  "id()"  abgeleitet.

LEERLAUF
   Eine integrierte Entwicklungs- und Lernumgebung für Python.  IDLE
   --- Python editor and shell  ist eine einfache Editor- und
   Interpreter-Umgebung, die im Lieferumfang der Standarddistribution
   von Python enthalten ist.

unsterblich
   *Unsterbliche Objekte* sind ein Implementierungsdetail von CPython,
   das in **PEP 683** eingeführt wurde.

   Ist ein Objekt unsterblich, wird seine *Referenzanzahl* niemals
   geändert, sodass es während der Laufzeit des Interpreters niemals
   freigegeben wird. Beispielsweise sind  "True"  und  "None"  in
   CPython unsterblich.

unveränderlich
   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 *thread-safe*, da ihr
   Zustand nach der Erstellung nicht mehr geändert werden kann,
   wodurch Bedenken hinsichtlich unsachgemäß synchronisierter
   *gleichzeitiger Änderungen* entfallen.

Importpfad
   Eine Liste von Speicherorten (oder *Pfadeinträge*), die vom *Pfad-
   basierten Finder* nach zu importierenden Modulen durchsucht werden.
   Beim Import stammt diese Liste der Speicherorte in der Regel aus
   "sys.path", bei Unterpaketen kann sie jedoch auch aus dem Attribut
   "__path__" des übergeordneten Pakets stammen.

Importieren
   Der Vorgang, durch den Python-Code in einem Modul für Python-Code
   in einem anderen Modul verfügbar gemacht wird.

Importeur
   Ein Objekt, das sowohl ein Modul findet als auch lädt; es ist
   sowohl ein *Finder*- als auch ein *Loader*-Objekt.

interaktiv
   Python verfügt über einen interaktiven Interpreter, d. h., Sie
   können Anweisungen und Ausdrücke an der Interpreter-
   Eingabeaufforderung eingeben, diese sofort ausführen und die
   Ergebnisse anzeigen lassen. Starten Sie einfach  "python"  ohne
   Argumente (z. B. über das Hauptmenü Ihres 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 finden Sie unter Interaktiver
   Modus.

interpretiert
   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 *interaktiv*.

Beenden des Interpreters
   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 *Garbage Collector* 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).

   Der Hauptgrund für das Beenden des Interpreters ist, dass das Modul
   "__main__"  oder das ausgeführte Skript die Ausführung
   abgeschlossen hat.

iterierbar
   Ein Objekt, das seine Elemente nacheinander zurückgeben kann.
   Beispiele für iterierbare Objekte sind alle Sequenztypen (wie
   "list", "str" und "tuple") sowie einige Nicht-Sequenztypen wie
   "dict", *Dateiobjekte* und Objekte beliebiger Klassen, die Sie mit
   einer "__iter__()" -Methode oder einer "__getitem__()" -Methode
   definieren, die die *sequence*-Semantik implementiert.

   Iterables können in einer  "for" -Schleife und an vielen anderen
   Stellen verwendet werden, an denen eine Sequenz benötigt wird
   ("zip()", "map()", …). Wenn ein iterierbares Objekt als Argument an
   die integrierte Funktion  "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,  "iter()"
   aufzurufen oder sich selbst um Iterator-Objekte zu kümmern. Die
   Anweisung  "for"  übernimmt dies automatisch für Sie und erstellt
   eine temporäre, unbenannte Variable, die den Iterator für die Dauer
   der Schleife enthält. Siehe auch *iterator*, *sequence* und
   *generator*.

Iterator
   An object representing a stream of data.  Repeated calls to the
   iterator's "__next__()" method (or passing it to the built-in
   function "next()") return successive items in the stream.  When no
   more data are available a "StopIteration" exception is raised
   instead.  At this point, the iterator object is exhausted and any
   further calls to its "__next__()" method just raise "StopIteration"
   again.  Iterators are required to have an "__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 "list") produces a
   fresh new iterator each time you pass it to the "iter()" function
   or use it in a "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.

   Weitere Informationen finden Sie unter Iterator-Typen.

   CPython wendet die Anforderung, dass ein Iterator  "__iter__()"
   definieren muss, nicht konsequent an. Beachten Sie außerdem, dass
   *free-threaded* CPython kein *thread-safe* Verhalten von Iterator-
   Operationen garantiert.

Schlüsselfunktion
   Eine Schlüsselfunktion oder Sortierfunktion ist ein aufrufbares
   Objekt, das einen Wert zurückgibt, der zum Sortieren oder Ordnen
   verwendet wird. Beispielsweise wird  "locale.strxfrm()"  verwendet,
   um einen Sortierschlüssel zu erzeugen, der die lokalspezifischen
   Sortierkonventionen berücksichtigt.

   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  "min()" ,  "max()" ,  "sorted()" ,
   "list.sort()" ,  "heapq.merge()" ,  "heapq.nsmallest()" ,
   "heapq.nlargest()"  und  "itertools.groupby()" .

   Es gibt verschiedene Möglichkeiten, eine Schlüsselfunktion zu
   erstellen. Beispielsweise kann die Methode  "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  "lambda"  erstellt
   werden, wie beispielsweise "lambda r: (r[0], r[2])". Außerdem sind
   "operator.attrgetter()", "operator.itemgetter()" und
   "operator.methodcaller()" drei Konstruktoren für
   Schlüsselfunktionen. Beispiele für die Erstellung und Verwendung
   von Schlüsselfunktionen finden Sie im Sorting HOW TO.

Schlüsselwortargument
   Siehe *Argument*.

Lambda
   Eine anonyme Inline-Funktion, die aus einem einzigen *Ausdruck*
   besteht, der beim Aufruf der Funktion ausgewertet wird. Die Syntax
   zum Erstellen einer Lambda-Funktion lautet "lambda [parameters]:
   expression"

LBYL
   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
   *EAFP*-Ansatz und zeichnet sich durch das häufige Vorkommen von
   "if" -Anweisungen aus.

   In einer Multithread-Umgebung besteht bei dem LBYL-Ansatz die
   Gefahr, dass eine *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 *Locks* oder durch
   Verwendung des *EAFP*-Ansatzes lösen. Siehe auch *thread-safe*.

Lexikalischer Analysator
   Formale Bezeichnung für den *Tokenizer*; siehe *token*.

Liste
   A built-in Python *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).

Listenkomprimierung
   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  "if"  ist optional.  Wird sie weggelassen, werden alle
   Elemente in  "range(256)"  verarbeitet.

Schloss
   Eine *Synchronisationsprimitive*, 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  "threading"
   stellt  "Lock"  (eine einfache Sperre) und  "RLock"  (eine
   *reentrante* Sperre) bereit.  Sperren werden verwendet, um *Race-
   Conditions* zu verhindern und einen *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
   *Deadlock* und *reentrant*.

sperrfrei
   Eine Operation, die keine *Sperre* 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 *free-threaded* Python
   bieten integrierte Typen wie "dict" und "list" lock-freie
   Leseoperationen, was bedeutet, dass andere Threads bei mehrstufigen
   Änderungen Zwischenzustände beobachten können, selbst wenn diese
   Änderungen die *per-object lock* halten.

Lader
   Ein Objekt, das ein Modul lädt. Es muss die Methoden
   "exec_module()"  und  "create_module()"  definieren, um die
   Schnittstelle  "Loader"  zu implementieren. Ein Loader wird in der
   Regel von einem *finder* zurückgegeben. Siehe auch:

   * Finders und Loader

   * "importlib.abc.Loader"

   * **PEP 302**

Ländereinstellung, Kodierung
   Unter Unix handelt es sich um die Kodierung der Locale LC_CTYPE.
   Sie kann mit "locale.setlocale(locale.LC_CTYPE, new_locale)
   <locale.setlocale>`()" festgelegt werden.

   Unter Windows ist dies die ANSI-Codepage (z. B.: ""cp1252"").

   Unter Android und VxWorks verwendet Python  ""utf-8""  als Locale-
   Kodierung.

   "locale.getencoding()" kann verwendet werden, um die Kodierung der
   Ländereinstellung abzurufen.

   Siehe auch den Eintrag *Dateisystem-Kodierung und
   Fehlerbehandlung*.

magische Methode
   Ein umgangssprachliches Synonym für *Spezialmethode*.

Kartierung
   Ein Container-Objekt, das die Suche nach beliebigen Schlüsseln
   unterstützt und die Methoden implementiert, die in den
   "collections.abc.Mapping" oder
   "collections.abc.MutableMapping"abstrakten Basisklassen festgelegt
   sind. Beispiele hierfür sind "dict", "collections.defaultdict",
   "collections.OrderedDict" und "collections.Counter".

Meta-Pfadfinder
   Ein *Finder*, der bei einer Suche auf "sys.meta_path" zurückgegeben
   wird. Meta-Pfadfinder stehen in Zusammenhang mit *Pfadeintrags-
   Findern*, unterscheiden sich jedoch von diesen.

   Unter "importlib.abc.MetaPathFinder" finden Sie die Methoden, die
   Meta-Path-Finder implementieren.

Metaklasse
   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.

   Weitere Informationen finden Sie unter Metaklassen.

Methode
   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 *Argument* (das üblicherweise
   als  "self"  bezeichnet wird). Siehe *function* und *nested scope*.

Reihenfolge der Methodenauflösung
   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, finden Sie unter
   The Python 2.3 Method Resolution Order.

Modul
   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 *Importierens* in
   Python geladen.

   Siehe auch *Paket*.

Modulspezifikation
   Ein Namespace, der die Import-bezogenen Informationen enthält, die
   zum Laden eines Moduls verwendet werden. Eine Instanz von
   "importlib.machinery.ModuleSpec".

   Siehe auch Modulspezifikationen.

MRO
   Siehe *Reihenfolge der Methodenauflösung*.

veränderlich
   Ein *Objekt* 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 *Race-Conditions* zu vermeiden.
   Siehe auch *unveränderlich*, *thread-sicher* und *parallele
   Änderung*.

benanntes Tupel
   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.

   Mehrere integrierte Datentypen werden als Tupel bezeichnet,
   darunter die von  "time.localtime()"  und  "os.stat()"
   zurückgegebenen Werte. Ein weiteres Beispiel ist  "sys.float_info":

      >>> sys.float_info[1]                   # indizierter Zugriff
      1024
      >>> sys.float_info.max_exp              # Zugriff auf ein benanntes Feld
      1024
      >>> isinstance(sys.float_info, tuple)   # Typ eines Tupels
      True

   Einige benannte Tupel sind integrierte Typen (wie die obigen
   Beispiele). Alternativ kann ein benanntes Tupel aus einer regulären
   Klassendefinition erstellt werden, die von  "tuple"  erbt und
   benannte Felder definiert. Eine solche Klasse kann manuell
   geschrieben werden oder durch Vererbung von  "typing.NamedTuple"
   bzw. mit der Factory-Funktion  "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.

Namensraum
   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 "builtins.open" und "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 "random.seed()"
   oder "itertools.islice()" schreibt, wird deutlich, dass diese
   Funktionen jeweils von den Modulen "random" und "itertools"
   implementiert werden.

Namensraum-Paket
   Ein *Paket*, das ausschließlich als Container für Unterpakete
   dient. Namespace-Pakete haben möglicherweise keine physische
   Darstellung und unterscheiden sich insbesondere von einem *normalen
   Paket*, da sie keine Datei  "__init__.py"  enthalten.

   Namespace-Pakete ermöglichen es, dass mehrere einzeln
   installierbare Pakete ein gemeinsames übergeordnetes Paket haben.
   Andernfalls wird empfohlen, ein *normales Paket* zu verwenden.

   Weitere Informationen finden Sie unter **PEP 420** und Namespace-
   Pakete.

   Siehe auch *Modul*.

Nativcode
   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 *Erweiterungsmodulen*, der von Python aus
   aufgerufen werden kann.  Siehe auch *Erweiterungsmodul*.

verschachtelter Gültigkeitsbereich
   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. Beachten Sie, 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  "nonlocal"
   ermöglicht das Schreiben in äußere Gültigkeitsbereiche.

Klasse im neuen Stil
   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  "__slots__" , Deskriptoren,
   Eigenschaften,  "__getattribute__()" , Klassenmethoden und
   statische Methoden.

nicht deterministisch
   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 *Race-Conditions*, bei denen der relative zeitliche
   Ablauf oder die Verflechtung von Threads das Ergebnis beeinflusst.
   Eine ordnungsgemäße Synchronisation mithilfe von *Locks* und
   anderen *Synchronisationsprimitiven* trägt dazu bei, ein
   deterministisches Verhalten sicherzustellen.

Objekt
   Jede Dateninstanz mit einem Zustand (Attribute oder Wert) und
   definiertem Verhalten (Methoden). Außerdem die oberste Basisklasse
   jeder *Klasse neuen Stils*.

optimierter Umfang
   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.

Paket
   Ein Python-*Modul*, das Untermodule oder – rekursiv – Unterpakete
   enthalten kann. Technisch gesehen ist ein Paket ein Python-Modul
   mit einem Attribut vom Typ  "__path__" .

   Siehe auch *reguläres Paket* und *Namensraum-Paket*.

Parallelität
   Die gleichzeitige Ausführung mehrerer Operationen (z. B. auf
   mehreren CPU-Kernen).  In Python-Builds mit dem *global interpreter
   lock (GIL)* 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. "multiprocessing") oder native
   Erweiterungen erforderlich, die das GIL aufheben. In *free-
   threaded* Python können mehrere Python-Threads Python-Code
   gleichzeitig auf verschiedenen Kernen ausführen.

Parameter
   Eine benannte Entität in einer *Funktions*- (oder
   Methoden-)Definition, die ein *Argument* (oder in manchen Fällen
   mehrere Argumente) angibt, das bzw. die die Funktion entgegennehmen
   kann. Es gibt fünf Arten von Parametern:

   * *positional-or-keyword*: Gibt ein Argument an, das entweder
     *positionsbezogen* oder als *Schlüsselwortargument* übergeben
     werden kann. Dies ist die Standardart von Parametern, zum
     Beispiel *foo* und *bar* im Folgenden:

        def func(foo, bar=None): ...

   * *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:

        def func(posonly1, posonly2, /, positional_or_keyword): ...

   * *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:

        def func(arg, *, kw_only1, kw_only2): ...

   * *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:

        def func(*args, **kwargs): ...

   * *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.

   Parameter können sowohl optionale als auch erforderliche Argumente
   sowie Standardwerte für einige optionale Argumente festlegen.

   Siehe auch den Glossareintrag *argument*, die FAQ-Frage zu dem
   Unterschied zwischen Argumenten und Parametern, die Klasse
   "inspect.Parameter", den Abschnitt Funktionsdefinitionen und **PEP
   362**.

Objektspezifische Sperre
   Ein *Lock*, der mit einer einzelnen Objektinstanz verknüpft ist, im
   Gegensatz zu einem globalen Lock, der von allen Objekten gemeinsam
   genutzt wird. In *free-threaded* Python verwenden integrierte Typen
   wie "dict" und "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 *lock-free*-Operationen.

Pfadeintrag
   Ein einzelner Speicherort im *Importpfad*, den der *pfadbasierte
   Finder* abfragt, um Module zum Importieren zu finden.

Pfadeintrags-Finder
   Ein *finder*, der von einer auf "sys.path_hooks" aufrufbaren
   Funktion (d. h. einem *path entry hook*) zurückgegeben wird, die
   weiß, wie man Module anhand eines *path entry* findet.

   Unter "importlib.abc.PathEntryFinder" finden Sie die Methoden, die
   von Path-Entry-Findern implementiert werden.

Pfadeintrag-Hook
   Eine auf der Liste  "sys.path_hooks"  aufrufbare Funktion, die
   einen *Pfadeintrag-Finder* zurückgibt, sofern sie weiß, wie Module
   auf einem bestimmten *Pfadeintrag* gefunden werden können.

Pfadbasierter Sucher
   Einer der standardmäßigen *Meta-Pfadfinder*, der einen *Importpfad*
   nach Modulen durchsucht.

pfadähnliches Objekt
   Ein Objekt, das einen Dateisystempfad darstellt. Ein pfadähnliches
   Objekt ist entweder ein  "str" - oder ein  "bytes" -Objekt, das
   einen Pfad darstellt, oder ein Objekt, das das  "os.PathLike"
   -Protokoll implementiert. Ein Objekt, das das  "os.PathLike"
   -Protokoll unterstützt, kann durch Aufruf der Funktion
   "os.fspath()"  in einen  "str" - oder  "bytes" -Dateisystempfad
   umgewandelt werden; mit  "os.fsdecode()"  bzw.  "os.fsencode()"
   lässt sich stattdessen ein  "str" - bzw.  "bytes" -Ergebnis
   gewährleisten. Eingeführt durch  **PEP 519** .

PEP
   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.

   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.

   Siehe **PEP 1**.

Anteil
   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.

Positionsargument
   Siehe *Argument*.

vorläufige API
   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.

   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.

   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 finden Sie unter **PEP 411**.

vorläufiges Paket
   Siehe *vorläufige API*.

Python 3000
   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.

Pythonesk
   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  "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:

      for i in range(len(food)):
          print(food[i])

   Im Gegensatz zu der übersichtlicheren, pythonesken Methode:

      für Stück in Essen:
          print(Stück)

qualifizierter Name
   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:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

   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":

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

Race-Condition
   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
   *nicht-deterministischem* Verhalten und schwer reproduzierbaren
   Fehlern führen.  Ein *Datenrennen* ist eine spezielle Art von Race
   Condition, bei der es um den nicht synchronisierten Zugriff auf
   gemeinsam genutzten Speicher geht. Der *LBYL*-Programmierstil ist
   in Multithread-Code besonders anfällig für Race Conditions. Die
   Verwendung von *Locks* und anderen *Synchronisationsprimitiven*
   hilft, Race Conditions zu vermeiden.

Referenzanzahl
   Die Anzahl der Verweise auf ein Objekt. Wenn die Referenzanzahl
   eines Objekts auf null sinkt, wird es freigegeben. Einige Objekte
   sind *unsterblich* 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 *CPython*-Implementierung
   dar.  Programmierer können die Funktion  "sys.getrefcount()"
   aufrufen, um die Referenzanzahl für ein bestimmtes Objekt
   abzurufen.

   In *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.

Standardpaket
   Ein herkömmliches *Paket*, beispielsweise ein Verzeichnis, das eine
   Datei vom Typ  "__init__.py"  enthält.

   Siehe auch: *Namensraum-Paket*.

wiederkehrend
   Eine Eigenschaft einer Funktion oder eines *lock*, die es
   ermöglicht, dass diese mehrfach vom selben Thread aufgerufen bzw.
   erworben wird, ohne dass dabei Fehler oder ein *Deadlock*
   auftreten.

   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 *nicht deterministisch* sein, wenn sie in einem
   Multithread-Programm reentrant aufgerufen werden.

   Was Sperren betrifft, ist die Python-Sperre  "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  "threading.Lock"  nicht
   reentrant – der Versuch, sie zweimal vom selben Thread aus zu
   erwerben, führt zu einem Deadlock.

   Siehe auch *lock* und *deadlock*.

REPL
   Eine Abkürzung für "read–eval–print loop" (Lesen–Auswerten
   –Ausgeben-Schleife), eine andere Bezeichnung für die *interaktive*
   Interpreter-Shell.

__slots__
   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.

Sequenz
   Ein *iterable*, das einen effizienten Zugriff auf Elemente mithilfe
   ganzzahliger Indizes über die spezielle Methode "__getitem__()"
   unterstützt und eine Methode "__len__()" definiert, die die Länge
   der Sequenz zurückgibt. Einige integrierte Sequenztypen sind
   "list", "str", "tuple" und "bytes". Beachten Sie, dass "dict"
   ebenfalls "__getitem__()" und "__len__()" unterstützt, jedoch eher
   als Mapping denn als Sequenz betrachtet wird, da die Suchvorgänge
   beliebige *hashable*-Schlüssel anstelle von Ganzzahlen verwenden.

   Die abstrakte Basisklasse  "collections.abc.Sequence"  definiert
   eine wesentlich umfangreichere Schnittstelle, die über die Methoden
   "__getitem__()"  und  "__len__()" hinausgeht und um die Methoden
   "count()",  "index()",  "__contains__()" sowie  "__reversed__()"
   erweitert wird. Typen, die diese erweiterte Schnittstelle
   implementieren, können explizit mit  "register()" registriert
   werden. Weitere Informationen zu Sequenzmethoden im Allgemeinen
   finden Sie unter Common Sequence Operations.

Mengenkomprimierung
   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 Darstellungen für Listen, Mengen und Wörterbücher.

Einzelversand
   Eine Form der *generischen Funktionsauswahl*, bei der die
   Implementierung anhand des Typs eines einzelnen Arguments
   ausgewählt wird.

Scheibe
   An object usually containing a portion of a *sequence*.  A slice is
   created using the subscript notation, "[]" with colons between
   numbers when several are given, such as in "variable_name[1:3:5]".
   The bracket (subscript) notation uses "slice" objects internally.

weich veraltet
   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.

   Im Gegensatz zur normalen Veralterung ist bei einer Soft
   Deprecation nicht vorgesehen, die API zu entfernen, und es werden
   keine Warnungen ausgegeben.

   Siehe PEP 387: Soft Deprecation.

spezielle Methode
   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 Spezielle
   Methodennamen dokumentiert.

Standardbibliothek
   Die Sammlung von *Paketen*, *Modulen* und *Erweiterungsmodulen*,
   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 finden Sie unter The Python standard
   library.

   Eine Liste aller möglichen Namen von Standardbibliotheksmodulen
   finden Sie unter "sys.stdlib_module_names".

Erklärung
   Eine Anweisung ist Teil einer Suite (eines "Code-Blocks"). Eine
   Anweisung ist entweder ein *Ausdruck* oder eine von mehreren
   Konstrukten mit einem Schlüsselwort, wie beispielsweise  "if" ,
   "while"  oder  "for" .

statischer Typprüfer
   Ein externes Tool, das Python-Code ausliest und analysiert, um
   Probleme wie beispielsweise falsche Typen zu erkennen. Siehe auch
   *Typangaben* und das Modul  "typing" .

stdlib
   Eine Abkürzung für *Standardbibliothek*.

stehlen
   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.

   Eine ausführliche Erläuterung finden Sie unter Reference Count
   Details.

starke Referenz
   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  "Py_INCREF()"  beim
   Erstellen der Referenz hergestellt und durch den Aufruf von
   "Py_DECREF()"  beim Löschen der Referenz freigegeben.

   Mit der Funktion  "Py_NewRef()"  lässt sich eine starke Referenz
   auf ein Objekt erstellen. In der Regel muss die Funktion
   "Py_DECREF()"  für die starke Referenz aufgerufen werden, bevor der
   Geltungsbereich der starken Referenz verlassen wird, um ein
   Referenzleck zu vermeiden.

   Siehe auch: *entlehnte Referenz*.

Synchronisationsprimitive
   Ein grundlegender Baustein zur Koordination (Synchronisation) der
   Ausführung mehrerer Threads, um einen *thread-safe* Zugriff auf
   gemeinsam genutzte Ressourcen zu gewährleisten. Das Python-Modul
   "threading"  stellt mehrere Synchronisationsprimitive bereit,
   darunter  "Lock" ,  "RLock" ,  "Semaphore" ,  "Condition" ,
   "Event"  und  "Barrier" .  Darüber hinaus bietet das Modul  "queue"
   Multi-Producer- und Multi-Consumer-Warteschlangen, die besonders in
   Multithread-Programmen nützlich sind. Diese Primitive tragen dazu
   bei, *Race-Conditions* zu verhindern und die Thread-Ausführung zu
   koordinieren.  Siehe auch *lock*.

Textkodierung
   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.

   Die Umwandlung einer Zeichenkette in eine Bytefolge wird als
   "Kodierung" bezeichnet, und die Rekonstruktion der Zeichenkette aus
   der Bytefolge wird als "Dekodierung" bezeichnet.

   Es gibt eine Vielzahl verschiedener Text-Serialisierungsverfahren
   Codecs, die zusammenfassend als "Textkodierungen" bezeichnet
   werden.

Textdatei
   Ein *Dateiobjekt*, das "str" -Objekte lesen und schreiben kann.
   Häufig greift eine Textdatei tatsächlich auf einen byteurientierten
   Datenstrom zu und übernimmt die *Textkodierung* automatisch.
   Beispiele für Textdateien sind Dateien, die im Textmodus geöffnet
   wurden ("'r'" oder "'w'"), "sys.stdin", "sys.stdout" sowie
   Instanzen von "io.StringIO".

   Siehe auch *Binärdatei* für ein Dateiobjekt, das *byteähnliche
   Objekte* lesen und schreiben kann.

thread-safe
   Ein Modul, eine Funktion oder eine Klasse, die sich bei
   gleichzeitiger Nutzung durch mehrere Threads korrekt verhält.
   Thread-sicherer Code verwendet geeignete
   *Synchronisationsprimitive* wie *Locks*, 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 *free-threaded*-Version verwenden integrierte Typen
   wie "dict", "list" und "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 *Race-Conditions* und
   *Datenkonflikten* führen.

Token
   Eine kleine Einheit des Quellcodes, die vom lexikalischen
   Analysator (auch *Tokenizer* genannt) generiert wird. Namen,
   Zahlen, Zeichenketten, Operatoren, Zeilenumbrüche und Ähnliches
   werden durch Token dargestellt.

   Das Modul  "tokenize"  stellt den lexikalischen Analysator von
   Python bereit. Das Modul  "token"  enthält Informationen zu den
   verschiedenen Token-Typen.

Zeichenkette in dreifachen Anführungszeichen
   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.

Typ
   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  "__class__"  zugänglich oder kann mit
   "type(obj)`" abgerufen werden.

Typalias
   Ein Synonym für einen Typ, das durch die Zuweisung des Typs zu
   einem Bezeichner erstellt wird.

   Typ-Aliase sind nützlich, um *Typ-Hinweise* zu vereinfachen. Zum
   Beispiel:

      def remove_gray_shades(
              colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
          pass

   könnte so lesbarer gestaltet werden:

      Farbe = Tupel[int, int, int]

      def remove_gray_shades(colors: Liste[Farbe]) -> Liste[Farbe]:
          pass

   Siehe "typing" und **PEP 484**, wo diese Funktion beschrieben wird.

Typhinweis
   Eine *Annotation*, die den erwarteten Typ für eine Variable, ein
   Klassenattribut oder einen Funktionsparameter bzw. Rückgabewert
   angibt.

   Typangaben sind optional und werden von Python nicht erzwungen,
   sind jedoch für *statische Typprüfer* nützlich. Außerdem können sie
   IDEs bei der Code-Vervollständigung und beim Refactoring
   unterstützen.

   Typhinweise für globale Variablen, Klassenattribute und Funktionen,
   nicht jedoch für lokale Variablen, können über
   "typing.get_type_hints()"  abgerufen werden.

   Siehe "typing" und **PEP 484**, wo diese Funktion beschrieben wird.

universelle Zeilenumbrüche
   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 "bytes.splitlines()" für eine weitere
   Anwendungsmöglichkeit.

Variablenbeschriftung
   Eine *Annotation* einer Variablen oder eines Klassenattributs.

   Bei der Annotation einer Variablen oder eines Klassenattributs ist
   die Zuweisung optional:

      Klasse C:
          Feld: 'annotation'

   Variablenannotationen werden in der Regel für *Typangaben*
   verwendet – beispielsweise wird erwartet, dass diese Variable Werte
   vom Typ "int" annimmt:

      Zähler: int = 0

   Die Syntax für die Annotation von Variablen wird im Abschnitt
   Kommentierte Zuweisungsanweisungen  erläutert.

   Siehe *Funktionsannotation*, **PEP 484** und **PEP 526**, wo diese
   Funktionalität beschrieben wird. Siehe auch Annotations Best
   Practices für bewährte Vorgehensweisen beim Umgang mit
   Annotationen.

virtuelle Umgebung
   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.

   Siehe auch "venv".

virtuelle Maschine
   Ein vollständig in Software definierter Computer. Die virtuelle
   Maschine von Python führt den vom Bytecode-Compiler erzeugten
   *Bytecode* aus.

Walross-Betreiber
   Eine scherzhafte Bezeichnung für den Zuweisungsausdruck Operator
   ":=", da er ein bisschen wie ein Walross aussieht, wenn man den
   Kopf etwas dreht.

Zen von Python
   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.
