Glossar
*******

">>>"
   The default Python prompt of the interactive shell.  Often seen for
   code examples which can be executed interactively in the
   interpreter.

"..."
   Kann sich beziehen auf:

   * The default Python prompt of the 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.

   * The "Ellipsis" built-in constant.

2to3
   A tool that tries to convert Python 2.x code to Python 3.x code by
   handling most of the incompatibilities which can be detected by
   parsing the source and traversing the parse tree.

   2to3 is available in the standard library as "lib2to3"; a
   standalone entry point is provided as "Tools/scripts/2to3".  See
   2to3 --- Automated Python 2 to 3 code translation.

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
   A function which returns an *asynchronous generator iterator*.  It
   looks like a coroutine function defined with "async def" except
   that it contains "yield" expressions for producing a series of
   values usable in an "async for" loop.

   Usually refers to an asynchronous generator function, but may refer
   to an *asynchronous generator iterator* in some contexts.  In cases
   where the intended meaning isn't clear, using the full terms avoids
   ambiguity.

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

asynchrone Generator-Iterator
   An object created by a *asynchronous generator* function.

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

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.

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.

Kontextmanager
   An object which controls the environment seen in a "with" statement
   by defining "__enter__()" and "__exit__()" methods. See **PEP
   343**.

Kontextvariable
   A variable which can have different values depending on its
   context. This is similar to Thread-Local Storage in which each
   execution thread may have a different value for a variable.
   However, with context variables, there may be several contexts in
   one execution thread and the main usage for context variables is to
   keep track of variables in concurrent asynchronous tasks. See
   "contextvars".

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.

Dekorateur
   A function returning another function, usually applied as a
   function transformation using the "@wrapper" syntax.  Common
   examples for decorators are "classmethod()" and "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 objects.

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.

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
   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
   *statement*s which cannot be used as expressions, such as "while".
   Assignments are also statements, not expressions.

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

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
   A function which returns a *generator iterator*.  It looks like a
   normal function except that it contains "yield" expressions for
   producing a series of values usable in a for-loop or that can be
   retrieved one at a time with the "next()" function.

   Usually refers to a generator function, but may refer to a
   *generator iterator* in some contexts.  In cases where the intended
   meaning isn't clear, using the full terms avoids ambiguity.

Generator-Iterator
   An object created by a *generator* function.

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

Generatorausdruck
   An expression that returns an iterator.  It looks like a normal
   expression followed by a "for" clause defining a loop variable,
   range, and an optional "if" clause.  The combined expression
   generates values for an enclosing function:

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

   See also the *single dispatch* glossary entry, the
   "functools.singledispatch()" decorator, and **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.

   Past efforts to create a "free-threaded" interpreter (one which
   locks shared data at a much finer granularity) have not been
   successful because performance suffered in the common single-
   processor case. It is believed that overcoming this performance
   issue would make the implementation much more complicated and
   therefore costlier to maintain.

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

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

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

   **CPython-Implementierungsdetail:** CPython does not consistently
   apply the requirement that an iterator define "__iter__()".

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

   There are several ways to create a key function.  For example. the
   "str.lower()" method can serve as a key function for case
   insensitive sorts.  Alternatively, a key function can be built from
   a "lambda" expression such as "lambda r: (r[0], r[2])".  Also,
   "operator.attrgetter()", "operator.itemgetter()", and
   "operator.methodcaller()" are three key function constructors.  See
   the Sorting HOW TO for examples of how to create and use key
   functions.

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 a multi-threaded environment, the LBYL approach can risk
   introducing a 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 locks or by using the EAFP approach.

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.

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
   Mutable objects can change their value but keep their "id()".  See
   also *immutable*.

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

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.

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

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

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

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'

Referenzanzahl
   The number of references to an object.  When the reference count of
   an object drops to zero, it is deallocated.  Some objects are
   "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 *CPython* implementation.  Programmers can call the
   "sys.getrefcount()" function to return the reference count for a
   particular object.

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

   Siehe auch: *Namensraum-Paket*.

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

   The "collections.abc.Sequence" abstract base class defines a much
   richer interface that goes beyond just "__getitem__()" and
   "__len__()", adding "count()", "index()", "__contains__()", and
   "__reversed__()". Types that implement this expanded interface can
   be registered explicitly using "register()". For more documentation
   on sequence methods generally, see 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.

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

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

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.

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.

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.
