Integrierte Funktionen
**********************

Der Python-Interpreter verfügt über eine Reihe integrierter Funktionen
und Typen,die jederzeit verfügbar sind. Sie sind hier in
alphabetischer Reihenfolge aufgeführt.

+---------------------------+-------------------------+-------------------------+---------------------------+
| Integrierte Funktionen                                                                                    |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "anext()" "any()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(number, /)

   Gibt den Absolutwert einer Zahl zurück. Das Argument kann eine
   Ganzzahl, eine Gleitkommazahl oder ein Objekt sein, das "__abs__()"
   implementiert. Handelt es sich bei dem Argument um eine komplexe
   Zahl, wird deren Betrag zurückgegeben.

aiter(async_iterable, /)

   Gibt einen *asynchronous iterator* für ein *asynchronous iterable*
   zurück. Entspricht dem Aufruf von "x.__aiter__()".

   Hinweis: Im Gegensatz zu "iter()" gibt es bei "aiter()" keine
   Variante mit zwei Argumenten

   Added in version 3.10.

all(iterable, /)

   Gibt "True" zurück, wenn alle Elemente des *iterable* wahr sind
   (oder wenn das iterable leer ist). Entspricht::“

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

awaitable anext(async_iterator, /)
awaitable anext(async_iterator, default, /)

   When awaited, return the next item from the given *asynchronous
   iterator*, or *default* if given and the iterator is exhausted.

   Dies ist die asynchrone Variante der eingebauten Funktion "next()"
   und verhält sich ähnlich.

   Dies ruft die Methode "__anext__()" von *async_iterator* auf und
   gibt ein *awaitable* zurück. Das Warten auf dieses (mittels
   "await") liefert den nächsten Wert des Iterators. Wenn *default*
   angegeben ist, wird dieser Wert zurückgegeben, falls der Iterator
   erschöpft ist; andernfalls wird "StopAsyncIteration" ausgelöst.

   Added in version 3.10.

any(iterable, /)

   Gibt "True" zurück, wenn mindestens ein Element des *iterable* wahr
   ist. Wenn das Iterable leer ist, wird "False" zurückgegeben.
   Entspricht:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object, /)

   Gibt wie "repr()" einen String zurück, der eine druckbare
   Darstellung eines Objekts enthält; allerdings werden Nicht-ASCII-
   Zeichen in dem von "repr()" zurückgegebenen String mittels "\x"-,
   "\u"- oder "\U"-Escapes maskiert. Dies erzeugt einen String, der
   dem ähnelt, den "repr()" in Python 2 zurückgibt.

bin(integer, /)

   Wandelt eine Ganzzahl in eine Binärzeichenkette mit dem Präfix "0b"
   um. Das Ergebnis ist ein gültiger Python-Ausdruck. Wenn *integer*
   kein Python-Objekt vom Typ "int" ist, muss es eine
   "__index__()"-Methode definieren, die eine Ganzzahl zurückgibt.
   Einige Beispiele:

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   Je nachdem, ob das Präfix "0b" gewünscht ist oder nicht, können Sie
   eine der folgenden Methoden verwenden.

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   Siehe auch "enum.bin()", um negative Werte als Zweierkomplement
   darzustellen.

   Weitere Informationen findest du unter "format()".

class bool(object=False, /)

   Gibt einen booleschen Wert zurück, d. h. entweder "True" oder
   "False". Das Argument wird mithilfe des Standardverfahrens zur
   Wahrheitsprüfung truth testing procedure umgewandelt. Ist das
   Argument falsch oder wird es weggelassen, wird "False"
   zurückgegeben; andernfalls wird "True" zurückgegeben. Die Klasse
   "bool" ist eine Unterklasse von "int" (siehe Numerische Typen ---
   int, float, complex). Sie kann nicht weiter unterteilt werden. Ihre
   einzigen Instanzen sind "False" und "True" (siehe Boolescher Typ –
   bool).

   Geändert in Version 3.7: Der Parameter ist jetzt rein
   positionsgebunden.

breakpoint(*args, **kws)

   Diese Funktion ruft an der Aufrufstelle den Debugger auf. Genauer
   gesagt ruft sie "sys.breakpointhook()" auf und reicht dabei "args"
   und "kws" direkt weiter. Standardmäßig ruft "sys.breakpointhook()"
   die Funktion "pdb.set_trace()" ohne Argumente auf. In diesem Fall
   handelt es sich lediglich um eine Komfortfunktion, damit Sie "pdb"
   nicht explizit importieren oder viel Code schreiben müssen, um in
   den Debugger zu gelangen. "sys.breakpointhook()" kann jedoch auf
   eine andere Funktion gesetzt werden, die dann automatisch von
   "breakpoint()" aufgerufen wird; so können Sie den Debugger Ihrer
   Wahl verwenden. Ist "sys.breakpointhook()" nicht verfügbar, löst
   diese Funktion einen "RuntimeError" aus.

   Standardmäßig lässt sich das Verhalten von "breakpoint()" über die
   Umgebungsvariable "PYTHONBREAKPOINT" ändern. Einzelheiten zur
   Verwendung finden Sie unter "sys.breakpointhook()".

   Beachte, dass dies nicht garantiert ist, wenn
   "sys.breakpointhook()" ersetzt wurde.

   Löst ein Audit-Ereignis "builtins.breakpoint" mit dem Argument
   "breakpointhook" aus.

   Added in version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

   Gibt ein neues Byte-Array zurück. Die Klasse "bytearray" ist eine
   veränderbare Sequenz von Ganzzahlen im Bereich 0 <= x < 256. Sie
   verfügt über die meisten der üblichen Methoden veränderbarer
   Sequenzen, die unter Veränderliche Sequenztypen beschrieben sind,
   sowie über die meisten Methoden des Typs "bytes", siehe Bytes- und
   Bytearray-Operationen.

   Der optionale Parameter *source* kann verwendet werden, um das
   Array auf unterschiedlichen Wegen zu initialisieren:“

   * Wenn es sich um einen *string* handelt, musst du auch die
     Parameter *encoding* (und optional *errors*) angeben;
     "bytearray()" wandelt den String dann mithilfe von "str.encode()"
     in Bytes um.“

   * Wenn es sich um eine Ganzzahl (*integer*) handelt, erhält das
     Array diese Größe und wird mit Null-Bytes initialisiert.“

   * Handelt es sich um ein Objekt, das dem buffer interface
     entspricht, so wird ein schreibgeschützter Puffer des Objekts
     verwendet, um das Bytes-Array zu initialisieren.“

   * Wenn es sich um ein *iterable* handelt, muss es eine Liste von
     Ganzzahlen im Bereich "0 <= x < 256" sein, die als anfänglicher
     Inhalt des Arrays verwendet werden.“

   Ohne Argument wird ein Array der Größe 0 erstellt.

   Siehe auch Binäre Sequenztypen – bytes, bytearray, memoryview und
   Bytearray-Objekte.

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

   Gibt ein neues "bytes"-Objekt zurück, bei dem es sich um eine
   unveränderliche Sequenz von Ganzzahlen im Bereich "0 <= x < 256"
   handelt. "bytes" ist eine unveränderliche Version von "bytearray" –
   es verfügt über dieselben nicht-modifizierenden Methoden sowie
   dasselbe Verhalten bei Indizierung und Slicing.

   Demzufolge werden die Konstruktorargumente wie bei "bytearray()"
   interpretiert.

   Bytes-Objekte können auch mithilfe von Literalen erstellt werden;
   siehe String and Bytes literals.

   Siehe auch Binäre Sequenztypen – bytes, bytearray, memoryview,
   Bytes-Objekte und Bytes- und Bytearray-Operationen.

callable(object, /)

   Gibt "True" zurück, wenn das Argument *object* aufrufbar erscheint,
   andernfalls "False". Wenn dies "True" zurückgibt, ist es dennoch
   möglich, dass ein Aufruf fehlschlägt; ist es jedoch "False", wird
   der Aufruf von *object* niemals erfolgreich sein. Beachte, dass
   Klassen aufrufbar sind (der Aufruf einer Klasse gibt eine neue
   Instanz zurück); Instanzen sind aufrufbar, wenn ihre Klasse über
   eine Methode "__call__()" verfügt.

   Added in version 3.2: Diese Funktion wurde zunächst in Python 3.0
   entfernt und dann in Python 3.2 wieder eingeführt.

chr(codepoint, /)

   Gibt den String zurück, der das Zeichen mit dem angegebenen
   Unicode-Codepunkt darstellt. Zum Beispiel liefert "chr(97)" den
   String "'a'", während "chr(8364)" den String "'€'" liefert. Dies
   ist die Umkehrfunktion zu "ord()".

   Der zulässige Wertebereich für das Argument reicht von 0 bis
   1.114.111 (0x10FFFF im Hexadezimalsystem). Liegt der Wert außerhalb
   dieses Bereichs, wird eine "ValueError"-Ausnahme ausgelöst.

@classmethod

   Wandeln Sie eine Methode in eine Klassenmethode um.

   Eine Klassenmethode erhält die Klasse als implizites erstes
   Argument, genau wie eine Instanzmethode die Instanz erhält. Um eine
   Klassenmethode zu deklarieren, verwenden Sie dieses Idiom:

      class C:
          @classmethod
          def f(cls, arg1, arg2): ...

   Die "@classmethod"-Form ist eine Funktion *decorator* – siehe
   Funktionsdefinitionen für Details.“

   Eine Klassenmethode kann entweder auf der Klasse (z. B. "C.f()")
   oder auf einer Instanz (z. B. "C().f()") aufgerufen werden. Die
   Instanz wird dabei ignoriert, mit Ausnahme ihrer Klasse. Wird eine
   Klassenmethode für eine abgeleitete Klasse aufgerufen, so wird das
   Objekt der abgeleiteten Klasse als implizites erstes Argument
   übergeben.

   Klassenmethoden unterscheiden sich von statischen Methoden in C++
   oder Java. Wenn Sie solche benötigen, siehe "staticmethod()" in
   diesem Abschnitt. Weitere Informationen zu Klassenmethoden finden
   Sie unter Die Standardtyp-Hierarchie.

   Geändert in Version 3.9: Klassenmethoden können nun andere
   *Deskriptoren* wie "property()" umschließen.

   Geändert in Version 3.10: Klassenmethoden erben nun die
   Methodenattribute ("__module__", "__name__", "__qualname__",
   "__doc__" und "__annotations__") und verfügen über ein neues
   "__wrapped__"-Attribut.

   Veraltet seit Version 3.11, entfernt in Version 3.13:
   Klassenmethoden können keine anderen *Deskriptoren* mehr kapseln,
   wie etwa "property()".

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

   Kompiliere *source* zu einem Code- oder AST-Objekt. Code-Objekte
   können mit "exec()" oder "eval()" ausgeführt werden. *source* kann
   entweder ein normaler String, ein Byte-String oder ein AST-Objekt
   sein. Informationen zur Arbeit mit AST-Objekten findest du in der
   Dokumentation zum Modul "ast".

   Das Argument *filename* sollte die Datei angeben, aus der der Code
   gelesen wurde; übergeben Sie einen erkennbaren Wert, falls er nicht
   aus einer Datei gelesen wurde (häufig wird "'<string>'" verwendet).

   Das Argument *mode* legt fest, welche Art von Code kompiliert
   werden soll; es kann "'exec'" sein, wenn *source* aus einer Folge
   von Anweisungen besteht, "'eval'", wenn es aus einem einzelnen
   Ausdruck besteht, oder "'single'", wenn es aus einer einzelnen
   interaktiven Anweisung besteht (im letzteren Fall werden
   Ausdrucksanweisungen, die einen anderen Wert als "None" ergeben,
   ausgegeben).

   Die optionalen Argumente *flags* und *dont_inherit* steuern, welche
   Compiler-Optionen aktiviert und welche future features zugelassen
   werden sollen. Wenn keines der Argumente angegeben ist (oder beide
   null sind), wird der Code mit denselben Flags kompiliert, die auch
   für den Code gelten, der "compile()" aufruft. Wird das Argument
   *flags* angegeben, *dont_inherit* jedoch nicht (oder ist es null),
   so werden die durch *flags* festgelegten Compiler-Optionen und
   future-Anweisungen zusätzlich zu jenen verwendet, die ohnehin zur
   Anwendung kämen. Ist *dont_inherit* eine Ganzzahl ungleich null, so
   ist das Argument *flags* allein maßgeblich – die Flags (future-
   Funktionen und Compiler-Optionen) des umgebenden Codes werden
   ignoriert.

   Compiler-Optionen und Future-Anweisungen werden durch Bits
   festgelegt, die mittels bitweiser ODER-Verknüpfung kombiniert
   werden können, um mehrere Optionen anzugeben. Das für eine
   bestimmte Future-Funktion erforderliche Bitfeld ist als Attribut
   "compiler_flag" der Instanz von "_Feature" im Modul "__future__" zu
   finden. Compiler-Flags sind im Modul "ast" unter dem Präfix "PyCF_"
   zu finden.

   Das Argument *optimize* legt die Optimierungsstufe des Compilers
   fest; der Standardwert "-1" wählt die Optimierungsstufe des
   Interpreters, wie sie durch die Optionen "-O" bestimmt wird.
   Explizite Stufen sind "0" (keine Optimierung; "__debug__" ist
   wahr), "1" (Erklärungen werden entfernt, "__debug__" ist falsch)
   oder "2" (auch Docstrings werden entfernt).

   This function raises "SyntaxError" if the compiled source is
   invalid, including a *source* containing a null character or that
   cannot be decoded; "ValueError" if *mode* or *flags* is invalid, or
   if a string *source* contains surrogate characters; "MemoryError"
   or "RecursionError" if *source* is too complex to parse or compile,
   for example an expression with many thousands of nested operators;
   and "OverflowError" if *source* is too large.

   Wenn du Python-Code in seine AST-Darstellung parsen möchtest, siehe
   "ast.parse()".

   Löst ein Audit-Ereignis namens "compile" mit den Argumenten
   "source" und "filename" aus. Dieses Ereignis kann auch durch
   implizite Kompilierung ausgelöst werden.

   Bemerkung:

     Beim Kompilieren einer Zeichenkette mit mehrzeiligem Code im
     Modus "'single'" oder "'eval'" muss die Eingabe mit mindestens
     einem Zeilenumbruchzeichen enden. Dies dient dazu, die Erkennung
     unvollständiger und vollständiger Anweisungen im Modul "code" zu
     ​​erleichtern.

   Warnung:

     Es ist möglich, den Python-Interpreter beim Kompilieren in ein
     AST-Objekt mit einem hinreichend großen oder komplexen String zum
     Absturz zu bringen – bedingt durch die Beschränkungen der Stack-
     Tiefe im AST-Compiler von Python.

   Geändert in Version 3.2: Unterstützung für Zeilenumbrüche unter
   Windows und Mac hinzugefügt. Zudem muss die Eingabe im Modus
   "'exec'" nicht mehr mit einem Zeilenumbruch enden. Der Parameter
   *optimize* wurde hinzugefügt.

   Geändert in Version 3.5: Früher wurde ein "TypeError" ausgelöst,
   wenn in *source* Null-Bytes auftraten.

   Geändert in Version 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" kann nun
   in den Flags übergeben werden, um die Unterstützung für "await",
   "async for" und "async with" auf oberster Ebene zu aktivieren.

   Geändert in Version 3.12: "SyntaxError" is raised instead of
   "ValueError" when null bytes are encountered in *source*.

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Wandeln Sie eine einzelne Zeichenkette oder Zahl in eine komplexe
   Zahl um oder erstellen Sie eine komplexe Zahl aus Real- und
   Imaginärteil.

   Beispiele:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

   Wenn das Argument ein String ist, muss es entweder einen Realteil
   (im gleichen Format wie für "float()") oder einen Imaginärteil (im
   gleichen Format, jedoch mit dem Suffix "'j'" oder "'J'") oder
   sowohl einen Real- als auch einen Imaginärteil enthalten (wobei das
   Vorzeichen des Imaginärteils in diesem Fall zwingend erforderlich
   ist). Der String kann optional von Leerzeichen sowie den runden
   Klammern "'('" und "')'" umschlossen sein; diese werden ignoriert.
   Der String darf keine Leerzeichen zwischen "'+'", "'-'", dem Suffix
   "'j'" oder "'J'" und der Dezimalzahl enthalten. So ist
   beispielsweise "complex('1+2j')" zulässig, während "complex('1 +
   2j')" einen "ValueError" auslöst. Genauer gesagt muss die Eingabe –
   nach Entfernung von Klammern sowie führenden und nachgestellten
   Leerzeichen – der Produktionsregel "complexvalue" in der folgenden
   Grammatik entsprechen:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

   Wenn das Argument eine Zahl ist, fungiert der Konstruktor als
   numerische Umwandlung, ähnlich wie "int" und "float". Bei einem
   allgemeinen Python-Objekt "x" delegiert "complex(x)" an
   "x.__complex__()". Ist "__complex__()" nicht definiert, wird auf
   "__float__()" zurückgegriffen. Ist "__float__()" nicht definiert,
   wird auf "__index__()" zurückgegriffen.“

   Wenn zwei Argumente übergeben oder Schlüsselwortargumente verwendet
   werden, kann jedes Argument von einem beliebigen numerischen Typ
   (einschließlich komplexer Zahlen) sein. Sind beide Argumente reelle
   Zahlen, wird eine komplexe Zahl mit dem Realteil *real* und dem
   Imaginärteil *imag* zurückgegeben. Sind beide Argumente komplexe
   Zahlen, wird eine komplexe Zahl mit dem Realteil "real.real-
   imag.imag" und dem Imaginärteil "real.imag+imag.real"
   zurückgegeben. Ist eines der Argumente eine reelle Zahl, wird in
   den obigen Ausdrücken nur deren Realteil verwendet.

   Wenn keine Argumente angegeben werden, wird "0j" zurückgegeben.

   Der komplexe Typ wird unter Numerische Typen --- int, float,
   complex beschrieben.

   Geändert in Version 3.6: Die Gruppierung von Ziffern mittels
   Unterstrichen, wie bei Code-Literalen, ist zulässig.

   Geändert in Version 3.8: Fällt auf "__index__()" zurück, wenn
   "__complex__()" und "__float__()" nicht definiert sind.

delattr(object, name, /)

   Dies ist ein Gegenstück zu "setattr()". Die Argumente sind ein
   Objekt und eine Zeichenkette. Die Zeichenkette muss der Name eines
   der Attribute des Objekts sein. Die Funktion löscht das benannte
   Attribut, sofern das Objekt dies zulässt. So entspricht
   beispielsweise "delattr(x, 'foobar')" der Anweisung "del x.foobar".
   *name* muss kein Python-Bezeichner sein (siehe "setattr()").

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

   Erstellt ein neues Dictionary. Das Objekt "dict" ist die
   Dictionary-Klasse. Siehe auch Mapping-Typen – dict für die
   Dokumentation zu dieser Klasse.

   Für weitere Container siehe die eingebauten Klassen "list", "set"
   und "tuple" sowie das Modul "collections".

dir()
dir(object, /)

   Ohne Argumente wird die Liste der Namen im aktuellen lokalen
   Gültigkeitsbereich zurückgegeben. Mit einem Argument wird versucht,
   eine Liste der gültigen Attribute für dieses Objekt zurückzugeben.

   Wenn das Objekt eine Methode namens "__dir__()" besitzt, wird diese
   Methode aufgerufen und muss die Liste der Attribute zurückgeben.
   Dies ermöglicht es Objekten, die eine benutzerdefinierte Funktion
   "__getattr__()" oder "__getattribute__()" implementieren, die Art
   und Weise anzupassen, wie "dir()" ihre Attribute auflistet.“

   Wenn das Objekt kein "__dir__()" bereitstellt, versucht die
   Funktion, so viele Informationen wie möglich aus dem
   "__dict__"-Attribut des Objekts (sofern definiert) sowie aus dessen
   Typobjekt zu gewinnen. Die resultierende Liste ist nicht
   zwangsläufig vollständig und kann ungenau sein, wenn das Objekt
   über eine benutzerdefinierte "__getattr__()"-Methode verfügt.

   Der Standardmechanismus von "dir()" verhält sich bei verschiedenen
   Objekttypen unterschiedlich, da er versucht, die relevantesten –
   und nicht etwa die vollständigen – Informationen zu liefern:

   * Wenn es sich bei dem Objekt um ein Modulobjekt handelt, enthält
     die Liste die Namen der Attribute des Moduls.

   * Wenn es sich bei dem Objekt um ein Typ- oder Klassenobjekt
     handelt, enthält die Liste die Namen seiner Attribute sowie –
     rekursiv – die Namen der Attribute seiner Basisklassen.

   * Andernfalls enthält die Liste die Namen der Attribute des
     Objekts, die Namen der Attribute seiner Klasse sowie – rekursiv –
     die Namen der Attribute der Basisklassen seiner Klasse.

   Die resultierende Liste ist alphabetisch sortiert. Zum Beispiel:

   >>> import struct
   >>> dir()   # show the names in the module namespace
   ['__builtins__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   ...
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   Bemerkung:

     Da "dir()" in erster Linie als Hilfsmittel für die Verwendung an
     einer interaktiven Eingabeaufforderung gedacht ist, zielt die
     Funktion eher darauf ab, eine interessante Menge von Namen zu
     liefern, als eine streng oder konsistent definierte Menge; zudem
     kann sich ihr detailliertes Verhalten zwischen verschiedenen
     Releases ändern. So sind beispielsweise Metaklassen-Attribute
     nicht in der Ergebnisliste enthalten, wenn das Argument eine
     Klasse ist.

divmod(a, b, /)

   Nimmt zwei (nicht komplexe) Zahlen als Argumente entgegen und gibt
   ein Zahlenpaar zurück, das aus dem Quotienten und dem Rest der
   Ganzzahldivision besteht. Bei gemischten Operandentypen gelten die
   Regeln für binäre arithmetische Operatoren. Bei Ganzzahlen
   entspricht das Ergebnis "(a // b, a % b)". Bei Gleitkomma-zahlen
   lautet das Ergebnis "(q, a % b)", wobei *q* normalerweise
   "math.floor(a / b)" entspricht, aber auch um 1 kleiner sein kann.
   In jedem Fall liegt "q * b + a % b" sehr nahe bei *a*; ist "a % b"
   ungleich null, so hat es dasselbe Vorzeichen wie *b*, und es gilt
   "0 <= abs(a % b) < abs(b)".

enumerate(iterable, start=0)

   Gibt ein enumerate-Objekt zurück. *iterable* muss eine Sequenz, ein
   *Iterator* oder ein anderes Objekt sein, das Iteration unterstützt.
   Die "__next__()"-Methode des von "enumerate()" zurückgegebenen
   Iterators liefert ein Tupel, das einen Zähler (beginnend bei
   *start*, standardmäßig 0) und die durch Iteration über *iterable*
   erhaltenen Werte enthält.

   >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
   >>> list(enumerate(seasons))
   [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
   >>> list(enumerate(seasons, start=1))
   [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

   Gleichbedeutend mit:

      def enumerate(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)

   Parameter:
      * **source** ("str" | code object) -- Ein Python Ausdruck

      * **globals** ("dict" | "None") -- Der globale Namensraum
        (default: "None").

      * **locals** (*mapping* | "None") -- Der lokale Namensraum
        (default: "None").

   Rückgabe:
      Das Ergebnis des ausgewerteten Ausdrucks.

   Meldung:
      Syntaxfehler werden als Ausnahmen gemeldet.

   Warnung:

     Diese Funktion führt beliebigen Code aus. Der Aufruf mit nicht
     vertrauenswürdigen, benutzerdefinierten Eingaben führt zu
     Sicherheitslücken.

   Das Argument *source* wird als Python-Ausdruck geparst und
   ausgewertet (genauer gesagt als Ausdrucksliste), wobei die Mappings
   *globals* und *locals* als globaler bzw. lokaler Namensraum
   verwendet werden. Ist das Dictionary *globals* vorhanden und
   enthält keinen Wert für den Schlüssel "__builtins__", wird vor dem
   Parsen von *source* ein Verweis auf das Dictionary des eingebauten
   Moduls "builtins" unter diesem Schlüssel eingefügt. Das
   Überschreiben von "__builtins__" kann verwendet werden, um die
   verfügbaren Namen einzuschränken oder zu ändern, dies ist jedoch
   **kein** Sicherheitsmechanismus: Der ausgeführte Code kann
   weiterhin auf alle Builtins zugreifen. Wird das Mapping *locals*
   weggelassen, wird standardmäßig das Dictionary *globals* verwendet.
   Werden beide Mappings weggelassen, wird der Quelltext mit den
   *globals* und *locals* der Umgebung ausgeführt, in der "eval()"
   aufgerufen wird. Beachte, dass *eval()* nur dann Zugriff auf
   *verschachtelte Gültigkeitsbereiche* (nicht-lokale Variablen) in
   der umschließenden Umgebung hat, wenn diese bereits im
   Gültigkeitsbereich referenziert werden, der "eval()" aufruft (z. B.
   über eine "nonlocal"-Anweisung).

   Beispiel:

   >>> x = 1
   >>> eval('x+1')
   2

   >>> eval("1, 2")
   (1, 2)

   Diese Funktion kann auch verwendet werden, um beliebige Code-
   Objekte (wie etwa solche, die mit "compile()" erstellt wurden)
   auszuführen. Übergeben Sie in diesem Fall ein Code-Objekt anstelle
   einer Zeichenkette. Wenn das Code-Objekt mit "'exec'" als
   *mode*-Argument kompiliert wurde, ist der Rückgabewert von "eval()"
   "None".

   Hinweise: Die dynamische Ausführung von Anweisungen wird durch die
   Funktion "exec()" unterstützt. Die Funktionen "globals()" und
   "locals()" liefern das aktuelle globale beziehungsweise lokale
   Dictionary zurück; dies kann nützlich sein, um sie an "eval()" oder
   "exec()" weiterzugeben.

   Wenn die angegebene Quelle eine Zeichenkette ist, werden führende
   und nachstehende Leerzeichen sowie Tabulatoren entfernt.

   Siehe "ast.literal_eval()" für eine Funktion, um Zeichenketten mit
   Ausdrücken auszuwerten, die nur Literale enthalten.

   Löst ein Audit-Ereignis "exec" mit dem Code-Objekt als Argument
   aus. Es können auch Ereignisse zur Code-Kompilierung ausgelöst
   werden.

   Geändert in Version 3.13: Die Argumente *globals* und *locals*
   können nun als Schlüsselwortargumente übergeben werden.

   Geändert in Version 3.13: Die Semantik des Standard-Namensraums für
   lokale Variablen (*locals*) wurde wie für die eingebaute Funktion
   "locals()" beschrieben angepasst.

exec(source, /, globals=None, locals=None, *, closure=None)

   Warnung:

     Diese Funktion führt beliebigen Code aus. Der Aufruf mit nicht
     vertrauenswürdigen, benutzerdefinierten Eingaben führt zu
     Sicherheitslücken.

   Diese Funktion unterstützt die dynamische Ausführung von Python-
   Code. *source* muss entweder eine Zeichenkette oder ein Code-Objekt
   sein. Handelt es sich um eine Zeichenkette, so wird diese als eine
   Folge von Python-Anweisungen geparst und anschließend ausgeführt
   (sofern kein Syntaxfehler auftritt). [1] Handelt es sich um ein
   Code-Objekt, so wird dieses einfach ausgeführt. In jedem Fall muss
   der ausgeführte Code als Dateieingabe gültig sein (siehe den
   Abschnitt File input im Referenzhandbuch). Beachten Sie, dass die
   Anweisungen "nonlocal", "yield" und "return" auch innerhalb des an
   die Funktion "exec()" übergebenen Codes nicht außerhalb von
   Funktionsdefinitionen verwendet werden dürfen. Der Rückgabewert ist
   "None".

   In allen Fällen wird der Code im aktuellen Gültigkeitsbereich
   ausgeführt, wenn die optionalen Argumente weggelassen werden. Wird
   nur *globals* angegeben, muss es sich um ein Dictionary handeln
   (und nicht um eine Unterklasse davon), das sowohl für die globalen
   als auch für die lokalen Variablen verwendet wird. Werden sowohl
   *globals* als auch *locals* angegeben, so dienen sie jeweils als
   globale beziehungsweise lokale Variablen. Falls angegeben, kann
   *locals* ein beliebiges Mapping-Objekt sein. Beachten Sie, dass auf
   Modulebene globale und lokale Variablen dasselbe Dictionary
   darstellen.

   Bemerkung:

     Wenn „exec“ zwei separate Objekte als *globals* und *locals*
     erhält, wird der Code so ausgeführt, als wäre er in eine
     Klassendefinition eingebettet. Das bedeutet, dass im ausgeführten
     Code definierte Funktionen und Klassen nicht auf Variablen
     zugreifen können, die auf der obersten Ebene zugewiesen wurden
     (da diese Variablen der „obersten Ebene“ in einer
     Klassendefinition als Klassenvariablen behandelt werden).

   Enthält das Dictionary *globals* keinen Wert für den Schlüssel
   "__builtins__", wird ein Verweis auf das Dictionary des eingebauten
   Moduls "builtins" unter diesem Schlüssel eingefügt. Das
   Überschreiben von "__builtins__" kann verwendet werden, um die
   verfügbaren Namen einzuschränken oder zu ändern, dies ist jedoch
   **kein** Sicherheitsmechanismus: Der ausgeführte Code kann
   weiterhin auf alle Builtins zugreifen.

   Das Argument *closure* spezifiziert einen Closure – ein Tupel von
   Cell-Variablen. Es ist nur dann gültig, wenn das *Objekt* ein Code-
   Objekt ist, das *freie (Closure-)Variablen* enthält. Die Länge des
   Tupels muss exakt der Länge des Attributs "co_freevars" des Code-
   Objekts entsprechen.

   Löst ein Audit-Ereignis "exec" mit dem Code-Objekt als Argument
   aus. Es können auch Ereignisse zur Code-Kompilierung ausgelöst
   werden.

   Bemerkung:

     Die eingebauten Funktionen "globals()" und "locals()" geben den
     aktuellen globalen beziehungsweise lokalen Namensraum zurück;
     dies kann nützlich sein, um sie als zweites und drittes Argument
     an "exec()" zu übergeben.

   Bemerkung:

     Die Standard *locals* wirken wie für die Funktion "locals()"
     weiter unten beschrieben. Übergeben Sie ein explizites
     *locals*-Dictionary, wenn Sie die Auswirkungen des Codes auf die
     *locals* sehen möchten, nachdem die Funktion "exec()"
     zurückgekehrt ist.

   Geändert in Version 3.11: Der Parameter *closure* wurde
   hinzugefügt.

   Geändert in Version 3.13: Die Argumente *globals* und *locals*
   können nun als Schlüsselwortargumente übergeben werden.

   Geändert in Version 3.13: Die Semantik des Standard-Namensraums für
   lokale Variablen (*locals*) wurde wie für die eingebaute Funktion
   "locals()" beschrieben angepasst.

filter(function, iterable, /)

   Erstellt einen Iterator aus denjenigen Elementen von *iterable*,
   für die *function* wahr ergibt. *iterable* kann entweder eine
   Sequenz, ein Container, der Iteration unterstützt, oder ein
   Iterator sein. Ist *function* "None", so wird die
   Identitätsfunktion angenommen; das heißt, alle Elemente von
   *iterable*, die „falsch“ sind, werden entfernt.

   Beachte, dass "filter(function, iterable)" dem Generatorausdruck
   "(item for item in iterable if function(item))" entspricht, wenn
   "function" nicht "None" ist, und "(item for item in iterable if
   item)", wenn "function" "None" ist.

   Siehe "itertools.filterfalse()" für die komplementäre Funktion, die
   Elemente von *iterable* zurückgibt, für die *function* falsch ist.

class float(number=0.0, /)
class float(string, /)

   Geben Sie eine Gleitkommazahl zurück, die aus einer Zahl oder einer
   Zeichenkette erstellt wurde.

   Beispiele:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   Wenn das Argument eine Zeichenkette ist, muss sie eine Dezimalzahl
   enthalten, der optional ein Vorzeichen vorangestellt ist und die
   optional von Leerzeichen umgeben sein kann. Das optionale
   Vorzeichen kann "'+'" oder "'-'" sein; ein "'+'"-Zeichen hat keinen
   Einfluss auf den resultierenden Wert. Das Argument kann auch eine
   Zeichenkette sein, die NaN (Not-a-Number) oder positive bzw.
   negative Unendlichkeit darstellt. Genauer gesagt muss die Eingabe –
   nach Entfernung führender und nachfolgender Leerzeichen – der
   Produktionsregel "floatvalue" in der folgenden Grammatik
   entsprechen:“

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

   Die Groß-/Kleinschreibung spielt keine Rolle; so sind
   beispielsweise "inf", "Inf", "INFINITY" und "iNfINity" allesamt
   zulässige Schreibweisen für positive Unendlichkeit.

   Handelt es sich bei dem Argument andernfalls um eine Ganzzahl oder
   eine Gleitkommazahl, so wird eine Gleitkommazahl mit demselben Wert
   (innerhalb der Gleitkommapräzision von Python) zurückgegeben. Liegt
   das Argument außerhalb des Wertebereichs eines Python-Floats, wird
   ein "OverflowError" ausgelöst.

   Für ein allgemeines Python-Objekt "x" delegiert "float(x)" an
   "x.__float__()". Wenn "__float__()" nicht definiert ist, fällt es
   „zurück zu "__index__()".“

   Wenn kein Argument angegeben wird, wird "0.0" zurückgegeben.

   Der Typ „float“ wird in Numerische Typen --- int, float, complex
   beschrieben.

   Geändert in Version 3.6: Die Gruppierung von Ziffern mittels
   Unterstrichen, wie bei Code-Literalen, ist zulässig.

   Geändert in Version 3.7: Der Parameter ist jetzt rein
   positionsgebunden.

   Geändert in Version 3.8: Fällt auf "__index__()" zurück, wenn
   "__float__()" nicht definiert ist.

format(value, format_spec='', /)

   Wandelt einen *Wert* in eine "formatierte" Darstellung um, wie
   durch *format_spec* festgelegt. Die Interpretation von
   *format_spec* hängt vom Typ des Arguments *Wert* ab; es gibt jedoch
   eine Standard-Formatierungssyntax, die von den meisten eingebauten
   Typen verwendet wird: Formatspezifikation Mini-Sprache.

   Die Standard *format_spec* ist eine leere Zeichenkette, was
   normalerweise denselben Effekt hat wie der Aufruf von "str(value)".

   Ein Aufruf von "format(value, format_spec)" wird in
   "type(value).__format__(value, format_spec)" übersetzt, wodurch das
   Instanz-Dictionary bei der Suche nach der "__format__()"-Methode
   des Werts umgangen wird. Eine "TypeError"-Ausnahme wird ausgelöst,
   wenn die Methodensuche "object" erreicht und *format_spec* nicht
   leer ist, oder wenn entweder *format_spec* oder der Rückgabewert
   keine Zeichenkette ist.

   Geändert in Version 3.4: "object().__format__(format_spec)" löst
   "TypeError" aus, wenn *format_spec* keine leere Zeichenkette ist.

class frozenset(iterable=(), /)

   Gibt ein neues Objekt "frozenset" zurück, optional mit Elementen
   aus *iterable*. "frozenset" ist eine eingebaute Klasse. Siehe auch
   Mengen-Typen – set, frozenset für die Dokumentation zu dieser
   Klasse.

   Für weitere Container siehe die eingebauten Klassen "set", "list",
   "tuple" und "dict" sowie das Modul "collections".

getattr(object, name, /)
getattr(object, name, default, /)

   Gibt den Wert des benannten Attributs von *object* zurück. *name*
   muss ein String sein. Wenn der String der Name eines der Attribute
   des Objekts ist, ist das Ergebnis der Wert dieses Attributs. Zum
   Beispiel entspricht "getattr(x, 'foobar')" dem Ausdruck "x.foobar".
   Existiert das benannte Attribut nicht, wird *default*
   zurückgegeben, sofern angegeben; andernfalls wird ein
   "AttributeError" ausgelöst. *name* muss kein Python-Bezeichner sein
   (siehe "setattr()").

   Bemerkung:

     Da Private Name Mangling zur Kompilierzeit erfolgt, muss der Name
     eines privaten Attributs (Attribute mit zwei führenden
     Unterstrichen) manuell umgewandelt werden, um es mittels
     "getattr()" abrufen zu können.

globals()

   Geben Sie das Dictionary zurück, das den Namespace des aktuellen
   Moduls implementiert. Bei Code innerhalb von Funktionen wird dieses
   bei der Definition der Funktion festgelegt und bleibt unverändert,
   unabhängig davon, von wo aus die Funktion aufgerufen wird.

hasattr(object, name, /)

   Die Argumente sind ein Objekt und ein String. Das Ergebnis ist
   "True", wenn der String der Name eines Attributs des Objekts ist,
   andernfalls "False". (Dies wird implementiert, indem
   "getattr(object, name)" aufgerufen und geprüft wird, ob ein
   "AttributeError" ausgelöst wird oder nicht.)

hash(object, /)

   Gibt den Hash-Wert des Objekts zurück (sofern es einen besitzt).
   Hash-Werte sind Ganzzahlen. Sie dienen dazu, Dictionary-Schlüssel
   bei einer Suche im Dictionary schnell zu vergleichen. Numerische
   Werte, die als gleich gelten, haben denselben Hash-Wert (selbst
   wenn sie unterschiedlichen Typs sind, wie es bei 1 und 1.0 der Fall
   ist).

   Bemerkung:

     Beachte bei Objekten mit benutzerdefinierten
     "__hash__()"-Methoden, dass "hash()" den Rückgabewert basierend
     auf der Bitbreite des Host-Rechners abschneidet.

help()
help(request)

   Ruft das integrierte Hilfesystem auf. (Diese Funktion ist für die
   interaktive Nutzung vorgesehen.) Wenn kein Argument angegeben wird,
   startet das interaktive Hilfesystem auf der Interpreterkonsole.
   Wenn das Argument eine Zeichenkette ist, wird diese als Name eines
   Moduls, einer Funktion, einer Klasse, einer Methode, eines
   Schlüsselworts oder eines Dokumentationsthemas nachgeschlagen und
   eine Hilfeseite auf der Konsole ausgegeben. Wenn das Argument ein
   anderes Objekt ist, wird eine Hilfeseite zu diesem Objekt
   generiert.

   Beachten Sie: Wenn beim Aufruf von "help()" ein Schrägstrich (/) in
   der Parameterliste einer Funktion erscheint, bedeutet dies, dass
   die Parameter vor dem Schrägstrich reine Positionsparameter sind.
   Weitere Informationen finden Sie unter dem FAQ-Eintrag zu reinen
   Positionsparametern.

   Diese Funktion wird vom Modul "site" dem eingebauten Namensraum
   hinzugefügt.

   Geändert in Version 3.4: Änderungen an "pydoc" und "inspect" führen
   dazu, dass die für aufrufbare Objekte (Callables) gemeldeten
   Signaturen nun umfassender und konsistenter sind.

hex(integer, /)

   Wandelt eine Ganzzahl in eine hexadezimale Zeichenkette in
   Kleinbuchstaben mit dem Präfix „0x“ um. Wenn *integer* kein Python-
   Objekt vom Typ "int" ist, muss es eine "__index__()"-Methode
   definieren, die eine Ganzzahl zurückgibt. Einige Beispiele:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

   Wenn Sie eine Ganzzahl in eine hexadezimale Zeichenkette in Groß-
   oder Kleinbuchstaben umwandeln möchten – wahlweise mit oder ohne
   Präfix –, können Sie eine der folgenden Methoden verwenden:

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   Weitere Informationen findest du unter "format()".

   Siehe auch "int()" für die Umwandlung einer Hexadezimalzeichenkette
   in eine Ganzzahl unter Verwendung der Basis 16.

   Bemerkung:

     Um eine hexadezimale String-Darstellung für einen Float-Wert zu
     erhalten, verwenden Sie die Methode "float.hex()".

id(object, /)

   Gibt die "Identität" eines Objekts zurück. Dies ist eine Ganzzahl,
   die garantiert eindeutig ist und während der Lebensdauer des
   Objekts konstant bleibt. Zwei Objekte, deren Lebensdauern sich
   nicht überschneiden, können denselben "id()"-Wert haben.

   Dies ist die Adresse des Objekts im Speicher.

   Löst ein Audit-Ereignis "builtins.id" mit dem Argument "id" aus.

input()
input(prompt, /)

   Wenn das Argument *prompt* angegeben ist, wird es ohne
   abschließendes Zeilenumbruchzeichen auf die Standardausgabe
   geschrieben. Die Funktion liest dann eine Zeile von der Eingabe,
   wandelt sie in eine Zeichenkette um (wobei ein abschließendes
   Zeilenumbruchzeichen entfernt wird) und gibt diese zurück. Beim
   Erreichen des Dateiendes (EOF) wird "EOFError" ausgelöst.
   Beispiel::“

      >>> s = input('--> ')
      --> Monty Python's Flying Circus
      >>> s
      "Monty Python's Flying Circus"

   Wenn das Modul "readline" geladen wurde, verwendet "input()" es, um
   umfangreiche Funktionen zur Zeilenbearbeitung und
   Historienverwaltung bereitzustellen.

   Löst ein Audit-Ereignis "builtins.input" mit dem Argument "prompt"
   aus, bevor die Eingabe gelesen wird

   Löst ein Audit-Ereignis "builtins.input/result" mit dem Ergebnis
   nach erfolgreichem Einlesen der Eingabe aus.

class int(number=0, /)
class int(string, /, base=10)

   Gibt ein Integer-Objekt zurück, das aus einer Zahl oder einer
   Zeichenkette erstellt wurde, oder gibt "0" zurück, wenn keine
   Argumente angegeben sind.

   Beispiele:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   If the argument defines "__int__()", "int(x)" returns
   "x.__int__()".  If the argument defines "__index__()", it returns
   "x.__index__()".  If the argument defines "__trunc__()", it returns
   "x.__trunc__()". For floating-point numbers, this truncates towards
   zero.

   Wenn das Argument keine Zahl ist oder wenn *base* angegeben wird,
   muss es sich um eine Zeichenkette, "bytes" oder "bytearray" Instanz
   handeln, die eine Ganzzahl zur Basis *base* darstellt. Optional
   kann der Zeichenkette ein "+" oder "-" vorangestellt sein (ohne
   Leerzeichen dazwischen); zudem kann sie führende Nullen aufweisen,
   von Leerzeichen umgeben sein und einzelne Unterstriche zwischen den
   Ziffern enthalten.

   Eine Zeichenkette, die eine Ganzzahl zur Basis *n* darstellt,
   besteht aus Ziffern, von denen jede einen Wert von 0 bis n-1
   repräsentiert. Die Werte 0 bis 9 können durch jede beliebige
   Unicode-Dezimalziffer dargestellt werden. Die Werte 10 bis 35
   lassen sich durch "a" bis "z" (oder "A" bis "Z") ausdrücken. Die
   Standardbasis ist 10. Zulässige Basen sind 0 sowie der Bereich von
   2 bis 36. Zeichenketten für die Basen 2, 8 und 16 können optional
   mit einem Präfix wie "0b"/"0B", "0o"/"0O" oder "0x"/"0X" versehen
   werden, ähnlich wie bei Ganzzahl-Literalen im Quellcode. Bei der
   Basis 0 wird die Zeichenkette ähnlich wie ein Ganzzahl-Literal im
   Quellcode interpretiert, wobei die tatsächliche Basis 2, 8, 10 oder
   16 durch das Präfix bestimmt wird. Zudem sind bei der Basis 0 keine
   führenden Nullen zulässig: "int('010', 0)" ist ungültig, während
   "int('010')" und "int('010', 8)" zulässig sind.

   Der Ganzzahltyp wird in Numerische Typen --- int, float, complex
   beschrieben.

   Geändert in Version 3.4: Wenn *base* keine Instanz von "int" ist
   und das *base*-Objekt über eine "base.__index__"-Methode verfügt,
   wird diese Methode aufgerufen, um eine Ganzzahl für die Basis zu
   erhalten. In früheren Versionen wurde "base.__int__" anstelle von
   "base.__index__" verwendet.

   Geändert in Version 3.6: Die Gruppierung von Ziffern mittels
   Unterstrichen, wie bei Code-Literalen, ist zulässig.

   Geändert in Version 3.7: Der erste Parameter ist nun rein
   positional.

   Geändert in Version 3.8: Greift auf "__index__()" zurück, wenn
   "__int__()" nicht definiert ist.

   Geändert in Version 3.11: The delegation to "__trunc__()" is
   deprecated.

   Geändert in Version 3.11: Die Länge von Zeichenketten bei der
   Umwandlung in oder aus einem "int" kann begrenzt werden, um Denial-
   of-Service-Angriffe zu verhindern. Es wird ein "ValueError"
   ausgelöst, wenn das Limit bei der Umwandlung einer Zeichenkette in
   ein "int" überschritten wird oder wenn die Umwandlung eines "int"
   in eine Zeichenkette das Limit überschreiten würde. Siehe die
   Dokumentation zur Längenbegrenzung bei der Umwandlung von
   Ganzzahlen in Zeichenketten.

isinstance(object, classinfo, /)

   Gibt "True" zurück, wenn das Argument *object* eine Instanz des
   Arguments *classinfo* oder einer (direkten, indirekten oder
   *virtuellen*) Unterklasse davon ist. Wenn *object* kein Objekt des
   angegebenen Typs ist, gibt die Funktion stets "False" zurück. Wenn
   *classinfo* ein Tupel von Typ-Objekten (oder rekursiv weiteren
   solchen Tupeln) oder eine Union-Typ aus mehreren Typen ist, wird
   "True" zurückgegeben, falls *object* eine Instanz eines dieser
   Typen ist. Wenn *classinfo* weder ein Typ noch ein Tupel von Typen
   (und solchen Tupeln) ist, wird eine "TypeError"-Ausnahme ausgelöst.
   Eine "TypeError"-Ausnahme wird für einen ungültigen Typ
   möglicherweise nicht ausgelöst, wenn eine frühere Überprüfung
   erfolgreich ist.

   Geändert in Version 3.10: *classinfo* kann eine Union-Typ sein.

issubclass(class, classinfo, /)

   Gibt "True" zurück, wenn *class* eine Unterklasse (direkt, indirekt
   oder *virtuell*) von *classinfo* ist. Eine Klasse gilt als
   Unterklasse ihrer selbst. *classinfo* kann ein Tupel von
   Klassenobjekten (oder rekursiv weitere solcher Tupel) oder eine
   Union-Typ sein; in diesem Fall wird "True" zurückgegeben, wenn
   *class* eine Unterklasse irgendeines Eintrags in *classinfo* ist.
   In allen anderen Fällen wird eine "TypeError"-Ausnahme ausgelöst.

   Geändert in Version 3.10: *classinfo* kann eine Union-Typ sein.

iter(iterable, /)
iter(callable, sentinel, /)

   Gibt ein *Iterator*-Objekt zurück. Das erste Argument wird je nach
   Vorhandensein des zweiten Arguments sehr unterschiedlich
   interpretiert. Ohne ein zweites Argument muss das einzige Argument
   ein Container-Objekt sein, das das *iterable*-Protokoll (die
   Methode "__iter__()") oder das Sequenzprotokoll (die Methode
   "__getitem__()" mit ganzzahligen Argumenten beginnend bei "0")
   unterstützt. Wird keines dieser Protokolle unterstützt, so wird ein
   "TypeError" ausgelöst. Wenn das zweite Argument, *sentinel*,
   angegeben ist, muss das erste Argument ein aufrufbares Objekt
   (*callable*) sein. Der in diesem Fall erzeugte Iterator ruft bei
   jedem Aufruf seiner Methode "__next__()" das aufrufbare Objekt ohne
   Argumente auf; entspricht der Rückgabewert *sentinel*, so wird
   "StopIteration" ausgelöst, andernfalls wird der Wert zurückgegeben.

   Siehe auch Iterator-Typen.

   Eine nützliche Anwendung der zweiten Form von "iter()" ist die
   Erstellung eines Block-Readers. Zum Beispiel das Lesen von Blöcken
   fester Größe aus einer binären Datenbankdatei bis zum Erreichen des
   Dateiende:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(object, /)

   Gibt die Länge (die Anzahl der Elemente) eines Objekts zurück. Das
   Argument kann eine Sequenz (wie etwa ein String, Bytes, ein Tupel,
   eine Liste oder ein Range-Objekt) oder eine Collection (wie etwa
   ein Dictionary, ein Set oder ein Frozen Set) sein.

   "len" löst bei Längen größer als "sys.maxsize" eine
   "OverflowError"-Ausnahme aus.Z. B. "range(2 ** 100)".

class list(iterable=(), /)

   Anstatt eine Funktion zu sein, ist "list" eigentlich ein
   veränderbarer Sequenztyp, wie in Listen und Sequenztypen – list,
   tuple, range dokumentiert.

locals()

   Gibt ein Mapping-Objekt zurück, das die aktuelle lokale
   Symboltabelle repräsentiert, wobei die Variablennamen als Schlüssel
   und die aktuell daran gebundenen Referenzen als Werte dienen.

   Auf Modulebene sowie bei der Verwendung von "exec()" oder "eval()"
   mit einem einzigen Namensraum gibt diese Funktion denselben
   Namensraum zurück wie "globals()".

   Auf Klassenebene gibt es den Namensraum zurück, der an den
   Metaklassen-Konstruktor übergeben wird.

   Bei der Verwendung von "exec()" oder "eval()" mit separaten lokalen
   und globalen Argumenten wird der lokale Namensraum zurückgegeben,
   der an den Funktionsaufruf übergeben wurde.

   In allen oben genannten Fällen gibt jeder Aufruf von "locals()" in
   einem bestimmten Ausführungs-Frame *dasselbe* Mapping-Objekt
   zurück. Änderungen, die über das von "locals()" zurückgegebene
   Mapping-Objekt vorgenommen werden, zeigen sich als zugewiesene, neu
   zugewiesene oder gelöschte lokale Variablen; umgekehrt wirken sich
   Zuweisungen, Neuzuweisungen oder das Löschen lokaler Variablen
   unmittelbar auf den Inhalt des zurückgegebenen Mapping-Objekts aus.

   In einem *optimierten Gültigkeitsbereich* (einschließlich
   Funktionen, Generatoren und Coroutinen) liefert jeder Aufruf von
   "locals()" stattdessen ein neues Dictionary zurück, das die
   aktuellen Bindungen der lokalen Variablen der Funktion sowie
   etwaige nonlocal-Zellreferenzen enthält. In diesem Fall werden
   Änderungen an Namensbindungen, die über das zurückgegebene
   Dictionary vorgenommen werden, *nicht* in die entsprechenden
   lokalen Variablen oder nonlocal-Zellreferenzen zurückgeschrieben;
   zudem hat das Zuweisen, Neuzuweisen oder Löschen lokaler Variablen
   und nonlocal-Zellreferenzen *keine* Auswirkungen auf den Inhalt
   zuvor zurückgegebener Dictionaries.

   Der Aufruf von "locals()" als Teil einer Listen-Abstraktion
   (comprehension) in einer Funktion, einem Generator oder einer
   Coroutine entspricht dem Aufruf im umschließenden
   Gültigkeitsbereich, mit der Ausnahme, dass die initialisierten
   Iterationsvariablen der Listen-Abstraktion (comprehension)
   einbezogen werden. In anderen Gültigkeitsbereichen verhält es sich
   so, als würde die Listen-Abstraktion (comprehension) als
   verschachtelte Funktion ausgeführt.

   Der Aufruf von "locals()" als Teil eines Generatorausdrucks ist
   gleichbedeutend mit dem Aufruf innerhalb einer verschachtelten
   Generatorfunktion.

   Geändert in Version 3.12: Das Verhalten von "locals()" in einer
   Listen-Abstraktion (comprehension) wurde wie in **PEP 709**
   beschrieben aktualisiert.

   Geändert in Version 3.13: Im Rahmen von **PEP 667** ist nun die
   Semantik für die Veränderung der von dieser Funktion
   zurückgegebenen Mapping-Objekte definiert. Das Verhalten in
   *optimierten Gültigkeitsbereichen* entspricht nun der obigen
   Beschreibung. Abgesehen von dieser Definition bleibt das Verhalten
   in anderen Gültigkeitsbereichen gegenüber früheren Versionen
   unverändert.

map(function, iterable, *iterables)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterables*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  For cases where the function inputs are already
   arranged into argument tuples, see "itertools.starmap()".

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

   Gibt das größte Element eines iterierbaren Objekts oder das größte
   von zwei oder mehr Argumenten zurück.

   Wird ein einzelnes Positionsargument übergeben, so muss es sich um
   ein *iterable* handeln. Das größte Element des Iterables wird
   zurückgegeben. Werden zwei oder mehr Positionsargumente übergeben,
   so wird das größte der Positionsargumente zurückgegeben.

   Es gibt zwei optionale Argumente, die nur als
   Schlüsselwortargumente übergeben werden können. Das Argument *key*
   legt eine Sortierfunktion mit einem Argument fest, wie sie auch bei
   "list.sort()" verwendet wird. Das Argument *default* gibt ein
   Objekt an, das zurückgegeben wird, falls das übergebene Iterable
   leer ist. Ist das Iterable leer und wird kein *default*-Wert
   angegeben, so wird ein "ValueError" ausgelöst.

   Wenn mehrere Elemente maximal sind, gibt die Funktion das erste
   zurück, auf das sie stößt. Dies steht im Einklang mit anderen
   Werkzeugen, die die Sortierstabilität bewahren, wie etwa
   "sorted(iterable, key=keyfunc, reverse=True)[0]" und
   "heapq.nlargest(1, iterable, key=keyfunc)".“

   Geändert in Version 3.4: Der *default*-Parameter (nur als Keyword-
   Argument verwendbar) wurde hinzugefügt.

   Geändert in Version 3.8: Der *Schlüssel* kann "None" sein.

class memoryview(object)

   Gibt ein aus dem angegebenen Argument erstelltes "memory-
   View"-Objekt zurück. Siehe Memory-Views für weitere Informationen.

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

   Geben Sie das kleinste Element eines iterierbaren Objekts oder das
   kleinste von zwei oder mehr Argumenten zurück.

   Wird ein einzelnes Positionsargument übergeben, so muss es sich um
   ein *Iterable* handeln. Das kleinste Element des Iterables wird
   zurückgegeben. Werden zwei oder mehr Positionsargumente übergeben,
   so wird das kleinste der Positionsargumente zurückgegeben.

   Es gibt zwei optionale Argumente, die nur als
   Schlüsselwortargumente übergeben werden können. Das Argument *key*
   legt eine Sortierfunktion mit einem Argument fest, wie sie auch bei
   "list.sort()" verwendet wird. Das Argument *default* gibt ein
   Objekt an, das zurückgegeben wird, falls das übergebene Iterable
   leer ist. Ist das Iterable leer und wird kein *default*-Wert
   angegeben, so wird ein "ValueError" ausgelöst.

   Wenn mehrere Elemente das Minimum darstellen, gibt die Funktion das
   erste zurück, auf das sie stößt. Dies steht im Einklang mit anderen
   Werkzeugen, die die Sortierstabilität wahren, wie etwa
   "sorted(iterable, key=keyfunc)[0]" und "heapq.nsmallest(1,
   iterable, key=keyfunc)".“

   Geändert in Version 3.4: Der *default*-Parameter (nur als Keyword-
   Argument verwendbar) wurde hinzugefügt.

   Geändert in Version 3.8: Der *Schlüssel* kann "None" sein.

next(iterator, /)
next(iterator, default, /)

   Retrieve the next item from the *iterator* by calling its
   "__next__()" method.  If *default* is given, it is returned if the
   iterator is exhausted, otherwise "StopIteration" is raised.

class object

   Dies ist die oberste Basisklasse aller anderen Klassen. Sie verfügt
   über Methoden, die allen Instanzen von Python-Klassen gemeinsam
   sind. Beim Aufruf des Konstruktors wird ein neues,
   eigenschaftsloses Objekt zurückgegeben. Der Konstruktor akzeptiert
   keine Argumente.

   Bemerkung:

     Instanzen von "object" besitzen *keine* "__dict__"-Attribute;
     daher können Sie einer Instanz von "object" keine beliebigen
     Attribute zuweisen.

oct(integer, /)

   Wandelt eine Ganzzahl in einen Oktal-String mit dem Präfix "0o" um.
   Das Ergebnis ist ein gültiger Python-Ausdruck. Wenn *integer* kein
   Python "int" Objekt ist, muss es eine "__index__()"-Methode
   definieren, die eine Ganzzahl zurückgibt. Zum Beispiel:

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   Wenn du eine Ganzzahl mit oder ohne das Präfix „0o“ in eine
   Oktalzeichenkette umwandeln möchtest, kannst du eine der folgenden
   Möglichkeiten nutzen.

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   Weitere Informationen findest du unter "format()".

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   Öffnet *file* und gibt ein entsprechendes *Dateiobjekt* zurück.
   Wenn die Datei nicht geöffnet werden kann, wird ein "OSError"
   ausgelöst. Weitere Beispiele für die Verwendung dieser Funktion
   finden Sie unter Dateien lesen und schreiben.

   *file* ist ein *pfadartiges Objekt* (path-like object), das den
   Pfadnamen (absolut oder relativ zum aktuellen Arbeitsverzeichnis)
   der zu öffnenden Datei angibt, oder ein ganzzahliger
   Dateideskriptor der zu umschließenden Datei. (Wird ein
   Dateideskriptor angegeben, so wird dieser geschlossen, wenn das
   zurückgegebene E/A-Objekt geschlossen wird, es sei denn, *closefd*
   ist auf "False" gesetzt.)

   *mode* ist eine optionale Zeichenkette, die den Modus angibt, in
   dem die Datei geöffnet wird. Der Standardwert ist "'r'", was das
   Öffnen zum Lesen im Textmodus bedeutet. Weitere gebräuchliche Werte
   sind "'w'" zum Schreiben (wobei die Datei geleert wird, falls sie
   bereits existiert), "'x'" für die exklusive Erstellung und "'a'"
   zum Anhängen (was auf *einigen* Unix-Systemen bedeutet, dass *alle*
   Schreibvorgänge Daten an das Ende der Datei anhängen, unabhängig
   von der aktuellen Schreib-/Leseposition). Wenn im Textmodus kein
   *encoding* angegeben wird, hängt die verwendete Zeichenkodierung
   vom Betriebssystem ab: "locale.getencoding()" wird aufgerufen, um
   die Kodierung der aktuellen Locale zu ermitteln. (Verwenden Sie für
   das Lesen und Schreiben von Rohbytes den Binärmodus und lassen Sie
   *encoding* weg.) Die verfügbaren Modi sind:

   +-----------+-----------------------------------------------------------------+
   | Zeichen   | <Bedeutung                                                      |
   |===========|=================================================================|
   | "'r'"     | zum Lesen öffnen (Standardwert)                                 |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | zum Schreiben öffnen und die Datei dabei zunächst auf die Länge |
   |           | Null kürzen                                                     |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | zum exklusiven Erstellen öffnen; schlägt fehl, wenn die Datei   |
   |           | bereits existiert                                               |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | zum Schreiben öffnen; an das Ende der Datei anhängen, falls     |
   |           | diese existiert                                                 |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | Binärmodus                                                      |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | Textmodus (default)                                             |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | zum Aktualisieren öffnen (Lesen und Schreiben)                  |
   +-----------+-----------------------------------------------------------------+

   Der Standardmodus ist "'r'" (zum Lesen von Text geöffnet, ein
   Synonym für "'rt'").Die Modi "'w+'" und "'w+b'" öffnen und kürzen
   die Datei. Die Modi "'r+'" und "'r+b‘" öffnet die Datei ohne
   Kürzung.“

   Wie in der Overview erwähnt, unterscheidet Python zwischen Binär-
   und Text-E/A. Dateien, die im Binärmodus geöffnet werden (wobei das
   Argument *mode* ein "'b'" enthält), geben ihren Inhalt als
   "bytes"-Objekte ohne jegliche Dekodierung zurück. Im Textmodus (der
   Standardeinstellung oder wenn das Argument *mode* ein "'t'"
   enthält) wird der Dateiinhalt als "str" zurückgegeben, wobei die
   Bytes zuvor mithilfe einer plattformabhängigen Kodierung oder –
   falls angegeben – mithilfe des spezifizierten *encoding* dekodiert
   wurden.

   Bemerkung:

     Python ist nicht von den Eigenschaften des zugrundeliegenden
     Betriebssystems von Textdateien abhängig; die gesamte
     Verarbeitung erfolgt durch Python selbst und ist daher
     plattformunabhängig.

   *buffering* ist eine optionale Ganzzahl, die zur Festlegung der
   Pufferungsstrategie dient. Übergeben Sie 0, um die Pufferung zu
   deaktivieren (nur im Binärmodus zulässig), 1, um Zeilenpufferung zu
   wählen (nur beim Schreiben im Textmodus verwendbar), und eine
   Ganzzahl > 1, um die Größe eines Puffers fester Größe in Bytes
   anzugeben. Beachten Sie, dass die Angabe einer Puffergröße auf
   diese Weise für gepufferte Binär-E/A gilt, während "TextIOWrapper"
   (d. h. mit "mode='r+'" geöffnete Dateien) eine andere Pufferung
   verwendet. Um die Pufferung in "TextIOWrapper" zu deaktivieren,
   können Sie das Flag "write_through" für
   "io.TextIOWrapper.reconfigure()" verwenden. Wenn kein
   *buffering*-Argument angegeben wird, funktioniert die Standard-
   Pufferungsstrategie wie folgt:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

   * "Interaktive" Textdateien (Dateien, für die "isatty()" "True"
     zurückgibt) verwenden Zeilenpufferung. Andere Textdateien
     verwenden das für Binärdateien beschriebene Verfahren.

   *encoding* ist der Name der Zeichenkodierung, die zum Dekodieren
   oder Kodieren der Datei verwendet wird. Dies sollte nur im
   Textmodus verwendet werden. Die Standardkodierung ist
   plattformabhängig (entsprechend dem Rückgabewert von
   "locale.getencoding()"), es kann jedoch jede von Python
   unterstützte *Textkodierung* verwendet werden. Eine Liste der
   unterstützten Kodierungen finden Sie im Modul "codecs".

   *errors* ist eine optionale Zeichenkette, die festlegt, wie mit
   Fehlern bei der Kodierung und Dekodierung umgegangen werden soll –
   dies kann nicht im Binärmodus verwendet werden. Es stehen
   verschiedene Standard-Fehlerbehandlungsroutinen zur Verfügung
   (aufgeführt unter Error Handlers), wobei auch jeder Name für eine
   Fehlerbehandlungsroutine zulässig ist, der mit
   "codecs.register_error()" registriert wurde. Zu den Standardnamen
   gehören:“

   * "'strict'", um eine "ValueError"-Ausnahme auszulösen, wenn ein
     Kodierungsfehler auftritt. Der Standardwert "None" hat dieselbe
     Wirkung.

   * "'ignore'" ignoriert Fehler. Beachten Sie, dass das Ignorieren
     von Kodierungsfehlern zu Datenverlust führen kann.“

   * "'replace'" bewirkt, dass an Stellen mit fehlerhaften Daten ein
     Ersetzungszeichen (wie etwa "'?'") eingefügt wird.“

   * "'surrogateescape'" stellt fehlerhafte Bytes als reduzierte
     Ersatz-Codeeinheiten  (low surrogate code) im Bereich von U+DC80
     bis U+DCFF dar. Diese Ersatz-Codeeinheiten werden beim Schreiben
     von Daten – sofern der Fehlerbehandler "surrogateescape"
     verwendet wird – wieder in die ursprünglichen Bytes
     zurückgewandelt. Dies ist nützlich für die Verarbeitung von
     Dateien mit unbekannter Zeichenkodierung.

   * "'xmlcharrefreplace'" wird nur beim Schreiben in eine Datei
     unterstützt. Zeichen, die von der Zeichenkodierung nicht
     unterstützt werden, werden durch die entsprechende XML-
     Zeichenreferenz "&#*nnn*;" ersetzt.“

   * "'backslashreplace'" ersetzt fehlerhafte Daten durch Pythons
     Escape-Sequenzen mit Backslash.“

   * "'namereplace'" (wird ebenfalls nur beim Schreiben unterstützt)
     ersetzt nicht unterstützte Zeichen durch "\N{...}"-Escape-
     Sequenzen.“

   *newline* legt fest, wie Zeilenumbruchzeichen aus dem Datenstrom
   verarbeitet werden. Es kann die Werte "None", "''", "'\n'", "'\r'"
   oder "'\r\n'" annehmen. Die Funktionsweise ist wie folgt:

   * Beim Lesen von Eingaben aus dem Stream wird der Modus für
     universelle Zeilenumbrüche aktiviert, wenn *newline* den Wert
     "None" hat. Zeilen in der Eingabe können mit "'\n'", "'\r'" oder
     "'\r\n'" enden; diese werden in "'\n'" umgewandelt, bevor sie an
     den Aufrufer zurückgegeben werden. Hat *newline* den Wert "''",
     ist der Modus für universelle Zeilenumbrüche ebenfalls aktiviert,
     jedoch werden die Zeilenenden unverändert an den Aufrufer
     zurückgegeben. Bei allen anderen zulässigen Werten werden
     Eingabezeilen ausschließlich durch die angegebene Zeichenkette
     begrenzt, und das Zeilenende wird unverändert an den Aufrufer
     zurückgegeben.

   * Beim Schreiben von Ausgaben in den Stream werden – sofern
     *newline* den Wert "None" hat – alle geschriebenen "'\n'"-Zeichen
     in das systemübliche Zeilenumbruchzeichen "os.linesep"
     umgewandelt. Ist *newline* gleich "''" oder "'\n'", findet keine
     Umwandlung statt. Nimmt *newline* einen der anderen zulässigen
     Werte an, werden alle geschriebenen "'\n'"-Zeichen in die
     angegebene Zeichenkette umgewandelt.

   Wenn *closefd* auf "False" gesetzt ist und anstelle eines
   Dateinamens ein Dateideskriptor übergeben wurde, bleibt der
   zugrundeliegende Dateideskriptor beim Schließen der Datei geöffnet.
   Wird ein Dateiname angegeben, muss *closefd* auf "True" (dem
   Standardwert) stehen; andernfalls wird ein Fehler ausgelöst.

   Ein benutzerdefinierter Opener kann verwendet werden, indem ein
   aufrufbares Objekt als *opener* übergeben wird. Der
   zugrundeliegende Dateideskriptor für das Dateiobjekt wird dann
   durch den Aufruf von *opener* mit (*file*, *flags*) ermittelt.
   *opener* muss einen offenen Dateideskriptor zurückgeben (die
   Übergabe von "os.open" als *opener* führt zu einer Funktionalität,
   die der Übergabe von "None" ähnelt).

   Die neu erstellte Datei ist nicht vererbbar.

   Das folgende Beispiel verwendet den Parameter dir_fd der Funktion
   "os.open()", um eine Datei relativ zu einem bestimmten Verzeichnis
   zu öffnen:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('Das wird geschrieben in somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   Der Typ des von der Funktion "open()" zurückgegebenen *Datei-
   Objekts* hängt vom Modus ab. Wird "open()" verwendet, um eine Datei
   im Textmodus ("'w'", "'r'", "'wt'", "'rt'" usw.) zu öffnen, wird
   eine Unterklasse von "io.TextIOBase" (speziell "io.TextIOWrapper")
   zurückgegeben. Wird die Funktion verwendet, um eine Datei im
   Binärmodus mit Pufferung zu öffnen, ist die zurückgegebene Klasse
   eine Unterklasse von "io.BufferedIOBase". Die genaue Klasse
   variiert: Im Binär-Lesemodus wird ein "io.BufferedReader"
   zurückgegeben; im Binär-Schreib- und Binär-Anhängemodus ein
   "io.BufferedWriter" und im Lese-/Schreibmodus ein
   "io.BufferedRandom". Ist die Pufferung deaktiviert, wird der
   Rohdatenstrom (Raw Stream) zurückgegeben – eine Unterklasse von
   "io.RawIOBase", nämlich "io.FileIO".

   Siehe auch die Module zur Dateiverarbeitung, wie "fileinput", "io"
   (wo "open()" definiert ist), "os", "os.path", "tempfile" und
   "shutil".

   Löst ein Audit-Ereignis "open" mit den Argumenten "path", "mode"
   und "flags" aus.

   Die Argumente „mode“ und „flags“ wurden möglicherweise modifiziert
   oder aus dem ursprünglichen Aufruf abgeleitet.

   Geändert in Version 3.3:

   * Der Parameter *opener* wurde hinzugefügt.

   * Der Modus "'x'" wurde hinzugefügt.

   * Früher wurde "IOError" ausgelöst; mittlerweile ist es ein Alias
     ​​für "OSError".

   * Ein "FileExistsError" wird nun ausgelöst, wenn die im exklusiven
     Erstellungsmodus ("'x'") geöffnete Datei bereits existiert.

   Geändert in Version 3.4:

   * Die Datei ist nun nicht mehr vererbbar.

   Geändert in Version 3.5:

   * Wenn der Systemaufruf unterbrochen wird und der Signal-Handler
     keine Ausnahme auslöst, wiederholt die Funktion nun den
     Systemaufruf, anstatt eine "InterruptedError"-Ausnahme auszulösen
     (siehe **PEP 475** für die Begründung).

   * Der Fehlerbehandlungsmechanismus „namereplace“ wurde hinzugefügt.

   Geändert in Version 3.6:

   * Unterstützung für Objekte hinzugefügt, die "os.PathLike"
     implementieren.

   * Unter Windows kann das Öffnen eines Konsolenpuffers eine
     Unterklasse von "io.RawIOBase" zurückgeben, bei der es sich nicht
     um "io.FileIO" handelt.

   Geändert in Version 3.11: Der Modus „U“ wurde entfernt.

ord(character, /)

   Gibt den Ordinalwert eines Zeichens zurück.

   Wenn das Argument eine Zeichenkette der Länge 1 ist, wird der
   Unicode-Codepunkt dieses Zeichens zurückgegeben. Beispielsweise
   liefert "ord('a')" die Ganzzahl "97" und "ord('€')" (Euro-Zeichen)
   liefert "8364". Dies ist die Umkehrfunktion zu "chr()".

   Wenn das Argument ein "bytes"- oder "bytearray"-Objekt der Länge 1
   ist, wird dessen einzelner Bytewert zurückgegeben. Beispielsweise
   gibt "ord(b'a')" die Ganzzahl "97" zurück.“

pow(base, exp, mod=None)

   Gibt *base* hoch *exp* zurück; ist *mod* angegeben, wird *base*
   hoch *exp* modulo *mod* zurückgegeben (effizienter berechnet als
   "pow(base, exp) % mod"). Die Form mit zwei Argumenten "pow(base,
   exp)" entspricht der Verwendung des Potenzoperators: "base**exp".

   Wenn es sich bei den Argumenten um numerische Typen mit
   unterschiedlichen Operandentypen handelt, gelten die Regeln zur
   Typanpassung für binäre arithmetische Operatoren. Bei Operanden vom
   Typ "int" hat das Ergebnis denselben Typ wie die Operanden (nach
   der Typanpassung), es sei denn, das zweite Argument ist negativ; in
   diesem Fall werden alle Argumente in float umgewandelt und ein
   float-Ergebnis geliefert. So liefert beispielsweise "pow(10, 2)"
   den Wert "100", während "pow(10, -2)" den Wert "0.01" ergibt. Bei
   einer negativen Basis vom Typ "int" oder "float" und einem nicht
   ganzzahligen Exponenten wird ein komplexes Ergebnis geliefert. Zum
   Beispiel liefert "pow(-9, 0.5)" einen Wert nahe "3j". Ist die Basis
   hingegen negativ (vom Typ "int" oder "float") und der Exponent
   ganzzahlig, so wird ein float-Ergebnis geliefert. So ergibt
   "pow(-9, 2.0)" beispielsweise "81.0".

   Wenn *base* und *exp* vom Typ "int" sind und *mod* angegeben ist,
   muss auch *mod* vom Typ Integer sein und darf nicht null sein. Wenn
   *mod* angegeben ist und *exp* negativ ist, müssen *base* und *mod*
   teilerfremd sein. In diesem Fall wird "pow(inv_base, -exp, mod)"
   zurückgegeben, wobei *inv_base* das Inverse von *base* modulo *mod*
   ist.

   Hier ist ein Beispiel für die Berechnung des Inversen von "38"
   modulo "97":

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   Geändert in Version 3.8: Bei "int"-Operanden erlaubt die Form von
   "pow" mit drei Argumenten nun ein negatives zweites Argument, was
   die Berechnung modularer Inverser ermöglicht.

   Geändert in Version 3.8: Erlaube Schlüsselwortargumente. Zuvor
   wurden nur Positionsargumente unterstützt.

print(*objects, sep=' ', end='\n', file=None, flush=False)

   Gibt die *objects* in den Textdatenstrom *file* aus, getrennt durch
   *sep* und gefolgt von *end*. *sep*, *end*, *file* und *flush*
   müssen, sofern angegeben, als Schlüsselwortargumente übergeben
   werden.

   Alle Argumente, die keine Schlüsselwortargumente sind, werden wie
   bei "str()" in Zeichenketten umgewandelt und in den Stream
   geschrieben, wobei sie durch *sep* getrennt und von *end* gefolgt
   werden. Sowohl *sep* als auch *end* müssen Zeichenketten sein; sie
   können auch "None" sein, was bedeutet, dass die Standardwerte
   verwendet werden. Werden keine *objects* angegeben, schreibt
   "print()" lediglich *end*.

   Das Argument *file* muss ein Objekt mit einer
   "write(string)"-Methode sein; ist es nicht vorhanden oder "None",
   wird "sys.stdout" verwendet. Da die ausgegebenen Argumente in
   Textzeichenketten umgewandelt werden, kann "print()" nicht mit
   Dateiobjekten im Binärmodus verwendet werden. Verwenden Sie für
   diese stattdessen "file.write(...)".

   Die Ausgabepufferung wird normalerweise durch *file* bestimmt. Wenn
   *flush* jedoch auf „true“ gesetzt ist, wird der Stream zwangsweise
   geleert.

   Geändert in Version 3.3: Das Keyword-Argument *flush* wurde
   hinzugefügt.

class property(fget=None, fset=None, fdel=None, doc=None)

   Gibt ein Eigenschaftsattribut zurück.

   *fget* ist eine Funktion zum Abrufen eines Attributwerts. *fset*
   ist eine Funktion zum Setzen eines Attributwerts. *fdel* ist eine
   Funktion zum Löschen eines Attributwerts. Und *doc* erstellt einen
   Docstring für das Attribut.

   Eine typische Verwendung ist die Definition eines verwalteten
   Attributs "x":

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "Ich bin die 'x' Eigenschaft.")

   Wenn *c* eine Instanz von *C* ist, ruft "c.x" den Empfänger
   (getter) auf, "c.x = value" den Einsetzer (setter) und "del c.x"
   den Löscher (deleter).

   Falls angegeben, wird *doc* der Docstring des Property-Attributs
   sein. Andernfalls übernimmt die Property den Docstring von *fget*
   (sofern vorhanden). Dies ermöglicht es, mit "@property" als
   *Decorator* auf einfache Weise Nur-Lese-Properties zu erstellen:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Hole die aktuelle Spannung."""
              return self._voltage

   Der "@property"-Dekorateur wandelt die Methode "voltage()" in einen
   "Empfänger" für ein gleichnamiges Attribut mit Lesezugriff um und
   setzt den Docstring für *voltage* auf „Hole die aktuelle Spannung.“

   @getter

   @setter

   @deleter

      Ein Property-Objekt verfügt über "getter"-, "setter"- und
      "deleter"-Methoden, die als Dekorateur verwendet werden können;
      sie erstellen eine Kopie der Property, bei der die entsprechende
      Zugriffsfunktion auf die dekorierte Funktion gesetzt ist. Dies
      lässt sich am besten anhand eines Beispiels erläutern:

         class C:
             def __init__(self):
                 self._x = None

             @property
             def x(self):
                 """Ich bin die 'x' Eigenschaft."""
                 return self._x

             @x.setter
             def x(self, value):
                 self._x = value

             @x.deleter
             def x(self):
                 del self._x

      Dieser Code ist exakt gleichbedeutend mit dem ersten Beispiel.
      Achte darauf, den zusätzlichen Funktionen denselben Namen zu
      geben wie der ursprünglichen Eigenschaft (in diesem Fall "x").

      Das zurückgegebene Property-Objekt verfügt zudem über die
      Attribute "fget", "fset" und "fdel", die den
      Konstruktorargumenten entsprechen.

   Geändert in Version 3.5: Die Docstrings von Property-Objekten sind
   jetzt beschreibbar.

   __name__

      Attribut, das den Namen der Eigenschaft enthält. Der Name der
      Eigenschaft kann zur Laufzeit geändert werden.

      Added in version 3.13.

class range(stop, /)
class range(start, stop, step=1, /)

   Anstatt eine Funktion zu sein, ist "range" tatsächlich ein
   unveränderlicher Sequenztyp, wie in Ranges und Sequenztypen – list,
   tuple, range dokumentiert.

repr(object, /)

   Gibt eine Zeichenkette zurück, die eine druckbare Darstellung eines
   Objekts enthält. Bei vielen Typen versucht diese Funktion, eine
   Zeichenkette zurückzugeben, die bei Übergabe an "eval()" ein Objekt
   mit demselben Wert ergeben würde; andernfalls besteht die
   Darstellung aus einer in spitze Klammern eingeschlossenen
   Zeichenkette, die den Namen des Objekttyps sowie zusätzliche
   Informationen – häufig einschließlich Name und Adresse des Objekts
   – enthält. Eine Klasse kann steuern, was diese Funktion für ihre
   Instanzen zurückgibt, indem sie eine "__repr__()"-Methode
   definiert. Ist "sys.displayhook()" nicht verfügbar, löst diese
   Funktion einen "RuntimeError" aus.

   Diese Klasse verfügt über eine benutzerdefinierte Darstellung, die
   ausgewertet werden kann:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(object, /)

   Gibt einen umgekehrten *Iterator* zurück. Das Argument muss ein
   Objekt sein, das über eine "__reversed__()"-Methode verfügt oder
   das Sequenzprotokoll unterstützt (die "__len__()"-Methode und die
   "__getitem__()"-Methode mit ganzzahligen Argumenten beginnend bei
   "0").

round(number, ndigits=None)

   Gibt *number* auf *ndigits* Nachkommastellen gerundet zurück. Wenn
   *ndigits* weggelassen wird oder "None" ist, wird die dem
   Eingabewert nächstgelegene Ganzzahl zurückgegeben.

   Bei den eingebauten Typen, die "round()" unterstützen, werden Werte
   auf das nächste Vielfache von 10 hoch minus *ndigits* gerundet;
   liegen zwei Vielfache gleich nah, wird zur geraden Zahl hin
   gerundet (so ergeben beispielsweise sowohl "round(0.5)" als auch
   "round(-0.5)" den Wert "0", und "round(1.5)" ergibt "2"). Für
   *ndigits* ist jeder Ganzzahlwert zulässig (positiv, null oder
   negativ). Der Rückgabewert ist eine Ganzzahl, wenn *ndigits*
   weggelassen wird oder "None" ist. Andernfalls hat der Rückgabewert
   denselben Typ wie *number*.

   Bei einem allgemeinen Python-Objekt "number" delegiert "round" an
   "number.__round__".

   Bemerkung:

     Das Verhalten von "round()" bei Gleitkommazahlen kann
     überraschend sein: So ergibt "round(2.675, 2)" beispielsweise
     "2.67" anstelle der erwarteten "2.68". Dies ist kein Fehler,
     sondern liegt daran, dass die meisten Dezimalbrüche nicht exakt
     als Gleitkommazahl dargestellt werden können. Weitere
     Informationen finden Sie unter Gleitkommaarithmetik: Probleme und
     Einschränkungen.

class set(iterable=(), /)

   Gibt ein neues Objekt "set" zurück, optional mit Elementen aus
   *iterable*. "set" ist eine eingebaute Klasse. Siehe auch Mengen-
   Typen – set, frozenset für die Dokumentation zu dieser Klasse.

   Für weitere Container siehe die eingebauten Klassen "frozenset",
   "list", "tuple" und "dict" sowie das Modul "collections".

setattr(object, name, value, /)

   Dies ist das Gegenstück zu "getattr()". Die Argumente sind ein
   Objekt, eine Zeichenkette und ein beliebiger Wert. Die Zeichenkette
   kann ein vorhandenes oder ein neues Attribut bezeichnen. Die
   Funktion weist dem Attribut den Wert zu, sofern das Objekt dies
   zulässt. So entspricht beispielsweise "setattr(x, 'foobar', 123)"
   der Anweisung "x.foobar = 123".

   *name* muss kein Python-Bezeichner im Sinne von Identifiers and
   keywords sein, es sei denn, das Objekt erzwingt dies,
   beispielsweise in einer benutzerdefinierten
   "__getattribute__()"-Methode oder über "__slots__". Ein Attribut,
   dessen Name kein Bezeichner ist, kann nicht über die Punktnotation
   angesprochen werden, ist jedoch über "getattr()" usw. zugänglich.“

   Bemerkung:

     Da Private Name Mangling zur Kompilierzeit erfolgt, muss der Name
     eines privaten Attributs (Attribute mit zwei führenden
     Unterstrichen) manuell umgewandelt werden, um es mittels
     "setattr()" zu setzen.

class slice(stop, /)
class slice(start, stop, step=None, /)

   Gibt ein *slice*-Objekt zurück, das die durch "range(start, stop,
   step)" festgelegte Menge an Indizes repräsentiert. Die Argumente
   *start* und *step* haben standardmäßig den Wert "None".

   Slice objects have read-only data attributes "start", "stop", and
   "step" which merely return the argument values (or their default).
   They have no other explicit functionality; however, they are used
   by NumPy and other third-party packages.

   start

   stop

   step

   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   *iterator*.

   Geändert in Version 3.12: Slice-Objekte sind jetzt *hashbar*
   (sofern "start", "stop" und "step" hashbar sind).

sorted(iterable, /, *, key=None, reverse=False)

   Gibt eine neue sortierte Liste der Elemente aus *iterable* zurück.

   Verfügt über zwei optionale Argumente, die als
   Schlüsselwortargumente angegeben werden müssen.

   *key* gibt eine Funktion mit einem Argument an, die dazu dient,
   einen Vergleichsschlüssel aus jedem Element in *iterable* zu
   extrahieren (zum Beispiel "key=str.lower"). Der Standardwert ist
   "None" (die Elemente werden direkt verglichen).

   *reverse* ist ein boolescher Wert. Wenn er auf "True" gesetzt ist,
   werden die Listenelemente so sortiert, als ob jeder Vergleich
   umgekehrt würde.

   Verwende "functools.cmp_to_key()", um eine veraltete *cmp*-Funktion
   in eine *key*-Funktion umzuwandeln.

   Die integrierte Funktion "sorted()" ist garantiert stabil. Ein
   Sortierverfahren ist stabil, wenn es die relative Reihenfolge von
   Elementen, die als gleich gelten, nicht verändert – dies ist
   hilfreich bei Sortierungen in mehreren Durchläufen (zum Beispiel
   Sortierung nach Abteilung und anschließend nach Gehaltsgruppe).

   Der Sortieralgorithmus verwendet nur "<"-Vergleiche zwischen
   Elementen. Während das Definieren einer Methode "__lt__()" für die
   Sortierung ausreicht, empfiehlt **PEP 8**, alle sechs erweiterten
   Vergleichsoperationen zu implementieren. Dies hilft, Fehler zu
   vermeiden, wenn dieselben Daten mit anderen Sortierwerkzeugen wie
   "max()" verwendet werden, die sich auf eine andere zugrunde
   liegende Methode stützen. Die Implementierung aller sechs
   Vergleiche hilft außerdem, Verwirrung bei gemischten Typvergleichen
   zu vermeiden, die die gespiegelte Methode "__gt__()" aufrufen
   können.

   Beispiele und eine kurze Anleitung zum Sortieren finden Sie unter
   Sorting Techniques.

@staticmethod

   Wandelt eine Methode in eine statische Methode um.

   Eine statische Methode erhält kein implizites erstes Argument. Um
   eine statische Methode zu deklarieren, verwenden Sie dieses Idiom:

      class C:
          @staticmethod
          def f(arg1, arg2, argN): ...

   Die Form "@staticmethod" ist ein Funktions-*Dekorateur* – siehe
   Funktionsdefinitionen für Einzelheiten.

   Eine statische Methode kann entweder über die Klasse (z. B.
   "C.f()") oder über eine Instanz (z. B. "C().f()") aufgerufen
   werden. Darüber hinaus ist der statische Methoden-*Deskriptor*
   selbst aufrufbar, sodass er in der Klassendefinition verwendet
   werden kann (z. B. "f()").

   Statische Methoden in Python ähneln denen in Java oder C++. Siehe
   auch das "@classmethod", eine Variante, die sich zum Erstellen
   alternativer Klassenkonstruktoren eignet.

   Wie bei allen Dekorateuren ist es auch möglich, "staticmethod" als
   reguläre Funktion aufzurufen und mit dem Ergebnis weiterzuarbeiten.
   Dies ist in Fällen erforderlich, in denen man innerhalb des
   Klassenkörpers eine Referenz auf eine Funktion benötigt und die
   automatische Umwandlung in eine Instanzmethode vermeiden möchte.
   Für solche Fälle verwendet man folgendes Idiom:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

   Weitere Informationen zu statischen Methoden finden Sie unter Die
   Standardtyp-Hierarchie.

   Geändert in Version 3.10: Statische Methoden erben nun die
   Methodenattribute ("__module__", "__name__", "__qualname__",
   "__doc__" und "__annotations__"), verfügen über ein neues
   "__wrapped__"-Attribut und sind nun wie reguläre Funktionen
   aufrufbar.

class str(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

   Gibt eine "str"-Version von *object* zurück. Siehe "str()" für
   Details.

   "str" ist die integrierte Zeichenketten-*Klasse*. Allgemeine
   Informationen zu Zeichenketten finden Sie unter Textsequenztyp –
   str.“

sum(iterable, /, start=0)

   Summiert *start* und die Elemente eines *Iterables* von links nach
   rechts auf und gibt die Gesamtsumme zurück. Die Elemente des
   *Iterables* sind normalerweise Zahlen, und der Startwert darf kein
   String sein.“

   Für einige Anwendungsfälle gibt es gute Alternativen zu "sum()".
   Die bevorzugte, schnelle Methode zum Verketten einer Sequenz von
   Zeichenketten ist der Aufruf von "''.join(sequence)". Für die
   Addition von Gleitkommazahlen mit erhöhter Genauigkeit siehe
   "math.fsum()". Zum Verketten einer Reihe von Iterables empfiehlt
   sich die Verwendung von "itertools.chain()".

   Geändert in Version 3.8: Der Parameter *start* kann als
   Schlüsselwortargument angegeben werden.

   Geändert in Version 3.12: Die Summation von Gleitkommazahlen wurde
   auf einen Algorithmus umgestellt, der bei den meisten Builds eine
   höhere Genauigkeit und eine bessere Kommutativität bietet.

class super
class super(type, object_or_type=None, /)

   Gibt ein Proxy-Objekt zurück, das Methodenaufrufe an eine Eltern-
   oder Geschwisterklasse von *type* delegiert. Dies ist nützlich für
   den Zugriff auf geerbte Methoden, die in einer Klasse überschrieben
   wurden.

   Das *object_or_type* bestimmt die *Methodenauflösungsreihenfolge*
   (method resolution order), die durchsucht werden soll. Die Suche
   beginnt bei der Klasse, die direkt auf den *type* folgt.

   Wenn zum Beispiel "__mro__" von *object_or_type* "D -> B -> C -> A
   -> object" lautet und der Wert von *type* "B" ist, dann durchsucht
   "super()" "C -> A -> object".

   Das Attribut "__mro__" der Klasse, die *object_or_type* entspricht,
   listet die Suchreihenfolge für die Methodenauflösung auf, die
   sowohl von "getattr()" als auch von "super()" verwendet wird. Das
   Attribut ist dynamisch und kann sich ändern, wann immer die
   Vererbungshierarchie aktualisiert wird.

   Wird das zweite Argument weggelassen, ist das zurückgegebene super-
   Objekt ungebunden. Ist das zweite Argument ein Objekt, muss
   "isinstance(obj, type)" wahr sein. Ist das zweite Argument ein Typ,
   muss "issubclass(type2, type)" wahr sein (dies ist nützlich für
   Klassenmethoden).“

   Wenn der Aufruf direkt innerhalb einer gewöhnlichen Methode einer
   Klasse erfolgt, können beide Argumente weggelassen werden
   („"super()" ohne Argumente“). In diesem Fall ist *type* die
   umschließende Klasse und *obj* das erste Argument der unmittelbar
   umschließenden Funktion (typischerweise "self"). (Dies bedeutet,
   dass "super()" ohne Argumente innerhalb verschachtelter Funktionen
   – einschließlich Generator-Ausdrücken, die implizit verschachtelte
   Funktionen erzeugen – nicht wie erwartet funktioniert.)

   Es gibt zwei typische Anwendungsfälle für *super*. In einer
   Klassenhierarchie mit einfacher Vererbung kann *super* verwendet
   werden, um auf Elternklassen zu verweisen, ohne diese explizit zu
   benennen, wodurch der Code wartungsfreundlicher wird. Diese
   Verwendung entspricht weitgehend der Verwendung von *super* in
   anderen Programmiersprachen.

   Der zweite Anwendungsfall ist die Unterstützung kooperativer
   Mehrfachvererbung in einer dynamischen Ausführungsumgebung. Dieser
   Anwendungsfall ist spezifisch für Python und kommt weder in
   statisch kompilierten Sprachen noch in Sprachen vor, die lediglich
   Einfachvererbung unterstützen. Dies ermöglicht die Implementierung
   von "Diamantstrukturen", bei denen mehrere Basisklassen dieselbe
   Methode implementieren. Ein gutes Design erfordert, dass derartige
   Implementierungen stets dieselbe Aufrufsignatur aufweisen (da die
   Aufrufreihenfolge zur Laufzeit bestimmt wird, sich an Änderungen
   der Klassenhierarchie anpasst und auch Geschwisterklassen
   einbeziehen kann, die vor der Laufzeit noch unbekannt sind).

   Für beide Anwendungsfälle sieht ein typischer Aufruf der
   Superklasse folgendermaßen aus:

      class C(B):
          def method(self, arg):
              super().method(arg)    # Dies bewirkt dasselbe wie:
                                     # super(C, self).method(arg)

   Neben der Methodensuche funktioniert "super()" auch bei der
   Attributsuche. Ein möglicher Anwendungsfall hierfür ist der Aufruf
   von *Deskriptoren* in einer Eltern- oder Geschwisterklasse.

   Beachte, dass "super()" als Teil des Bindungsprozesses für
   explizite Attributzugriffe mit Punktnotation – wie etwa
   "super().__getitem__(name)" – implementiert ist. Dies geschieht
   durch die Implementierung einer eigenen
   "__getattribute__()"-Methode, die Klassen in einer vorhersagbaren
   Reihenfolge durchsucht und so kooperative Mehrfachvererbung
   unterstützt. Folglich ist "super()" für implizite Zugriffe mittels
   Anweisungen oder Operatoren, wie beispielsweise "super()[name]",
   nicht definiert.

   Beachteaußerdem, dass "super()" – abgesehen von der Variante ohne
   Argumente – nicht auf die Verwendung innerhalb von Methoden
   beschränkt ist. Die Variante mit zwei Argumenten legt die Argumente
   genau fest und stellt die entsprechenden Bezüge her. Die Variante
   ohne Argumente funktioniert hingegen nur innerhalb einer
   Klassendefinition, da der Compiler die erforderlichen Details
   ergänzt, um die gerade definierte Klasse korrekt zu ermitteln und
   bei gewöhnlichen Methoden auf die aktuelle Instanz zuzugreifen.

   Praktische Vorschläge zur Gestaltung kooperativer Klassen unter
   Verwendung von "super()" finden Sie im Leitfaden zur Verwendung von
   super().

class tuple(iterable=(), /)

   Anstatt eine Funktion zu sein, ist "tuple" eigentlich ein
   unveränderlicher Sequenztyp, wie in Tupel und Sequenztypen – list,
   tuple, range dokumentiert.

class type(object, /)
class type(name, bases, dict, /, **kwargs)

   Geben Sie mit einem Argument den Typ eines *Objekts* zurück. Der
   Rückgabewert ist ein Typobjekt und im Allgemeinen dasselbe Objekt,
   das von "object.__class__" zurückgegeben wird.

   Die eingebaute Funktion "isinstance()" wird empfohlen, um den Typ
   eines Objekts zu überprüfen, da sie Unterklassen berücksichtigt.

   Gibt bei Angabe von drei Argumenten ein neues Typobjekt zurück.
   Dies ist im Wesentlichen eine dynamische Form der
   "class"-Anweisung. Die Zeichenkette *name* ist der Klassenname und
   wird zum Attribut "__name__". Das Tupel *bases* enthält die
   Basisklassen und wird zum Attribut "__bases__"; ist es leer, wird
   "object" – die gemeinsame Basisklasse aller Klassen – hinzugefügt.
   Das Dictionary *dict* enthält Attribut- und Methodendefinitionen
   für den Klassenkörper; es kann kopiert oder gekapselt werden, bevor
   es zum Attribut "__dict__" wird. Die folgenden beiden Anweisungen
   erzeugen identische "type"-Objekte:

   >>> class X:
   ...     a = 1
   ...
   >>> X = type('X', (), dict(a=1))

   Siehe auch:

   * Dokumentation zu Attributen und Methoden von Klassen.

   * Typ-Objekte

   Schlüsselwortargumente, die der Form mit drei Argumenten übergeben
   werden, werden an den entsprechenden Metaklassen-Mechanismus
   (üblicherweise "__init_subclass__()") weitergereicht – auf dieselbe
   Weise, wie dies bei Schlüsselwörtern in einer Klassendefinition
   (abgesehen von *metaclass*) der Fall wäre.

   Anders als bei einer "class"-Anweisung ruft die dreiargumentige
   Form nicht die Metaklassen-Methode "__prepare__" auf (siehe
   Vorbereiten des Klassen-Namespace). Verwende "types.new_class()",
   um eine Klasse dynamisch unter Verwendung der passenden Metaklasse
   zu erstellen.

   Siehe auch Anpassung der Klassenerstellung.

   Geändert in Version 3.6: Unterklassen von "type", die
   "type.__new__" nicht überschreiben, dürfen nicht mehr die Form mit
   einem Argument verwenden, um den Typ eines Objekts zu ermitteln.

vars()
vars(object, /)

   Geben Sie das Attribut "__dict__" für ein Modul, eine Klasse, eine
   Instanz oder ein beliebiges anderes Objekt mit einem
   "__dict__"-Attribut zurück.

   Objekte wie Module und Instanzen verfügen über ein aktualisierbares
   "__dict__"-Attribut; andere Objekte können jedoch
   Schreibbeschränkungen für ihre "__dict__"-Attribute aufweisen
   (Klassen verwenden beispielsweise ein "types.MappingProxyType", um
   direkte Aktualisierungen des Dictionarys zu verhindern).

   Ohne Argument verhält sich "vars()" wie "locals()".

   Eine "TypeError"-Ausnahme wird ausgelöst, wenn ein Objekt angegeben
   wird, das kein "__dict__"-Attribut besitzt (zum Beispiel, wenn
   seine Klasse das "__slots__"-Attribut definiert).

   Geändert in Version 3.13: Das Ergebnis des Aufrufs dieser Funktion
   ohne Argument wurde wie für die eingebaute Funktion "locals()"
   beschrieben aktualisiert.

zip(*iterables, strict=False)

   Über mehrere Iterables parallel iterieren und dabei Tupel mit je
   einem Element aus jedem Iterable erzeugen.“

   Beispiel:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   Etwas formeller ausgedrückt: "zip()" gibt einen Iterator von Tupeln
   zurück, wobei das *i*-te Tupel das *i*-te Element aus jedem der als
   Argument übergebenen Iterables enthält.

   Eine weitere Möglichkeit, sich "zip()" vorzustellen, ist, dass es
   Zeilen in Spalten und Spalten in Zeilen umwandelt. Dies ähnelt dem
   Transponieren einer Matrix.

   "zip()" arbeitet verzögert (lazy): Die Elemente werden erst
   verarbeitet, wenn über das Iterable iteriert wird, z. B. mittels
   einer "for"-Schleife oder durch Umwandlung in eine "list".

   Es ist zu beachten, dass die an "zip()" übergebenen Iterables
   unterschiedliche Längen aufweisen können – manchmal beabsichtigt,
   manchmal aufgrund eines Fehlers in dem Code, der diese Iterables
   erstellt hat. Python bietet drei verschiedene Ansätze für den
   Umgang mit diesem Problem:

   * By default, "zip()" stops when the shortest iterable is
     exhausted. It will ignore the remaining items in the longer
     iterables, cutting off the result to the length of the shortest
     iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" wird häufig in Fällen verwendet, in denen davon
     ausgegangen wird, dass die Iterables gleich lang sind. In solchen
     Fällen empfiehlt sich die Verwendung der Option "strict=True".
     Die Ausgabe entspricht der von regulärem "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Unlike the default behavior, it raises a "ValueError" if one
     iterable is exhausted before the others:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     Ohne das Argument „strict=True“ werden Fehler, die zu Iterables
     unterschiedlicher Länge führen, unterdrückt; dies kann sich
     möglicherweise als schwer zu findender Fehler an einer anderen
     Stelle des Programms äußern.

   * Kürzere Iterables können mit einem konstanten Wert aufgefüllt
     werden, damit alle Iterables dieselbe Länge haben. Dies geschieht
     mit "itertools.zip_longest()".

   Grenzfälle: Bei einem einzelnen iterierbaren Argument gibt "zip()"
   einen Iterator von 1-Tupeln zurück. Ohne Argumente gibt es einen
   leeren Iterator zurück.

   Tipps und Tricks:

   * Die Auswertungsreihenfolge der Iterables von links nach rechts
     ist garantiert. Dies ermöglicht ein Idiom, um eine Datensequenz
     mithilfe von "zip(*[iter(s)]*n, strict=True)" in Gruppen der
     Länge "n" zu unterteilen. Dabei wird *derselbe* Iterator "n"-mal
     verwendet, sodass jedes Ergebnis-Tupel die Resultate von "n"
     Aufrufen des Iterators enthält. Dies bewirkt eine Aufteilung der
     Eingabe in Abschnitte der Länge "n".

   * "zip()" kann in Verbindung mit dem "*"-Operator verwendet werden,
     um eine Liste zu entpacken:

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

   Geändert in Version 3.10: Das Argument "strict" wurde hinzugefügt.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Bemerkung:

     Dies ist eine fortgeschrittene Funktion, die im Gegensatz zu
     "importlib.import_module()" in der alltäglichen Python-
     Programmierung nicht benötigt wird.

   Diese Funktion wird durch die "import"-Anweisung aufgerufen. Sie
   kann ersetzt werden (durch Importieren des Moduls "builtins" und
   Zuweisung an "builtins.__import__"), um die Semantik der
   "import"-Anweisung zu ändern; davon wird jedoch **dringend**
   abgeraten. Es ist meist einfacher, Import-Hooks (siehe **PEP 302**)
   zu verwenden, um dieselben Ziele zu erreichen, ohne Probleme bei
   Code zu verursachen, der von der Standard-Importimplementierung
   ausgeht. Auch von der direkten Verwendung von "__import__()" wird
   zugunsten von "importlib.import_module()" abgeraten.

   Die Funktion importiert das Modul *name* und verwendet dabei
   gegebenenfalls die angegebenen *globals* und *locals*, um zu
   bestimmen, wie der Name im Kontext eines Pakets zu interpretieren
   ist. Über *fromlist* werden die Namen von Objekten oder
   Untermodulen angegeben, die aus dem durch *name* bezeichneten Modul
   importiert werden sollen. Die Standardimplementierung verwendet das
   Argument *locals* überhaupt nicht und nutzt *globals* lediglich
   dazu, den Paketkontext der "import"-Anweisung zu bestimmen.

   *level* gibt an, ob absolute oder relative Importe verwendet werden
   sollen. "0" (der Standard) bedeutet, dass nur absolute Importe
   durchgeführt werden. Positive Werte für „level“ geben die Anzahl
   der übergeordneten Verzeichnisse an, die ausgehend vom Verzeichnis
   des Moduls, das "__import__()" aufruft, durchsucht werden sollen.
   (siehe **PEP 328** für mehr Details).

   Wenn die Variable *name* die Form "package.module" hat, wird
   normalerweise das Paket der obersten Ebene (der Name bis zum ersten
   Punkt) zurückgegeben, *nicht* das durch *name* bezeichnete Modul.
   Wird jedoch ein nicht leeres *fromlist*-Argument angegeben, so wird
   das durch *name* bezeichnete Modul zurückgegeben.

   Die Anweisung „import spam“ führt beispielsweise zu Bytecode, der
   dem folgenden Code ähnelt:

      spam = __import__('spam', globals(), locals(), [], 0)

   Die Anweisung "import spam.ham" führt zu diesem Aufruf:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

   Beachte, wie "__import__()" hier das Modul der obersten Ebene
   zurückgibt, da dies das Objekt ist, das durch die
   "import"-Anweisung an einen Namen gebunden wird.

   Andererseits führt die Anweisung "from spam.ham import eggs,
   sausage as saus" zu

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Hier wird das Modul "spam.ham" von "__import__()" zurückgegeben.
   Aus diesem Objekt werden die zu importierenden Namen abgerufen und
   den entsprechenden Namen zugewiesen.

   Wenn Sie ein Modul (möglicherweise innerhalb eines Pakets) einfach
   anhand seines Namens importieren möchten, verwenden Sie
   "importlib.import_module()".

   Geändert in Version 3.3: Negative Werte für *level* werden nicht
   mehr unterstützt (wodurch sich auch der Standardwert auf 0 ändert).

   Geändert in Version 3.9: Wenn die Befehlszeilenoptionen "-E" oder
   "-I" verwendet werden, wird die Umgebungsvariable "PYTHONCASEOK"
   nun ignoriert.

-[ Fußnoten ]-

[1] Beachte, dass der Parser nur Zeilenenden im Unix-Format
    akzeptiert. Wenn Du den Code aus einer Datei liest, stelle sicher,
    dass Du den Modus zur Umwandlung von Zeilenumbrüchen verwendest,
    um Zeilenumbrüche im Windows- oder Mac-Format zu konvertieren.
