Eingebaute Typen
****************

Die folgenden Abschnitte beschreiben die Standardtypen, die in den
Interpreter eingebaut sind.

Die wichtigsten eingebauten Typen sind numerische Typen, Sequenzen,
Mappings, Klassen, Instanzen und Exceptions.

Einige Collection-Klassen sind veränderbar. Die Methoden, die ihre
Elemente an Ort und Stelle (in place) hinzufügen, entfernen oder
umordnen und kein bestimmtes Element zurückgeben, geben niemals die
Collection-Instanz selbst zurück, sondern "None".

Einige Operationen werden von mehreren Objekttypen unterstützt.
Insbesondere können praktisch alle Objekte auf Gleichheit verglichen,
auf ihren Wahrheitswert getestet und in eine Zeichenkette umgewandelt
werden (mit der Funktion "repr()" oder der geringfügig abweichenden
Funktion "str()"). Letztere Funktion wird implizit verwendet, wenn ein
Objekt durch die Funktion "print()" ausgegeben wird.


Wahrheitswert-Prüfung
=====================

Jedes Objekt kann auf seinen Wahrheitswert getestet werden, um in
einer "if"- oder "while"-Bedingung oder als Operand der folgenden
booleschen Operationen verwendet zu werden.

By default, an object is considered true unless its class defines
either a "__bool__()" method that returns "False" or a "__len__()"
method that returns zero, when called with the object. [1]  Here are
most of the built-in objects considered false:

* Konstanten, die als falsch definiert sind: "None" und "False"

* Null eines beliebigen numerischen Typs: "0", "0.0", "0j",
  "Decimal(0)", "Fraction(0, 1)"

* leere Sequenzen und Collections: "''", "()", "[]", "{}", "set()",
  "range(0)"

Operationen und eingebaute Funktionen, die ein boolesches Ergebnis
haben, geben immer "0" oder "False" für falsch und "1" oder "True" für
wahr zurück, sofern nicht anders angegeben. (Wichtige Ausnahme: Die
booleschen Operationen "or" und "and" geben immer einen ihrer
Operanden zurück.)


Boolesche Operationen --- "and", "or", "not"
============================================

Dies sind die booleschen Operationen, geordnet nach aufsteigender
Priorität:

+---------------+-----------------------------------+---------+
| Operation     | Ergebnis                          | Hinwei  |
|               |                                   | se      |
|===============|===================================|=========|
| "x or y"      | wenn *x* wahr ist, dann *x*,      | (1)     |
|               | sonst *y*                         |         |
+---------------+-----------------------------------+---------+
| "x und y"     | wenn *x* falsch ist, dann *x*,    | (2)     |
|               | sonst *y*                         |         |
+---------------+-----------------------------------+---------+
| "not x"       | wenn *x* falsch ist, dann "True", | (3)     |
|               | sonst "False"                     |         |
+---------------+-----------------------------------+---------+

Hinweise:

1. Dies ist ein Kurzschlussoperator, daher wird das zweite Argument
   nur ausgewertet, wenn das erste falsch ist.

2. Dies ist ein Kurzschlussoperator, daher wird das zweite Argument
   nur ausgewertet, wenn das erste wahr ist.

3. "not" hat eine niedrigere Priorität als nicht-boolesche Operatoren,
   daher wird "not a == b" als "not (a == b)" interpretiert, und "a ==
   not b" ist ein Syntaxfehler.


Vergleiche
==========

Es gibt acht Vergleichsoperationen in Python. Sie haben alle dieselbe
Priorität (welche höher ist als die der booleschen Operationen).
Vergleiche können beliebig verkettet werden, zum Beispiel ist "x < y
<= z" äquivalent zu "x < y and y <= z", mit der Ausnahme, dass *y* nur
einmal ausgewertet wird (aber in beiden Fällen wird *z* überhaupt
nicht ausgewertet, wenn "x < y" als falsch befunden wird).

Diese Tabelle fasst die Vergleichsoperationen zusammen:

+--------------+---------------------------+
| Operation    | Bedeutung                 |
|==============|===========================|
| "<"          | echt kleiner als          |
+--------------+---------------------------+
| "<="         | kleiner oder gleich       |
+--------------+---------------------------+
| ">"          | echt größer als           |
+--------------+---------------------------+
| ">="         | größer oder gleich        |
+--------------+---------------------------+
| "=="         | gleich                    |
+--------------+---------------------------+
| "!="         | ungleich                  |
+--------------+---------------------------+
| "is"         | Objektidentität           |
+--------------+---------------------------+
| "is not"     | negierte Objektidentität  |
+--------------+---------------------------+

Objekte verschiedener Typen, mit Ausnahme verschiedener numerischer
Typen, sind bei einem Vergleich niemals gleich. Der Operator "==" ist
immer definiert, entspricht aber für einige Objekttypen (z. B.
Klassenobjekte) dem Operator "is". Die Operatoren "<", "<=", ">" und
">=" sind nur dort definiert, wo sie sinnvoll sind.Beispielsweise
lösen sie eine "TypeError"-Ausnahme aus, wenn eines der Argumente eine
komplexe Zahl ist.

Nicht-identische Instanzen einer Klasse werden normalerweise als
ungleich angesehen, es sei denn, die Klasse definiert die Methode
"__eq__()".

Instanzen einer Klasse können bezüglich anderer Instanzen derselben
Klasse oder anderer Objekttypen nicht geordnet werden, es sei denn,
die Klasse definiert ausreichend viele der Methoden "__lt__()",
"__le__()", "__gt__()" und "__ge__()" (im Allgemeinen genügen
"__lt__()" und "__eq__()", wenn man die herkömmlichen Bedeutungen der
Vergleichsoperatoren wünscht).

Das Verhalten der Operatoren "is" und "is not" kann nicht angepasst
werden. Zudem können sie auf beliebige zwei Objekte angewendet werden
und lösen niemals eine Ausnahme aus.

Zwei weitere Operationen mit derselben syntaktischen Priorität, "in"
und "not in", werden von Typen unterstützt, die *iterable* sind oder
die Methode "__contains__()" implementieren.


Numerische Typen --- "int", "float", "complex"
==============================================

Es gibt drei verschiedene numerische Typen: *Ganzzahlen <integers>*,
*Gleitkommazahlen <floating-point numbers>* und *komplexe Zahlen
<complex numbers>*. Zudem sind Booleans ein Subtyp von Ganzzahlen.
Ganzzahlen haben eine unbegrenzte Genauigkeit. Gleitkommazahlen werden
in C üblicherweise mittels double implementiert. Informationen über
die Genauigkeit und interne Darstellung von Gleitkommazahlen für die
Maschine, auf der das Programm läuft, sind in "sys.float_info"
verfügbar. Komplexe Zahlen haben einen Real- und einen Imaginärteil,
welche jeweils eine Gleitkommazahl sind. Um diese Teile aus einer
komplexen Zahl *z* zu extrahieren, verwendet man "z.real" und
"z.imag". (Die Standardbibliothek enthält die zusätzlichen numerischen
Typen "fractions.Fraction" für rationale Zahlen und "decimal.Decimal"
für Gleitkommazahlen mit benutzerdefinierbarer Genauigkeit.)

Zahlen werden durch numerische Literale oder als Ergebnis von
eingebauten Funktionen und Operatoren erzeugt. Reine Ganzzahlliterale
(einschließlich Hexadezimal-, Oktal- und Binärzahlen) ergeben
Ganzzahlen. Numerische Literale, die einen Dezimalpunkt oder ein
Exponenten-Zeichen enthalten, ergeben Gleitkommazahlen. Das Anhängen
von "'j'" oder "'J'" an ein numerisches Literal ergibt eine imaginäre
Zahl (eine komplexe Zahl mit einem Realteil von null), die man zu
einer Ganzzahl oder einem Float addieren kann, um eine komplexe Zahl
mit Real- und Imaginärteil zu erhalten.

Python fully supports mixed arithmetic: when a binary arithmetic
operator has operands of different numeric types, the operand with the
"narrower" type is widened to that of the other, where integer is
narrower than floating point, which is narrower than complex. A
comparison between numbers of different types behaves as though the
exact values of those numbers were being compared. [2]

Die Konstruktoren "int()", "float()" und "complex()" können verwendet
werden, um Zahlen eines bestimmten Typs zu erzeugen.

Alle numerischen Typen (außer komplexe Zahlen) unterstützen die
folgenden Operationen (zur Priorität der Operationen siehe Reihenfolge
der Rechenoperatoren):

+-----------------------+-----------------------------------+-----------+----------------------+
| Operation             | Ergebnis                          | Hinweise  | Vollständige         |
|                       |                                   |           | Dokumentation        |
|=======================|===================================|===========|======================|
| "x + y"               | Summe von *x* und *y*             |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x - y"               | Differenz von *x* und *y*         |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x * y"               | Produkt von *x* und *y*           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x / y"               | Quotient von *x* und *y*          |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x // y"              | abgerundeter Quotient von *x* und | (1)(2)    |                      |
|                       | *y*                               |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x % y"               | Rest von "x / y"                  | (2)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "-x"                  | *x* negiert                       |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "+x"                  | *x* unverändert                   |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "abs(x)"              | Absolutwert oder Betrag von *x*   |           | "abs()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "int(x)"              | *x* umgewandelt in eine Ganzzahl  | (3)(6)    | "int()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "float(x)"            | *x* umgewandelt in eine           | (4)(6)    | "float()"            |
|                       | Gleitkommazahl                    |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "complex(re, im)"     | Eine komplexe Zahl mit Realteil   | (6)       | "complex()"          |
|                       | *re* und Imaginärteil *im*. *im*  |           |                      |
|                       | ist standardmäßig null.           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "c.conjugate()"       | Konjugiert komplexe Zahl zu *c*   |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "divmod(x, y)"        | Das Paar "(x // y, x % y)"        | (2)       | "divmod()"           |
+-----------------------+-----------------------------------+-----------+----------------------+
| "pow(x, y)"           | *x* hoch *y*                      | (5)       | "pow()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x ** y"              | *x* hoch *y*                      | (5)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+

Hinweise:

1. Wird auch als Ganzzahldivision bezeichnet. Für Operanden vom Typ
   "int" hat das Ergebnis den Typ "int". Für Operanden vom Typ "float"
   hat das Ergebnis den Typ "float". Im Allgemeinen ist das Ergebnis
   eine ganze Zahl, obwohl der Typ des Ergebnisses nicht zwingend
   "int" ist. Das Ergebnis wird immer in Richtung minus unendlich
   gerundet: "1//2" ist "0", "(-1)//2" ist "-1", "1//(-2)" ist "-1"
   und "(-1)//(-2)" ist "0".

2. Nicht für komplexe Zahlen. Verwende stattdessen gegebenenfalls
   "abs()" zur Umwandlung in Fließkommazahlen.

3. Die Umwandlung von "float" in "int" schneidet den Nachkommateil ab.
   Siehe die Funktionen "math.floor()" und "math.ceil()" für
   alternative Umwandlungen.

4. float akzeptiert auch die Zeichenketten „nan“ und „inf“ mit einem
   optionalen Präfix „+“ oder „-“ für Not a Number (NaN) sowie
   positive oder negative Unendlichkeit.

5. Python definiert "pow(0, 0)" und "0 ** 0" als "1", wie es für
   Programmiersprachen üblich ist.

6. Zu den akzeptierten numerischen Literalen gehören die Ziffern "0"
   bis "9" oder jedes Unicode-Äquivalent (Codepunkte mit der
   Eigenschaft "Nd").

   Siehe den Unicode-Standard für eine vollständige Liste der
   Codepunkte mit der Eigenschaft "Nd".

Alle "numbers.Real"-Typen ("int" und "float") enthalten außerdem die
folgenden Operationen:

+----------------------+-----------------------------------------------+
| Operation            | Ergebnis                                      |
|======================|===============================================|
| "math.trunc(x)"      | *x* abgeschnitten zu "Integral"               |
+----------------------+-----------------------------------------------+
| "round(x[, n])"      | *x* gerundet auf *n* Stellen, wobei           |
|                      | kaufmännisch/zur nächsten geraden Zahl        |
|                      | gerundet wird (Round half to even). Wird *n*  |
|                      | weggelassen, ist der Standardwert 0.          |
+----------------------+-----------------------------------------------+
| "math.floor(x)"      | das größte "Integral" <= *x*                  |
+----------------------+-----------------------------------------------+
| "math.ceil(x)"       | das kleinste "Integral" >= *x*                |
+----------------------+-----------------------------------------------+

Weitere numerische Operationen finden sich in den Modulen "math" und
"cmath".


Bitweise Operationen auf Ganzzahl-Typen
---------------------------------------

Bitweise Operationen sind nur für Ganzzahlen sinnvoll. Das Ergebnis
bitweiser Operationen wird so berechnet, als würde es im
Zweierkomplement mit einer unendlichen Anzahl von Vorzeichenbits
ausgeführt.

Die Prioritäten der binären bitweisen Operationen sind alle niedriger
als die der numerischen Operationen und höher als die der Vergleiche.
Die unäre Operation "~" hat die gleiche Priorität wie die anderen
unären numerischen Operationen ("+" und "-").

Diese Tabelle listet die bitweisen Operationen auf, sortiert nach
aufsteigender Priorität:

+--------------+----------------------------------+------------+
| Operation    | Ergebnis                         | Hinweise   |
|==============|==================================|============|
| "x | y"      | bitweises *oder* von *x* und *y* | (4)        |
+--------------+----------------------------------+------------+
| "x ^ y"      | bitweises *exklusives oder* von  | (4)        |
|              | *x* und *y*                      |            |
+--------------+----------------------------------+------------+
| "x & y"      | bitweises *und* von *x* und *y*  | (4)        |
+--------------+----------------------------------+------------+
| "x << n"     | *x* um *n* Bits nach links       | (1)(2)     |
|              | verschoben                       |            |
+--------------+----------------------------------+------------+
| "x >> n"     | *x* um *n* Bits nach rechts      | (1)(3)     |
|              | verschoben                       |            |
+--------------+----------------------------------+------------+
| "~x"         | die Bits von *x* invertiert      |            |
+--------------+----------------------------------+------------+

Hinweise:

1. Negative Shift-Werte sind unzulässig und führen dazu, dass ein
   "ValueError" ausgelöst wird.

2. Ein Linksshift um *n* Bits ist äquivalent zur Multiplikation mit
   "pow(2, n)".

3. Ein Rechtsshift um *n* Bits ist äquivalent zur Abrundungsdivision
   (Floor Division) durch "pow(2, n)".

4. Die Durchführung dieser Berechnungen mit mindestens einem
   zusätzlichen Vorzeichen-Erweiterungsbit in einer endlichen
   Zweierkomplement-Darstellung (einer Arbeitsbitbreite von "1 +
   max(x.bit_length(), y.bit_length())" oder mehr) reicht aus, um das
   gleiche Ergebnis zu erhalten, als gäbe es eine unendliche Anzahl
   von Vorzeichenbits.


Zusätzliche Methoden zu Ganzzahl-Typen
--------------------------------------

Der Typ int implementiert die "numbers.Integral" *abstrakte
Basisklasse*. Darüber hinaus stellt er einige weitere Methoden zur
Verfügung:

int.bit_length()

   Gibt die Anzahl der Bits zurück, die erforderlich sind, um eine
   Ganzzahl binär darzustellen, ausschließlich des Vorzeichens und
   führender Nullen:

      >>> n = -37
      >>> bin(n)
      '-0b100101'
      >>> n.bit_length()
      6

   Genauer gesagt: Wenn "x" ungleich null ist, dann ist
   "x.bit_length()" die eindeutige positive Ganzzahl "k", sodass
   "2**(k-1) <= abs(x) < 2**k" gilt. Entsprechend gilt: Wenn "abs(x)"
   klein genug ist, um einen korrekt gerundeten Logarithmus zu haben,
   dann ist "k = 1 + int(log(abs(x), 2))". Wenn "x" null ist, gibt
   "x.bit_length()" den Wert "0" zurück.

   Äquivalent zu:

      def bit_length(self):
          s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
          s = s.lstrip('-0b') # remove leading zeros and minus sign
          return len(s)       # len('100101') --> 6

   Added in version 3.1.

int.bit_count()

   Gibt die Anzahl der Einsen in der binären Darstellung des
   Absolutwerts der Ganzzahl zurück. Dies ist auch als Popcount
   (Population Count) bekannt. Beispiel:

      >>> n = 19
      >>> bin(n)
      '0b10011'
      >>> n.bit_count()
      3
      >>> (-n).bit_count()
      3

   Äquivalent zu:

      def bit_count(self):
          return bin(self).count("1")

   Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)

   Gibt ein Byte-Array zurück, das eine Ganzzahl darstellt.

   >>> (1024).to_bytes(2, byteorder='big')
   b'\x04\x00'
   >>> (1024).to_bytes(10, byteorder='big')
   b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
   >>> (-1024).to_bytes(10, byteorder='big', signed=True)
   b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
   >>> x = 1000
   >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
   b'\xe8\x03'

   Die Ganzzahl wird mit *length* Bytes dargestellt, standardmäßig 1.
   Ein "OverflowError" wird ausgelöst, wenn die Ganzzahl mit der
   angegebenen Anzahl von Bytes nicht darstellbar ist.

   Das Argument *byteorder* bestimmt die Bytereihenfolge, die zur
   Darstellung der Ganzzahl verwendet wird, und ist standardmäßig
   ""big"". Wenn *byteorder* ""big"" ist, befindet sich das
   höchstwertige Byte am Anfang des Byte-Arrays. Wenn *byteorder*
   ""little"" ist, befindet sich das höchstwertige Byte am Ende des
   Byte-Arrays.

   Das Argument *signed* bestimmt, ob das Zweierkomplement zur
   Darstellung der Ganzzahl verwendet wird. Wenn *signed* den Wert
   "False" hat und eine negative Ganzzahl übergeben wird, wird ein
   "OverflowError" ausgelöst. Der Standardwert für *signed* ist
   "False".

   Die Standardwerte können verwendet werden, um eine Ganzzahl bequem
   in ein einzelnes Byte-Objekt umzuwandeln:

      >>> (65).to_bytes()
      b'A'

   Wenn die Standardargumente verwendet werden, sollte jedoch nicht
   versucht werden, einen Wert größer als 255 zu konvertieren, da
   sonst ein "OverflowError" auftritt.

   Äquivalent zu:

      def to_bytes(n, length=1, byteorder='big', signed=False):
          if byteorder == 'little':
              order = range(length)
          elif byteorder == 'big':
              order = reversed(range(length))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          return bytes((n >> i*8) & 0xff for i in order)

   Added in version 3.2.

   Geändert in Version 3.11: Standard-Argumentwerte für "length" und
   "byteorder" hinzugefügt.

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)

   Gibt die Ganzzahl zurück, die durch das angegebene Byte-Array
   dargestellt wird.

   >>> int.from_bytes(b'\x00\x10', byteorder='big')
   16
   >>> int.from_bytes(b'\x00\x10', byteorder='little')
   4096
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
   -1024
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
   64512
   >>> int.from_bytes([255, 0, 0], byteorder='big')
   16711680

   Das Argument *bytes* muss entweder ein *Byte-ähnliches Objekt* oder
   ein Iterable sein, das Bytes erzeugt.

   Das Argument *byteorder* bestimmt die Bytereihenfolge, die zur
   Darstellung der Ganzzahl verwendet wird, und ist standardmäßig
   ""big"". Wenn *byteorder* ""big"" ist, befindet sich das
   höchstwertige Byte am Anfang des Byte-Arrays. Wenn *byteorder*
   ""little"" ist, befindet sich das höchstwertige Byte am Ende des
   Byte-Arrays. Um die native Bytereihenfolge des Host-Systems
   abzufragen, verwende "sys.byteorder" als Wert für die
   Bytereihenfolge.

   Das Argument *signed* gibt an, ob das Zweierkomplement zur
   Darstellung der Ganzzahl verwendet wird.

   Äquivalent zu:

      def from_bytes(bytes, byteorder='big', signed=False):
          if byteorder == 'little':
              little_ordered = list(bytes)
          elif byteorder == 'big':
              little_ordered = list(reversed(bytes))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          n = sum(b << i*8 for i, b in enumerate(little_ordered))
          if signed and little_ordered and (little_ordered[-1] & 0x80):
              n -= 1 << 8*len(little_ordered)

          return n

   Added in version 3.2.

   Geändert in Version 3.11: Standard-Argumentwert für "byteorder"
   hinzugefügt.

int.as_integer_ratio()

   Gibt ein Paar von Ganzzahlen zurück, deren Verhältnis gleich der
   ursprünglichen Ganzzahl ist und einen positiven Nenner hat. Das
   Ganzzahlverhältnis von ganzen Zahlen ist immer die Ganzzahl als
   Zähler und "1" als Nenner.

   Added in version 3.8.

int.is_integer()

   Gibt "True" zurück. Existiert für Duck-Typing-Kompatibilität mit
   "float.is_integer()".

   Added in version 3.12.


Zusätzliche Methoden zu Float
-----------------------------

Der Typ float implementiert die "numbers.Real" *abstrakte
Basisklasse*. float verfügt außerdem über die folgenden zusätzlichen
Methoden.

float.as_integer_ratio()

   Gibt ein Paar von Ganzzahlen zurück, deren Verhältnis exakt dem
   ursprünglichen Float entspricht. Das Verhältnis ist vollständig
   gekürzt und hat einen positiven Nenner. Löst bei unendlichen Werten
   einen "OverflowError" und bei NaNs einen "ValueError" aus.

float.is_integer()

   Gibt "True" zurück, wenn die Float-Instanz endlich mit ganzzahligem
   Wert ist, andernfalls "False":

      >>> (-2.0).is_integer()
      True
      >>> (3.2).is_integer()
      False

Zwei Methoden unterstützen die Konvertierung in und aus Hexadezimal-
Strings. Da Pythons Floats intern als Binärzahlen gespeichert werden,
beinhaltet das Konvertieren eines Floats in oder aus einem *dezimalen*
String üblicherweise einen kleinen Rundungsfehler. Im Gegensatz dazu
ermöglichen Hexadezimal-Strings die exakte Darstellung und
Spezifikation von Gleitkommazahlen. Dies kann beim Debuggen und bei
numerischen Berechnungen nützlich sein.

float.hex()

   Gibt eine Darstellung einer Gleitkommazahl als Hexadezimal-String
   zurück. Für endliche Gleitkommazahlen enthält diese Darstellung
   immer ein führendes "0x" sowie ein nachgestelltes "p" und einen
   Exponenten.

classmethod float.fromhex(s)

   Klassenmethode, die den durch einen Hexadezimal-String *s*
   dargestellten Float zurückgibt. Der String *s* darf führende und
   nachgestellte Leerzeichen enthalten.

Beachte, dass "float.hex()" eine Instanzmethode ist, während
"float.fromhex()" eine Klassenmethode ist.

Ein Hexadezimal-String hat die Form:

   [sign] ['0x'] integer ['.' fraction] ['p' exponent]

wobei das optionale "sign" entweder "+" oder "-" sein kann, "integer"
und "fraction" Zeichenketten aus Hexadezimalziffern sind und
"exponent" eine Dezimal-Ganzzahl mit einem optionalen führenden
Vorzeichen ist. Groß-/Kleinschreibung wird nicht unterschieden, und es
muss mindestens eine Hexadezimalziffer entweder im Ganzzahl- oder im
Nachkommateil vorhanden sein. Diese Syntax ähnelt der in Abschnitt
6.4.4.2 des C99-Standards spezifizierten Syntax sowie der ab Java 1.5
verwendeten Syntax. Insbesondere ist die Ausgabe von "float.hex()" als
hexadezimales Gleitkomma-Literal in C- oder Java-Code verwendbar, und
von C's "%a"-Formatzeichen oder Java's "Double.toHexString" erzeugte
Hexadezimal-Strings werden von "float.fromhex()" akzeptiert.

Beachte, dass der Exponent dezimal statt hexadezimal geschrieben wird
und die Zweierpotenz angibt, mit der der Koeffizient multipliziert
wird. Beispielsweise stellt der Hexadezimal-String "0x3.a7p10" die
Gleitkommazahl "(3 + 10./16 + 7./16**2) * 2.0**10" bzw. "3740.0" dar:

   >>> float.fromhex('0x3.a7p10')
   3740.0

Die Anwendung der umgekehrten Konvertierung auf "3740.0" ergibt einen
anderen Hexadezimal-String, der dieselbe Zahl darstellt:

   >>> float.hex(3740.0)
   '0x1.d380000000000p+11'


Hashing von numerischen Typen
-----------------------------

Für Zahlen "x" und "y", möglicherweise unterschiedlichen Typs, ist es
erforderlich, dass "hash(x) == hash(y)" gilt, wann immer "x == y" ist
(weitere Details finden sich in der Dokumentation zur Methode
"__hash__()"). Zur einfachen Implementierung und Effizienz über eine
Vielzahl numerischer Typen hinweg (einschließlich "int", "float",
"decimal.Decimal" und "fractions.Fraction") basiert Pythons Hash für
numerische Typen auf einer einzigen mathematischen Funktion, die für
jede rationale Zahl definiert ist und somit für alle Instanzen von
"int" und "fractions.Fraction" sowie alle endlichen Instanzen von
"float" und "decimal.Decimal" gilt. Im Wesentlichen ist diese Funktion
durch eine Reduktion modulo "P" für eine feste Primzahl "P" gegeben.
Der Wert von "P" wird Python als das Attribut "modulus" von
"sys.hash_info" zur Verfügung gestellt.

Derzeit ist die verwendete Primzahl "P = 2**31 - 1" auf Systemen mit
32-Bit-C-Longs und "P = 2**61 - 1" auf Systemen mit 64-Bit-C-Longs.

Hier sind die Regeln im Detail:

* Wenn "x = m / n" eine nicht-negative rationale Zahl ist und "n"
  nicht durch "P" teilbar ist, definiere "hash(x)" als "m * invmod(n,
  P) % P", wobei "invmod(n, P)" das Inverse von "n" modulo "P"
  liefert.

* Wenn "x = m / n" eine nicht-negative rationale Zahl ist und "n"
  durch "P" teilbar ist ("m" jedoch nicht), dann hat "n" kein Inverses
  modulo "P" und die obige Regel greift nicht; in diesem Fall
  definiere "hash(x)" als den konstanten Wert "sys.hash_info.inf".

* Wenn "x = m / n" eine negative rationale Zahl ist, definiere
  "hash(x)" als "-hash(-x)". Wenn der resultierende Hash "-1" ist,
  ersetze ihn durch "-2".

* Die speziellen Werte "sys.hash_info.inf" und "-sys.hash_info.inf"
  werden als Hash-Werte für positive bzw. negative Unendlichkeit
  verwendet.

* Für eine "complex"-Zahl "z" werden die Hash-Werte des Real- und
  Imaginärteils kombiniert, indem "hash(z.real) + sys.hash_info.imag *
  hash(z.imag)" berechnet wird, reduziert modulo
  "2**sys.hash_info.width", sodass das Ergebnis in
  "range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))"
  liegt. Wenn das Ergebnis wiederum "-1" ist, wird es durch "-2"
  ersetzt.

Zur Verdeutlichung der obigen Regeln folgt hier ein Beispiel-Python-
Code, der dem eingebauten Hash entspricht, zur Berechnung des Hash-
Werts einer rationalen Zahl, eines "float" oder "complex":

   import sys, math

   def hash_fraction(m, n):
       """Compute the hash of a rational number m / n.

       Assumes m and n are integers, with n positive.
       Equivalent to hash(fractions.Fraction(m, n)).

       """
       P = sys.hash_info.modulus
       # Remove common factors of P.  (Unnecessary if m and n already coprime.)
       while m % P == n % P == 0:
           m, n = m // P, n // P

       if n % P == 0:
           hash_value = sys.hash_info.inf
       else:
           # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
           # pow(n, P-2, P) gives the inverse of n modulo P.
           hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
       if m < 0:
           hash_value = -hash_value
       if hash_value == -1:
           hash_value = -2
       return hash_value

   def hash_float(x):
       """Compute the hash of a float x."""

       if math.isnan(x):
           return object.__hash__(x)
       elif math.isinf(x):
           return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
       else:
           return hash_fraction(*x.as_integer_ratio())

   def hash_complex(z):
       """Compute the hash of a complex number z."""

       hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
       # do a signed reduction modulo 2**sys.hash_info.width
       M = 2**(sys.hash_info.width - 1)
       hash_value = (hash_value & (M - 1)) - (hash_value & M)
       if hash_value == -1:
           hash_value = -2
       return hash_value


Boolescher Typ – "bool"
=======================

Booleans stellen Wahrheitswerte dar. Der Typ "bool" hat genau zwei
konstante Instanzen: "True" und "False".

Die eingebaute Funktion "bool()" konvertiert jeden Wert in einen
booleschen Wert, sofern der Wert als Wahrheitswert interpretiert
werden kann (siehe Abschnitt Wahrheitswert-Prüfung oben).

Verwende für logische Operationen die booleschen Operatoren "and",
"or" und "not". Wenn die bitweisen Operatoren "&", "|", "^" auf zwei
Booleans angewendet werden, geben sie einen booleschen Wert zurück,
der den logischen Operationen "and", "or" und "xor" entspricht.
Allerdings sollten die logischen Operatoren "and", "or" und "!="
gegenüber "&", "|" und "^" bevorzugt werden.

Veraltet ab Version 3.12: Die Verwendung des bitweisen
Inversionsoperators "~" ist veraltet und wird in Python 3.16 einen
Fehler auslösen.

"bool" ist eine Unterklasse von "int" (siehe Numerische Typen --- int,
float, complex). In vielen numerischen Kontexten verhalten sich
"False" und "True" wie die Ganzzahlen 0 bzw. 1. Es wird jedoch davon
abgeraten, sich darauf zu verlassen; konvertiere stattdessen explizit
mittels "int()".


Iterator-Typen
==============

Python unterstützt ein Konzept der Iteration über Container. Dies ist
mittels zweier verschiedener Methoden implementiert, mit denen
benutzerdefinierte Klassen Iteration unterstützen können. Sequenzen,
die weiter unten detaillierter beschrieben werden, unterstützen die
Iterationsmethoden immer.

Für Container-Objekte muss eine Methode definiert werden, um
Unterstützung für *Iterierbares* bereitzustellen:

container.__iter__()

   Gibt ein *Iterator*-Objekt zurück. Das Objekt muss das unten
   beschriebene Iterator-Protokoll unterstützen. Wenn ein Container
   verschiedene Arten der Iteration unterstützt, können zusätzliche
   Methoden bereitgestellt werden, um gezielt Iteratoren für diese
   Iterationsarten anzufordern. (Ein Beispiel für ein Objekt, das
   mehrere Formen der Iteration unterstützt, wäre eine Baumstruktur,
   die sowohl Breitensuche als auch Tiefensuche unterstützt.) Diese
   Methode entspricht dem "tp_iter"-Slot der Typstruktur für Python-
   Objekte in der Python/C-API.

Die Iterator-Objekte selbst müssen die folgenden zwei Methoden
unterstützen, die zusammen das *Iterator-Protokoll* bilden:

iterator.__iter__()

   Gibt das *Iterator*-Objekt selbst zurück. Dies ist erforderlich,
   damit sowohl Container als auch Iteratoren mit den Anweisungen
   "for" und "in" verwendet werden können. Diese Methode entspricht
   dem "tp_iter"-Slot der Typstruktur für Python-Objekte in der
   Python/C-API.

iterator.__next__()

   Gibt das nächste Element aus dem *Iterator* zurück. Wenn keine
   weiteren Elemente vorhanden sind, wird die Ausnahme "StopIteration"
   ausgelöst. Diese Methode entspricht dem "tp_iternext"-Slot der
   Typstruktur für Python-Objekte in der Python/C-API.

Python definiert mehrere Iterator-Objekte, um die Iteration über
allgemeine und spezifische Sequenztypen, Dictionaries und andere
spezialisiertere Formen zu unterstützen. Die konkreten Typen sind über
ihre Implementierung des Iterator-Protokolls hinaus nicht von
Bedeutung.

Sobald die Methode "__next__()" eines Iterators "StopIteration"
auslöst, muss sie dies auch bei nachfolgenden Aufrufen weiterhin tun.
Implementierungen, die diese Eigenschaft nicht einhalten, gelten als
fehlerhaft.


Generator-Typen
---------------

Pythons *Generatoren* bieten eine bequeme Möglichkeit, das Iterator-
Protokoll zu implementieren. Wenn die Methode "__iter__()" eines
Container-Objekts als Generator implementiert ist, gibt sie
automatisch ein Iterator-Objekt (technisch gesehen ein Generator-
Objekt) zurück, das die Methoden "__iter__()" und "__next__()"
bereitstellt. Weitere Informationen über Generatoren finden sich in
der Dokumentation zum yield-Ausdruck.


Sequenztypen – "list", "tuple", "range"
=======================================

Es gibt drei grundlegende Sequenztypen: Listen, Tupel und Range-
Objekte. Zusätzliche Sequenztypen, die für die Verarbeitung von
Binärdaten und Text-Strings ausgelegt sind, werden in eigenen
Abschnitten beschrieben.


Gemeinsame Sequenzoperationen
-----------------------------

Die Operationen in der folgenden Tabelle werden von den meisten
Sequenztypen unterstützt, sowohl veränderlichen als auch
unveränderlichen. Die ABC "collections.abc.Sequence" wird
bereitgestellt, um die korrekte Implementierung dieser Operationen auf
benutzerdefinierten Sequenztypen zu erleichtern.

Diese Tabelle listet die Sequenzoperationen auf, sortiert nach
aufsteigender Priorität. In der Tabelle sind *s* und *t* Sequenzen
desselben Typs, *n*, *i*, *j* und *k* sind Ganzzahlen und *x* ist ein
beliebiges Objekt, das alle durch *s* auferlegten Typ- und
Wertebeschränkungen erfüllt.

Die Operationen "in" und "not in" haben die gleiche Priorität wie die
Vergleichsoperationen. Die Operationen "+" (Verkettung) und "*"
(Wiederholung) haben die gleiche Priorität wie die entsprechenden
numerischen Operationen. [3]

+----------------------------+----------------------------------+------------+
| Operation                  | Ergebnis                         | Hinweise   |
|============================|==================================|============|
| "x in s"                   | "True", wenn ein Element von *s* | (1)        |
|                            | gleich *x* ist, andernfalls      |            |
|                            | "False"                          |            |
+----------------------------+----------------------------------+------------+
| "x not in s"               | "False", wenn ein Element von    | (1)        |
|                            | *s* gleich *x* ist, andernfalls  |            |
|                            | "True"                           |            |
+----------------------------+----------------------------------+------------+
| "s + t"                    | die Verkettung von *s* und *t*   | (6)(7)     |
+----------------------------+----------------------------------+------------+
| "s * n" oder "n * s"       | äquivalent dazu, *s* *n*-mal zu  | (2)(7)     |
|                            | sich selbst zu addieren          |            |
+----------------------------+----------------------------------+------------+
| "s[i]"                     | *i*-tes Element von *s*,         | (3)(8)     |
|                            | beginnend bei 0                  |            |
+----------------------------+----------------------------------+------------+
| "s[i:j]"                   | Ausschnitt (Slice) von *s* von   | (3)(4)     |
|                            | *i* bis *j*                      |            |
+----------------------------+----------------------------------+------------+
| "s[i:j:k]"                 | Ausschnitt (Slice) von *s* von   | (3)(5)     |
|                            | *i* bis *j* mit Schrittweite *k* |            |
+----------------------------+----------------------------------+------------+
| "len(s)"                   | Länge von *s*                    |            |
+----------------------------+----------------------------------+------------+
| "min(s)"                   | kleinstes Element von *s*        |            |
+----------------------------+----------------------------------+------------+
| "max(s)"                   | größtes Element von *s*          |            |
+----------------------------+----------------------------------+------------+

Sequenzen desselben Typs unterstützen auch Vergleiche. Insbesondere
werden Tupel und Listen lexikografisch verglichen, indem entsprechende
Elemente verglichen werden. Das bedeutet, dass für Gleichheit jedes
Element gleich sein muss und die beiden Sequenzen denselben Typ sowie
dieselbe Länge haben müssen. (Vollständige Details finden sich unter
Vergleiche in der Sprachreferenz.)

Vorwärts- und Rückwärts-Iteratoren über veränderliche Sequenzen
greifen über einen Index auf Werte zu. Dieser Index läuft auch dann
weiter vorwärts (oder rückwärts), wenn die zugrunde liegende Sequenz
verändert wird. Der Iterator endet erst, wenn ein "IndexError" oder
ein "StopIteration" auftritt (oder wenn der Index unter null fällt).

Hinweise:

1. Während die Operationen "in" und "not in" im allgemeinen Fall nur
   für einfache Enthaltenseinsprüfungen verwendet werden, nutzen
   einige spezialisierte Sequenzen (wie "str", "bytes" und
   "bytearray") diese auch für Teilsequenz-Prüfungen:

      >>> "gg" in "eggs"
      True

2. Werte von *n* kleiner als "0" werden als "0" behandelt (was eine
   leere Sequenz desselben Typs wie *s* ergibt). Beachte, dass
   Elemente in der Sequenz *s* nicht kopiert werden; sie werden
   mehrfach referenziert. Dies führt bei Python-Einsteigern häufig zu
   Missverständnissen; betrachte:

      >>> lists = [[]] * 3
      >>> lists
      [[], [], []]
      >>> lists[0].append(3)
      >>> lists
      [[3], [3], [3]]

   Hierbei ist "[[]]" eine ein-elementige Liste, die eine leere Liste
   enthält, sodass alle drei Elemente von "[[]] * 3" Referenzen auf
   diese eine leere Liste sind. Die Änderung eines beliebigen Elements
   von "lists" ändert diese einzelne Liste. Auf folgende Weise lässt
   sich eine Liste aus verschiedenen Listen erstellen:

      >>> lists = [[] for i in range(3)]
      >>> lists[0].append(3)
      >>> lists[1].append(5)
      >>> lists[2].append(7)
      >>> lists
      [[3], [5], [7]]

   Weitere Erklärungen finden sich im FAQ-Eintrag How do I create a
   multidimensional list?.

3. Wenn *i* oder *j* negativ ist, ist der Index relativ zum Ende der
   Sequenz *s*: "len(s) + i" oder "len(s) + j" wird eingesetzt.
   Beachte jedoch, dass "-0" weiterhin "0" ist.

4. Der Slice von *s* von *i* bis *j* ist definiert als die Folge der
   Elemente mit Index *k*, für die "i <= k < j" gilt.

   * Wird *i* weggelassen oder ist "None", wird "0" verwendet.

   * Wird *j* weggelassen oder ist "None", wird "len(s)" verwendet.

   * Ist *i* oder *j* kleiner als "-len(s)", wird "0" verwendet.

   * Ist *i* oder *j* größer als "len(s)", wird "len(s)" verwendet.

   * Ist *i* größer oder gleich *j*, ist der Slice leer.

5. Der Ausschnitt von *s* von *i* bis *j* mit Schrittweite *k* ist
   definiert als die Sequenz von Elementen mit dem Index "x = i +
   n*k", sodass "0 <= n < (j-i)/k" gilt. Mit anderen Worten: Die
   Indizes sind "i", "i+k", "i+2*k", "i+3*k" usw., und enden, wenn *j*
   erreicht wird (jedoch ohne *j* einzuschließen). Wenn *k* positiv
   ist, werden *i* und *j* auf "len(s)" reduziert, falls sie größer
   sind. Wenn *k* negativ ist, werden *i* und *j* auf "len(s) - 1"
   reduziert, falls sie größer sind. Wenn *i* oder *j* weggelassen
   werden oder "None" sind, werden sie zu "End"-Werten (welches Ende
   hängt vom Vorzeichen von *k* ab). Beachte: *k* darf nicht null
   sein. Wenn *k* "None" ist, wird es wie "1" behandelt.

6. Das Verketten unveränderlicher Sequenzen führt immer zu einem neuen
   Objekt. Das bedeutet, dass der Aufbau einer Sequenz durch
   wiederholte Verkettung quadratische Laufzeitkosten bezogen auf die
   Gesamtlänge der Sequenz verursacht. Um lineare Laufzeitkosten zu
   erzielen, sollte auf eine der folgenden Alternativen ausgewichen
   werden:

   * beim Verketten von "str"-Objekten kann eine Liste aufgebaut und
     am Ende "str.join()" verwendet werden, oder es wird in eine
     "io.StringIO"-Instanz geschrieben und deren Wert nach Abschluss
     abgerufen

   * beim Verketten von "bytes"-Objekten kann ähnlich "bytes.join()"
     oder "io.BytesIO" verwendet werden, oder es kann eine In-Place-
     Verkettung mit einem "bytearray"-Objekt durchgeführt werden.
     "bytearray"-Objekte sind veränderlich und besitzen einen
     effizienten Speicherüberallokations-Mechanismus

   * beim Verketten von "tuple"-Objekten stattdessen eine "list"
     erweitern

   * für andere Typen die entsprechende Klassendokumentation
     konsultieren

7. Einige Sequenztypen (wie "range") unterstützen nur
   Elementsequenzen, die bestimmten Mustern folgen, und unterstützen
   daher weder Sequenzverkettung noch Wiederholung.

8. Ein "IndexError" wird ausgelöst, wenn *i* außerhalb des
   Sequenzbereichs liegt.

-[ Sequenzmethoden ]-

Sequenztypen unterstützen außerdem die folgenden Methoden:

sequence.count(value, /)

   Gibt die Gesamtzahl der Vorkommen von *value* in *sequence* zurück.

sequence.index(value[, start[, stop]])

   Gibt den Index des ersten Vorkommens von *value* in *sequence*
   zurück.

   Löst einen "ValueError" aus, wenn *value* nicht in *sequence*
   gefunden wird.

   Die Argumente *start* oder *stop* ermöglichen die effiziente Suche
   in Teilabschnitten der Sequenz, beginnend bei *start* und endend
   bei *stop*. Dies entspricht in etwa "start +
   sequence[start:stop].index(value)", jedoch ohne Kopieren von Daten.

   Vorsicht:

     Nicht alle Sequenztypen unterstützen die Übergabe der Argumente
     *start* und *stop*.


Unveränderliche Sequenztypen
----------------------------

Die einzige Operation, die unveränderliche Sequenztypen im Allgemeinen
implementieren und die von veränderlichen Sequenztypen nicht
implementiert wird, ist die Unterstützung für die eingebaute Funktion
"hash()".

Diese Unterstützung ermöglicht es, unveränderliche Sequenzen wie etwa
"tuple"-Instanzen als Schlüssel in "dict" zu verwenden und in "set"-
sowie "frozenset"-Instanzen zu speichern.

Der Versuch, eine unveränderliche Sequenz zu hashen, die nicht
hashbare Werte enthält, führt zu einem "TypeError".


Veränderliche Sequenztypen
--------------------------

Die Operationen in der folgenden Tabelle sind auf veränderlichen
Sequenztypen definiert. Die ABC "collections.abc.MutableSequence" wird
bereitgestellt, um die korrekte Implementierung dieser Operationen auf
benutzerdefinierten Sequenztypen zu erleichtern.

In der Tabelle ist *s* eine Instanz eines veränderlichen Sequenztyps,
*t* ein beliebiges iterierbares Objekt und *x* ein beliebiges Objekt,
das alle durch *s* vorgegebenen Typ- und Wertebeschränkungen erfüllt
(beispielsweise akzeptiert "bytearray" nur Ganzzahlen, die die
Wertebeschränkung "0 <= x <= 255" erfüllen).

+--------------------------------+----------------------------------+-----------------------+
| Operation                      | Ergebnis                         | Hinweise              |
|================================|==================================|=======================|
| "s[i] = x"                     | Element *i* von *s* wird durch   |                       |
|                                | *x* ersetzt                      |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i]"                     | entfernt Element *i* von *s*     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j] = t"                   | Ausschnitt von *s* von *i* bis   |                       |
|                                | *j* wird durch den Inhalt des    |                       |
|                                | Iterables *t* ersetzt            |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j]"                   | entfernt die Elemente von        |                       |
|                                | "s[i:j]" aus der Liste           |                       |
|                                | (entspricht "s[i:j] = []")       |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j:k] = t"                 | die Elemente von "s[i:j:k]"      | (1)                   |
|                                | werden durch diejenigen von *t*  |                       |
|                                | ersetzt                          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j:k]"                 | entfernt die Elemente von        |                       |
|                                | "s[i:j:k]" aus der Liste         |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s += t"                       | erweitert *s* um den Inhalt von  |                       |
|                                | *t* (weitgehend identisch mit    |                       |
|                                | "s[len(s):len(s)] = t")          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s *= n"                       | aktualisiert *s* mit dem *n*-mal | (2)                   |
|                                | wiederholten Inhalt              |                       |
+--------------------------------+----------------------------------+-----------------------+

Hinweise:

1. Wenn *k* ungleich "1" ist, muss *t* dieselbe Länge haben wie der
   Ausschnitt, den es ersetzt.

2. Der Wert *n* ist eine Ganzzahl oder ein Objekt, das "__index__()"
   implementiert. Null und negative Werte von *n* leeren die Sequenz.
   Elemente in der Sequenz werden nicht kopiert; sie werden mehrfach
   referenziert, wie für "s * n" unter Gemeinsame Sequenzoperationen
   erläutert.

-[ Methoden veränderlicher Sequenzen ]-

Veränderliche Sequenztypen unterstützen außerdem die folgenden
Methoden:

sequence.append(value, /)

   Hängt *value* an das Ende der Sequenz an. Dies entspricht
   "seq[len(seq):len(seq)] = [value]".

sequence.clear()

   Added in version 3.3.

   Entfernt alle Elemente aus *sequence*. Dies entspricht "del
   sequence[:]".

sequence.copy()

   Added in version 3.3.

   Erzeugt eine flache Kopie (Shallow Copy) von *sequence*. Dies
   entspricht "sequence[:]".

   Hinweis:

     Die Methode "copy()" ist nicht Teil der "MutableSequence"-Klasse
     "ABC", wird jedoch von den meisten konkreten veränderlichen
     Sequenztypen bereitgestellt.

sequence.extend(iterable, /)

   Erweitert *sequence* um den Inhalt von *iterable*. Dies entspricht
   weitgehend "seq[len(seq):len(seq)] = iterable".

sequence.insert(index, value, /)

   Fügt *value* am angegebenen *index* in *sequence* ein. Dies
   entspricht "sequence[index:index] = [value]".

sequence.pop(index=-1, /)

   Ruft das Element am *index* ab und entfernt es gleichzeitig aus
   *sequence*. Standardmäßig wird das letzte Element in *sequence*
   entfernt und zurückgegeben.

sequence.remove(value, /)

   Entfernt das erste Element aus *sequence*, für das "sequence[i] ==
   value" gilt.

   Löst einen "ValueError" aus, wenn *value* nicht in *sequence*
   gefunden wird.

sequence.reverse()

   Kehrt die Elemente von *sequence* in-place um. Diese Methode spart
   Speicherplatz beim Umkehren einer großen Sequenz. Um daran zu
   erinnern, dass sie über Seiteneffekte arbeitet, gibt sie "None"
   zurück.


Listen
------

Listen sind veränderliche Sequenzen, die typischerweise zum Speichern
von Sammlungen homogener Elemente verwendet werden (wobei der genaue
Grad der Ähnlichkeit je nach Anwendung variiert).

class list(iterable=(), /)

   Listen können auf verschiedene Arten konstruiert werden:

   * Verwendung eines Paars eckiger Klammern für die leere Liste: "[]"

   * Verwendung eckiger Klammern mit kommagetrennten Elementen: "[a]",
     "[a, b, c]"

   * Verwendung einer List-Comprehension: "[x for x in iterable]"

   * Verwendung des Typ-Konstruktors: "list()" oder "list(iterable)"

   Der Konstruktor baut eine Liste auf, deren Elemente mit den
   Elementen von *iterable* und in derselben Reihenfolge
   übereinstimmen. *iterable* kann entweder eine Sequenz, ein
   Container mit Iterationsunterstützung oder ein Iterator-Objekt
   sein. Wenn *iterable* bereits eine Liste ist, wird eine Kopie
   erstellt und zurückgegeben, ähnlich wie bei "iterable[:]".
   Beispielsweise gibt "list('abc')" "['a', 'b', 'c']" zurück und
   "list( (1, 2, 3) )" liefert "[1, 2, 3]". Wenn kein Argument
   übergeben wird, erzeugt der Konstruktor eine neue leere Liste,
   "[]".

   Viele weitere Operationen erzeugen ebenfalls Listen, einschließlich
   der eingebauten Funktion "sorted()".

   Listen sind hinsichtlich des Typs ihrer Elemente generisch.

   Listen implementieren alle gemeinsamen und veränderlichen
   Sequenzoperationen. Listen bieten außerdem die folgende zusätzliche
   Methode:

   sort(*, key=None, reverse=False)

      Diese Methode sortiert die Liste in-place und verwendet
      ausschließlich "<"-Vergleiche zwischen Elementen. Ausnahmen
      werden nicht unterdrückt – falls eine Vergleichsoperation
      fehlschlägt, schlägt der gesamte Sortiervorgang fehl (und die
      Liste bleibt voraussichtlich in einem teilweise modifizierten
      Zustand zurück).

      "sort()" akzeptiert zwei Argumente, die nur als Schlüsselwort-
      Argumente übergeben werden können (keyword-only arguments):

      *key* gibt eine Funktion mit einem Argument an, die verwendet
      wird, um aus jedem Listenelement einen Vergleichsschlüssel zu
      extrahieren (zum Beispiel "key=str.lower"). Der Schlüssel für
      jedes Element in der Liste wird einmalig berechnet und dann für
      den gesamten Sortiervorgang verwendet. Der Standardwert von
      "None" bedeutet, dass Listenelemente direkt sortiert werden,
      ohne einen separaten Schlüsselwert zu berechnen.

      Das Hilfswerkzeug "functools.cmp_to_key()" steht zur Verfügung,
      um eine *cmp*-Funktion im Stil von Python 2.x in eine
      *key*-Funktion umzuwandeln.

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

      Diese Methode modifiziert die Sequenz in-place zur
      Platzersparnis beim Sortieren einer großen Sequenz. Um daran zu
      erinnern, dass sie über Seiteneffekte arbeitet, gibt sie nicht
      die sortierte Sequenz zurück (verwende "sorted()", um explizit
      eine neue sortierte Listeninstanz anzufordern).

      Die Methode "sort()" ist garantiert stabil. Eine Sortierung ist
      stabil, wenn sie garantiert, dass die relative Reihenfolge von
      Elementen, die als gleich verglichen werden, nicht verändert
      wird – dies ist hilfreich für Sortierungen in mehreren
      Durchläufen (zum Beispiel zuerst nach Abteilung, dann nach
      Gehaltsstufe sortieren).

      Für Sortierbeispiele und ein kurzes Sortier-Tutorial siehe
      Sorting Techniques.

      Während eine Liste sortiert wird, ist die Auswirkung von
      Versuchen, die Liste zu verändern oder auch nur zu inspizieren,
      undefiniert. Die C-Implementierung von Python lässt die Liste
      für die Dauer als leer erscheinen und löst einen "ValueError"
      aus, wenn sie feststellen kann, dass die Liste während eines
      Sortiervorgangs verändert wurde.


Tupel
-----

Tupel sind unveränderliche Sequenzen, die typischerweise zum Speichern
von Sammlungen heterogener Daten verwendet werden (wie etwa die
2-Tupel, die von der eingebauten Funktion "enumerate()" erzeugt
werden). Tupel werden auch in Fällen verwendet, in denen eine
unveränderliche Sequenz homogener Daten benötigt wird (wie etwa zur
Ermöglichung der Speicherung in einer "set"- oder "dict"-Instanz).

class tuple(iterable=(), /)

   Tupel können auf verschiedene Arten konstruiert werden:

   * Verwendung eines Paars runder Klammern für das leere Tupel: "()"

   * Verwendung eines nachgestellten Kommas für ein Tupel mit einem
     Element(Singleton-Tupel): "a," oder "(a,)"

   * Trennen von Elementen durch Kommas: "a, b, c" oder "(a, b, c)"

   * Verwendung der eingebauten Funktion "tuple()": "tuple()" oder
     "tuple(iterable)"

   Der Konstruktor baut ein Tupel auf, dessen Elemente mit den
   Elementen von *iterable* und in derselben Reihenfolge
   übereinstimmen. *iterable* kann entweder eine Sequenz, ein
   Container mit Iterationsunterstützung oder ein Iterator-Objekt
   sein. Wenn *iterable* bereits ein Tupel ist, wird es unverändert
   zurückgegeben. Beispielsweise gibt "tuple('abc')" "('a', 'b', 'c')"
   zurück und "tuple( [1, 2, 3] )" liefert "(1, 2, 3)". Wenn kein
   Argument übergeben wird, erzeugt der Konstruktor ein neues leeres
   Tupel, "()".

   Beachte, dass eigentlich das Komma ein Tupel ausmacht, nicht die
   runden Klammern. Die Klammern sind optional, außer im Fall des
   leeren Tupels oder wenn sie benötigt werden, um syntaktische
   Mehrdeutigkeiten zu vermeiden. Zum Beispiel ist "f(a, b, c)" ein
   Funktionsaufruf mit drei Argumenten, während "f((a, b, c))" ein
   Funktionsaufruf mit einem 3-Tupel als einzigem Argument ist.

   Tupel implementieren alle gemeinsamen Sequenzoperationen.

   Tupel sind hinsichtlich der Typen ihres Inhalts generisch. Weitere
   Informationen findest du in der typing-Dokumentation zum Annotieren
   von Tupeln.

Für heterogene Datensammlungen, bei denen der Zugriff über Namen
verständlicher ist als der Zugriff über Indizes, kann
"collections.namedtuple()" eine passendere Wahl als ein einfaches
Tupel-Objekt sein.


Ranges
------

Der Typ "range" stellt eine unveränderliche Zahlenfolge dar und wird
häufig verwendet, um eine bestimmte Anzahl von Wiederholungen in
"for"-Schleifen auszuführen.

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

   Die Argumente für den Range-Konstruktor müssen Ganzzahlen sein
   (entweder das eingebaute "int" oder jedes Objekt, das die spezielle
   Methode "__index__()" implementiert). Wenn das Argument *step*
   weggelassen wird, ist der Standardwert "1". Wenn das Argument
   *start* weggelassen wird, ist der Standardwert "0". Wenn *step*
   null ist, wird ein "ValueError" ausgelöst.

   Für ein positives *step* werden die Inhalte einer Range "r" durch
   die Formel "r[i] = start + step*i" bestimmt, wobei "i >= 0" und
   "r[i] < stop" gilt.

   Für ein negatives *step* werden die Inhalte der Range weiterhin
   durch die Formel "r[i] = start + step*i" bestimmt, die Bedingungen
   lauten jedoch "i >= 0" und "r[i] > stop".

   Ein Range-Objekt ist leer, wenn "r[0]" die Wertebedingung nicht
   erfüllt. Ranges unterstützen negative Indizes, diese werden jedoch
   als Indizierung vom Ende der durch die positiven Indizes bestimmten
   Sequenz interpretiert.

   Ranges, die absolute Werte größer als "sys.maxsize" enthalten, sind
   zulässig, aber einige Funktionen (wie z. B. "len()") können einen
   "OverflowError" auslösen.

   Range-Beispiele:

      >>> list(range(10))
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> list(range(1, 11))
      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      >>> list(range(0, 30, 5))
      [0, 5, 10, 15, 20, 25]
      >>> list(range(0, 10, 3))
      [0, 3, 6, 9]
      >>> list(range(0, -10, -1))
      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
      >>> list(range(0))
      []
      >>> list(range(1, 0))
      []

   Ranges implementieren alle gemeinsamen Sequenzoperationen mit
   Ausnahme von Verkettung und Wiederholung (aufgrund der Tatsache,
   dass Range-Objekte nur Sequenzen darstellen können, die einem
   strengen Muster folgen, und Wiederholung sowie Verkettung dieses
   Muster in der Regel verletzen würden).

   start

      Der Wert des Parameters *start* (oder "0", falls der Parameter
      nicht übergeben wurde)

   stop

      Der Wert des Parameters *stop*

   step

      Der Wert des Parameters *step* (oder "1", falls der Parameter
      nicht übergeben wurde)

Der Vorteil des Typs "range" gegenüber einer regulären "list" oder
einem "tuple" besteht darin, dass ein "range"-Objekt unabhängig von
der Größe des dargestellten Bereichs immer dieselbe (geringe)
Speichermenge belegt (da es nur die Werte "start", "stop" und "step"
speichert und einzelne Elemente sowie Teilbereiche erst bei Bedarf
berechnet).

Range-Objekte implementieren die ABC "collections.abc.Sequence" und
bieten Funktionen wie Prüfung von Enthaltensein, Elementindex-Abfrage,
Slicing und Unterstützung für negative Indizes (siehe Sequenztypen –
list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Das Prüfen von Range-Objekten auf Gleichheit mit "==" und "!="
vergleicht sie als Sequenzen. Das bedeutet, dass zwei Range-Objekte
als gleich gelten, wenn sie dieselbe Wertesequenz darstellen.
(Beachte, dass zwei gleichwertige Range-Objekte unterschiedliche
Attribute "start", "stop" und "step" haben können, wie zum Beispiel
"range(0) == range(2, 1, 3)" oder "range(0, 3, 2) == range(0, 4, 2)".)

Geändert in Version 3.2: Implementierung der Sequence-ABC.
Unterstützung von Slicing und negativen Indizes. Prüfung von
"int"-Objekten auf Mitgliedschaft in konstanter Zeit anstatt über alle
Elemente zu iterieren.

Geändert in Version 3.3: Definition von '==' und '!=', um Range-
Objekte basierend auf der von ihnen definierten Wertesequenz zu
vergleichen (anstatt auf Basis der Objektidentität).Die Attribute
"start", "stop" und "step" hinzugefügt.

Siehe auch:

  * Das linspace recipe zeigt, wie eine Lazy-Version von Range
    implementiert werden kann, die für Gleitkomma-Anwendungen geeignet
    ist.


Textsequenztyp – "str"
======================

Textdaten werden in Python mit "str"-Objekten oder *Strings*
gehandhabt. Strings sind unveränderliche Sequenzen von Unicode-
Codepunkten. String-Literale werden auf verschiedene Arten
geschrieben:

* Einfache Anführungszeichen: "'allows embedded "double" quotes'"

* Doppelte Anführungszeichen: ""allows embedded 'single' quotes""

* Dreifache Anführungszeichen: "'''Three single quotes'''", """"Three
  double quotes""""

Mit dreifachen Anführungszeichen versehene Strings können sich über
mehrere Zeilen erstrecken – alle zugehörigen Whitespaces werden in das
String-Literal aufgenommen.

String-Literale, die Teil eines einzelnen Ausdrucks sind und nur
Whitespaces zwischen sich haben, werden implizit in ein einziges
String-Literal umgewandelt. Das heißt: "("spam " "eggs") == "spam
eggs"".

Siehe String and Bytes literals für mehr Details zu den verschiedenen
Formen von String-Literalen, einschließlich der unterstützten Escape-
Sequenzen und des Präfixes "r" ("raw"), das die meisten Verarbeitungen
von Escape-Sequenzen deaktiviert.

Strings können auch aus anderen Objekten mithilfe des
"str"-Konstruktors erzeugt werden.

Da es keinen separaten "Zeichen"-Typ gibt, erzeugt die Indizierung
eines Strings Strings der Länge 1. Das heißt, für einen nicht-leeren
String *s* gilt: "s[0] == s[0:1]".

Es gibt auch keinen veränderlichen String-Typ, aber "str.join()" oder
"io.StringIO" können verwendet werden, um Strings effizient aus
mehreren Fragmenten zusammenzusetzen.

Geändert in Version 3.3: Aus Gründen der Abwärtskompatibilität mit der
Python-2-Reihe ist das Präfix "u" bei String-Literalen wieder erlaubt.
Es hat keine Auswirkung auf die Bedeutung von String-Literalen und
kann nicht mit dem Präfix "r" kombiniert werden.

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

   Gibt eine String-Version von *object* zurück. Wenn *object* nicht
   angegeben ist, wird der leere String zurückgegeben. Andernfalls
   hängt das Verhalten von "str()" davon ab, ob *encoding* oder
   *errors* wie folgt angegeben sind.

   Wenn weder *encoding* noch *errors* angegeben sind, gibt
   "str(object)" "type(object).__str__(object)" zurück, was die
   "informelle" oder schön druckbare String-Repräsentation von
   *object* ist. Für String-Objekte ist dies der String selbst. Wenn
   *object* keine "__str__()"-Methode besitzt, fällt "str()" darauf
   zurück, "repr(object)" zurückzugeben.

   Wenn mindestens eines von *encoding* oder *errors* angegeben ist,
   sollte *object* ein *Byte-ähnliches Objekt* sein (z. B. "bytes"
   oder "bytearray"). In diesem Fall, wenn *object* ein "bytes"- (oder
   "bytearray"-)Objekt ist, entspricht "str(bytes, encoding, errors)"
   dem Ausdruck "bytes.decode(encoding, errors)". Andernfalls wird das
   dem Pufferobjekt zugrunde liegende Bytes-Objekt abgerufen, bevor
   "bytes.decode()" aufgerufen wird. Siehe Binäre Sequenztypen –
   bytes, bytearray, memoryview und Buffer-Protokoll für Informationen
   über Pufferobjekte.

   Das Übergeben eines "bytes"-Objekts an "str()" ohne die Argumente
   *encoding* oder *errors* fällt unter den ersten Fall der Rückgabe
   der informellen String-Repräsentation (siehe auch die
   Kommandozeilenoption "-b" von Python). Zum Beispiel:

      >>> str(b'Zoot!')
      "b'Zoot!'"

   Weitere Informationen über die Klasse "str" und ihre Methoden
   finden sich unter Textsequenztyp – str und im nachfolgenden
   Abschnitt String-Methoden. Zur Ausgabe formatierter Strings siehe
   die Abschnitte f-Strings und Syntax für Formatzeichenketten. Siehe
   außerdem den Abschnitt Text Processing Services.


String-Methoden
---------------

Strings implementieren alle gemeinsamen Sequenzoperationen zusammen
mit den nachfolgend beschriebenen zusätzlichen Methoden.

Strings unterstützen außerdem zwei Arten der String-Formatierung: Eine
bietet ein hohes Maß an Flexibilität und Anpassungsmöglichkeiten
(siehe "str.format()", Syntax für Formatzeichenketten und
Benutzerdefinierte String-Formatierung), und die andere basiert auf
der Formatierung im C-"printf"-Stil, die einen engeren Bereich von
Typen abdeckt und etwas schwieriger korrekt zu verwenden ist, aber für
die Fälle, die sie abdeckt, oft schneller ist (String-Formatierung im
printf-Stil).

Der Abschnitt Text Processing Services der Standardbibliothek
behandelt eine Reihe weiterer Module, die verschiedene textbezogene
Hilfsprogramme bereitstellen (einschließlich der Unterstützung
regulärer Ausdrücke im Modul "re").

str.capitalize()

   Gibt eine Kopie des Strings zurück, bei der das erste Zeichen
   großgeschrieben und der Rest kleingeschrieben ist.

   Geändert in Version 3.8: Das erste Zeichen wird nun in Titlecase
   anstelle von Uppercase umgewandelt. Das bedeutet, dass bei Zeichen
   wie Digraphen nur der erste Buchstabe großgeschrieben wird und
   nicht das gesamte Zeichen.

str.casefold()

   Gibt eine casefold-Kopie des Strings zurück. Casefold-Strings
   können für Abgleiche ohne Berücksichtigung der
   Groß-/Kleinschreibung verwendet werden.

   Casefolding ähnelt der Kleinschreibung, ist jedoch aggressiver, da
   es darauf abzielt, alle Groß-/Kleinschreibungsunterschiede in einer
   Zeichenkette zu entfernen. Zum Beispiel entspricht der deutsche
   Kleinbuchstabe "'ß'" dem Ausdruck ""ss"". Da er bereits klein
   geschrieben ist, würde "lower()" bei "'ß'" nichts bewirken;
   "casefold()" wandelt ihn in ""ss"" um. Zum Beispiel:

      >>> 'straße'.lower()
      'straße'
      >>> 'straße'.casefold()
      'strasse'

   The casefolding algorithm is described in section 3.13 'Default
   Case Folding' of the Unicode Standard.

   Added in version 3.3.

str.center(width, fillchar=' ', /)

   Gibt den String zentriert in einem String der Länge *width* zurück.
   Das Auffüllen erfolgt mit dem angegebenen *fillchar* (Standard ist
   ein ASCII-Leerzeichen). Der ursprüngliche String wird
   zurückgegeben, wenn *width* kleiner oder gleich "len(s)" ist. Zum
   Beispiel:

      >>> 'Python'.center(10)
      '  Python  '
      >>> 'Python'.center(10, '-')
      '--Python--'
      >>> 'Python'.center(4)
      'Python'

str.count(sub[, start[, end]])

   Gibt die Anzahl der nicht überlappenden Vorkommen des Teilstrings
   *sub* im Bereich [*start*, *end*] zurück. Die optionalen Argumente
   *start* und *end* werden wie in der Slice-Notation interpretiert.

   Wenn *sub* leer ist, wird die Anzahl der leeren Strings zwischen
   den Zeichen zurückgegeben, was der Länge des Strings plus eins
   entspricht. Zum Beispiel:

      >>> 'spam, spam, spam'.count('spam')
      3
      >>> 'spam, spam, spam'.count('spam', 5)
      2
      >>> 'spam, spam, spam'.count('spam', 5, 10)
      1
      >>> 'spam, spam, spam'.count('eggs')
      0
      >>> 'spam, spam, spam'.count('')
      17

str.encode(encoding='utf-8', errors='strict')

   Gibt den als "bytes" kodierten String zurück.

   *encoding* ist standardmäßig "'utf-8'"; siehe Standard Encodings
   für mögliche Werte.

   *errors* steuert, wie Kodierungsfehler behandelt werden. Bei
   "'strict'" (Standardwert) wird eine "UnicodeError"-Ausnahme
   ausgelöst. Andere mögliche Werte sind "'ignore'", "'replace'",
   "'xmlcharrefreplace'", "'backslashreplace'" und jeder andere über
   "codecs.register_error()" registrierte Name. Siehe Error Handlers
   für Details.

   Aus Leistungsgründen wird der Wert von *errors* nicht auf
   Gültigkeit geprüft, es sei denn, es tritt tatsächlich ein
   Kodierungsfehler auf, der Python Development Mode ist aktiviert
   oder es wird ein Debug-Build verwendet. Zum Beispiel:

      >>> encoded_str_to_bytes = 'Python'.encode()
      >>> type(encoded_str_to_bytes)
      <class 'bytes'>
      >>> encoded_str_to_bytes
      b'Python'

   Geändert in Version 3.1: Unterstützung für Schlüsselwort-Argumente
   hinzugefügt.

   Geändert in Version 3.9: Der Wert des Arguments *errors* wird nun
   im Python Development Mode und im Debug-Modus geprüft.

str.endswith(suffix[, start[, end]])

   Gibt "True" zurück, wenn der String mit dem angegebenen *suffix*
   endet, andernfalls "False". *suffix* kann auch ein Tupel von zu
   suchenden Suffixen sein. Mit optionalem *start* wird ab dieser
   Position geprüft. Mit optionalem *end* wird der Vergleich an dieser
   Position beendet. Die Verwendung von *start* und *end* entspricht
   "str[start:end].endswith(suffix)". Zum Beispiel:

      >>> 'Python'.endswith('on')
      True
      >>> 'a tuple of suffixes'.endswith(('at', 'in'))
      False
      >>> 'a tuple of suffixes'.endswith(('at', 'es'))
      True
      >>> 'Python is amazing'.endswith('is', 0, 9)
      True

   Siehe auch "startswith()" und "removesuffix()".

str.expandtabs(tabsize=8)

   Gibt eine Kopie des Strings zurück, bei der alle Tabulatorzeichen
   abhängig von der aktuellen Spalte und der angegebenen
   Tabulatorgröße durch ein oder mehrere Leerzeichen ersetzt werden.
   Tabulatorpositionen treten alle *tabsize* Zeichen auf (Standardwert
   ist 8, was Tabulatorpositionen in den Spalten 0, 8, 16 usw.
   ergibt). Um den String zu expandieren, wird die aktuelle Spalte auf
   null gesetzt und der String Zeichen für Zeichen durchlaufen. Wenn
   das Zeichen ein Tabulator ("\t") ist, werden ein oder mehrere
   Leerzeichen in das Ergebnis eingefügt, bis die aktuelle Spalte der
   nächsten Tabulatorposition entspricht. (Das Tabulatorzeichen selbst
   wird nicht kopiert.) Wenn das Zeichen ein Zeilenumbruch ("\n") oder
   Wagenrücklauf ("\r") ist, wird es kopiert und die aktuelle Spalte
   auf null zurückgesetzt. Jedes andere Zeichen wird unverändert
   kopiert und die aktuelle Spalte um eins erhöht, unabhängig davon,
   wie das Zeichen bei der Ausgabe dargestellt wird. Zum Beispiel:

      >>> '01\t012\t0123\t01234'.expandtabs()
      '01      012     0123    01234'
      >>> '01\t012\t0123\t01234'.expandtabs(4)
      '01  012 0123    01234'
      >>> print('01\t012\n0123\t01234'.expandtabs(4))
      01  012
      0123    01234

str.find(sub[, start[, end]])

   Gibt den niedrigsten Index im String zurück, an dem der Teilstring
   *sub* innerhalb des Slices "s[start:end]" gefunden wird. Die
   optionalen Argumente *start* und *end* werden wie in der Slice-
   Notation interpretiert. Gibt "-1" zurück, wenn *sub* nicht gefunden
   wird. Zum Beispiel:

      >>> 'spam, spam, spam'.find('sp')
      0
      >>> 'spam, spam, spam'.find('sp', 5)
      6

   Siehe auch "rfind()" und "index()".

   Bemerkung:

     Die Methode "find()" sollte nur verwendet werden, wenn die
     Position von *sub* benötigt wird. Um zu prüfen, ob *sub* ein
     Teilstring ist oder nicht, verwende den Operator "in":

        >>> 'Py' in 'Python'
        True

str.format(*args, **kwargs)

   Führt eine Zeichenketten-Formatierungsoperation aus. Die
   Zeichenkette, auf der diese Methode aufgerufen wird, kann literalen
   Text oder durch geschweifte Klammern "{}" abgegrenzte
   Ersetzungsfelder enthalten. Jedes Ersetzungsfeld enthält entweder
   den numerischen Index eines Positionsarguments oder den Namen eines
   Schlüsselwortarguments. Gibt eine Kopie der Zeichenkette zurück, in
   der jedes Ersetzungsfeld durch den String-Wert des entsprechenden
   Arguments ersetzt wird. Zum Beispiel:

      >>> "The sum of 1 + 2 is {0}".format(1+2)
      'The sum of 1 + 2 is 3'
      >>> "The sum of {a} + {b} is {answer}".format(answer=1+2, a=1, b=2)
      'The sum of 1 + 2 is 3'
      >>> "{1} expects the {0} Inquisition!".format("Spanish", "Nobody")
      'Nobody expects the Spanish Inquisition!'

   Siehe Syntax für Formatzeichenketten für eine Beschreibung der
   verschiedenen Formatierungsoptionen, die in Format-Strings
   angegeben werden können.

   Bemerkung:

     Beim Formatieren einer Zahl ("int", "float", "complex",
     "decimal.Decimal" und Unterklassen) mit dem Typ "n" (z. B.:
     "'{:n}'.format(1234)") setzt die Funktion vorübergehend die
     Locale "LC_CTYPE" auf die Locale "LC_NUMERIC", um die Felder
     "decimal_point" und "thousands_sep" von "localeconv()" zu
     dekodieren, falls diese Nicht-ASCII oder länger als 1 Byte sind
     und sich die Locale "LC_NUMERIC" von der Locale "LC_CTYPE"
     unterscheidet. Diese vorübergehende Änderung betrifft auch andere
     Threads.

   Geändert in Version 3.7: Beim Formatieren einer Zahl mit dem Typ
   "n" setzt die Funktion in einigen Fällen vorübergehend die Locale
   "LC_CTYPE" auf die Locale "LC_NUMERIC".

str.format_map(mapping, /)

   Ähnlich wie "str.format(**mapping)", außer dass "mapping" direkt
   verwendet und nicht in ein "dict" kopiert wird. Dies ist nützlich,
   wenn "mapping" beispielsweise eine Unterklasse von dict ist:

   >>> class Default(dict):
   ...     def __missing__(self, key):
   ...         return key
   ...
   >>> '{name} was born in {country}'.format_map(Default(name='Guido'))
   'Guido was born in country'

   Added in version 3.2.

str.index(sub[, start[, end]])

   Wie "find()", löst jedoch einen "ValueError" aus, wenn der
   Teilstring nicht gefunden wird. Zum Beispiel:

      >>> 'spam, spam, spam'.index('spam')
      0
      >>> 'spam, spam, spam'.index('eggs')
      Traceback (most recent call last):
        File "<python-input-0>", line 1, in <module>
          'spam, spam, spam'.index('eggs')
          ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
      ValueError: substring not found

   Siehe auch "rindex()".

str.isalnum()

   Gibt "True" zurück, wenn alle Zeichen im String alphanumerisch sind
   und mindestens ein Zeichen vorhanden ist, andernfalls "False". Ein
   Zeichen "c" ist alphanumerisch, wenn eines der folgenden "True"
   zurückgibt: "c.isalpha()", "c.isdecimal()", "c.isdigit()" oder
   "c.isnumeric()". Zum Beispiel:

      >>> 'abc123'.isalnum()
      True
      >>> 'abc123!@#'.isalnum()
      False
      >>> ''.isalnum()
      False
      >>> ' '.isalnum()
      False

str.isalpha()

   Return "True" if all characters in the string are alphabetic and
   there is at least one character, "False" otherwise.  Alphabetic
   characters are those characters defined in the Unicode character
   database as "Letter", i.e., those with general category property
   being one of "Lm", "Lt", "Lu", "Ll", or "Lo".  Note that this is
   different from the Alphabetic property defined in section 4.10
   'Letters, Alphabetic, and Ideographic' of the Unicode Standard. For
   example:

      >>> 'Letters and spaces'.isalpha()
      False
      >>> 'LettersOnly'.isalpha()
      True
      >>> 'µ'.isalpha()  # nicht-ASCII-Zeichen können ebenfalls als alphabetisch gelten
      True

   Siehe Unicode Properties.

str.isascii()

   Gibt "True" zurück, wenn der String leer ist oder alle Zeichen im
   String ASCII sind, andernfalls "False". ASCII-Zeichen haben
   Codepunkte im Bereich U+0000-U+007F. Zum Beispiel:

      >>> 'ASCII characters'.isascii()
      True
      >>> 'µ'.isascii()
      False

   Added in version 3.7.

str.isdecimal()

   Gibt "True" zurück, wenn alle Zeichen im String Dezimalzeichen sind
   und mindestens ein Zeichen vorhanden ist, andernfalls "False".
   Dezimalzeichen sind solche, die zur Bildung von Zahlen zur Basis 10
   verwendet werden können, z. B. U+0660, ARABISCH-INDISCHE ZIFFER
   NULL. Formal ist ein Dezimalzeichen ein Zeichen in der allgemeinen
   Unicode-Kategorie "Nd". Zum Beispiel:

      >>> '0123456789'.isdecimal()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isdecimal()  # arabisch-indische Ziffern null bis neun
      True
      >>> 'alphabetic'.isdecimal()
      False

str.isdigit()

   Gibt "True" zurück, wenn alle Zeichen in der Zeichenkette Ziffern
   sind und mindestens ein Zeichen vorhanden ist, andernfalls "False".
   Zu den Ziffern zählen Dezimalzeichen sowie Ziffern, die eine
   besondere Behandlung erfordern, wie zum Beispiel hochgestellte
   Kompatibilitätsziffern. Dies umfasst Ziffern, die nicht zur Bildung
   von Zahlen im Zehnersystem verwendet werden können, wie die
   Kharosthi-Zahlen. Formal ist eine Ziffer ein Zeichen mit dem
   Eigenschaftswert Numeric_Type=Digit oder Numeric_Type=Decimal.

   Zum Beispiel:

      >>> '0123456789'.isdigit()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isdigit()  # arabisch-indische Ziffern null bis neun
      True
      >>> '⅕'.isdigit()  # gemeiner Bruch ein Fünftel
      False
      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
      (False, True, True)

   Siehe auch "isdecimal()" und "isnumeric()".

str.isidentifier()

   Gibt "True" zurück, wenn der String ein gültiger Bezeichner gemäß
   der Sprachdefinition, Abschnitt Identifiers and keywords, ist.

   Mit "keyword.iskeyword()" kann getestet werden, ob der String "s"
   ein reservierter Bezeichner wie "def" und "class" ist.

   Beispiel:

      >>> from keyword import iskeyword

      >>> 'hello'.isidentifier(), iskeyword('hello')
      (True, False)
      >>> 'def'.isidentifier(), iskeyword('def')
      (True, True)

str.islower()

   Gibt "True" zurück, wenn alle Zeichen mit Groß-/Kleinschreibung [4]
   im String kleingeschrieben sind und mindestens ein Zeichen mit
   Groß-/Kleinschreibung vorhanden ist, andernfalls "False".

str.isnumeric()

   Gibt "True" zurück, wenn alle Zeichen im String numerische Zeichen
   sind und mindestens ein Zeichen vorhanden ist, andernfalls "False".
   Numerische Zeichen umfassen Ziffernzeichen und alle Zeichen, die
   die Unicode-Eigenschaft eines numerischen Werts haben, z. B.
   U+2155, GEWÖHNLICHER BRUCH EIN FÜNFTEL. Formal sind numerische
   Zeichen diejenigen mit dem Eigenschaftswert Numeric_Type=Digit,
   Numeric_Type=Decimal oder Numeric_Type=Numeric.

      >>> '0123456789'.isnumeric()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # arabisch-indische Ziffern null bis neun
      True
      >>> '⅕'.isnumeric()  # gemeiner Bruch ein Fünftel
      True
      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
      (False, True, True)

   Siehe auch "isdecimal()" und "isdigit()".

str.isprintable()

   Gibt "True" zurück, wenn alle Zeichen im String druckbar sind,
   "False", wenn er mindestens ein nicht druckbares Zeichen enthält.

   Hier bedeutet "druckbar", dass das Zeichen für "repr()" zur
   Verwendung in seiner Ausgabe geeignet ist; "nicht druckbar"
   bedeutet, dass "repr()" bei eingebauten Typen das Zeichen
   hexadezimal maskiert. Dies hat keinen Einfluss auf die Behandlung
   von Strings, die in "sys.stdout" oder "sys.stderr" geschrieben
   werden.

   Die druckbaren Zeichen sind diejenigen, die in der Unicode-
   Zeichendatenbank (siehe "unicodedata") eine allgemeine Kategorie in
   der Gruppe Buchstabe, Markierung, Zahl, Interpunktion oder Symbol
   (L, M, N, P oder S) haben; zuzüglich des ASCII-Leerzeichens 0x20.
   Nicht druckbare Zeichen sind diejenigen in der Gruppe Trennzeichen
   oder Andere (Z oder C), mit Ausnahme des ASCII-Leerzeichens.

   Zum Beispiel:

      >>> ''.isprintable(), ' '.isprintable()
      (True, True)
      >>> '\t'.isprintable(), '\n'.isprintable()
      (False, False)

   Siehe auch "isspace()".

str.isspace()

   Gibt "True" zurück, wenn der String nur Whitespace-Zeichen enthält
   und mindestens ein Zeichen vorhanden ist, andernfalls "False".

   Zum Beispiel:

      >>> ''.isspace()
      False
      >>> ' '.isspace()
      True
      >>> '\t\n'.isspace() # TAB and BREAK LINE
      True
      >>> '\u3000'.isspace() # IDEOGRAPHIC SPACE
      True

   Ein Zeichen ist *Whitespace*, wenn in der Unicode-Zeichendatenbank
   (siehe "unicodedata") entweder seine allgemeine Kategorie "Zs"
   ("Separator, space") ist oder seine bidirektionale Klasse eine von
   "WS", "B" oder "S" ist.

   Siehe auch "isprintable()".

str.istitle()

   Gibt "True" zurück, wenn der String im Titlecase vorliegt und
   mindestens ein Zeichen vorhanden ist, zum Beispiel dürfen
   Großbuchstaben nur auf Zeichen ohne Groß-/Kleinschreibung folgen
   und Kleinbuchstaben nur auf solche mit Groß-/Kleinschreibung. Gibt
   andernfalls "False" zurück.

   Zum Beispiel:

      >>> 'Spam, Spam, Spam'.istitle()
      True
      >>> 'spam, spam, spam'.istitle()
      False
      >>> 'SPAM, SPAM, SPAM'.istitle()
      False

   Siehe auch "title()".

str.isupper()

   Gibt "True" zurück, wenn alle Zeichen mit Groß-/Kleinschreibung [4]
   im String großgeschrieben sind und mindestens ein Zeichen mit
   Groß-/Kleinschreibung vorhanden ist, andernfalls "False".

   >>> 'BANANA'.isupper()
   True
   >>> 'banana'.isupper()
   False
   >>> 'baNana'.isupper()
   False
   >>> ' '.isupper()
   False

str.join(iterable, /)

   Gibt einen String zurück, der die Verkettung der Strings in
   *iterable* ist. Ein "TypeError" wird ausgelöst, wenn sich Nicht-
   String-Werte in *iterable* befinden, einschließlich
   "bytes"-Objekten. Das Trennzeichen zwischen den Elementen ist der
   String, der diese Methode bereitstellt.

      >>> ', '.join(['spam', 'spam', 'spam'])
      'spam, spam, spam'
      >>> '-'.join('Python')
      'P-y-t-h-o-n'

   Siehe auch "split()".

str.ljust(width, fillchar=' ', /)

   Gibt den String linksbündig in einem String der Länge *width*
   zurück. Das Auffüllen erfolgt mit dem angegebenen *fillchar*
   (Standard ist ein ASCII-Leerzeichen). Der ursprüngliche String wird
   zurückgegeben, wenn *width* kleiner oder gleich "len(s)" ist.

   Zum Beispiel:

      >>> 'Python'.ljust(10)
      'Python    '
      >>> 'Python'.ljust(10, '.')
      'Python....'
      >>> 'Monty Python'.ljust(10, '.')
      'Monty Python'

   Siehe auch "rjust()".

str.lower()

   Gibt eine Kopie des Strings zurück, bei der alle Zeichen mit
   Groß-/Kleinschreibung [4] in Kleinbuchstaben umgewandelt wurden.
   Zum Beispiel:

      >>> 'Lower Method Example'.lower()
      'lower method example'

   The lowercasing algorithm used is described in section 3.13
   'Default Case Folding' of the Unicode Standard.

str.lstrip(chars=None, /)

   Gibt eine Kopie des Strings zurück, bei der führende Zeichen
   entfernt wurden. Das Argument *chars* ist ein String, der die Menge
   der zu entfernenden Zeichen angibt. Wenn es weggelassen wird oder
   "None" ist, entfernt das Argument *chars* standardmäßig
   Whitespaces. Das Argument *chars* ist kein Präfix; vielmehr werden
   alle Kombinationen seiner Werte abgeschnitten:

      >>> '   spacious   '.lstrip()
      'spacious   '
      >>> 'www.example.com'.lstrip('cmowz.')
      'example.com'

   Siehe "str.removeprefix()" für eine Methode, die einen einzelnen
   Präfix-String anstelle einer Menge aller Zeichen entfernt. Zum
   Beispiel:

      >>> 'Arthur: three!'.lstrip('Arthur: ')
      'ee!'
      >>> 'Arthur: three!'.removeprefix('Arthur: ')
      'three!'

static str.maketrans(dict, /)
static str.maketrans(from, to, remove='', /)

   Diese statische Methode gibt eine Übersetzungstabelle zurück, die
   für "str.translate()" verwendet werden kann.

   Wenn es nur ein Argument gibt, muss es ein Dictionary sein, das
   Unicode-Ordinalzahlen (Ganzzahlen) oder Zeichen (Strings der Länge
   1) auf Unicode-Ordinalzahlen, Strings (beliebiger Länge) oder
   "None" abbildet. Zeichenschlüssel werden anschließend in
   Ordinalzahlen umgewandelt.

   Wenn es zwei Argumente gibt, müssen diese gleich lange Strings
   sein, und im resultierenden Dictionary wird jedes Zeichen in *from*
   auf das Zeichen an derselben Position in *to* abgebildet. Wenn es
   ein drittes Argument gibt, muss dieses ein String sein, dessen
   Zeichen im Ergebnis auf "None" abgebildet werden.

str.partition(sep, /)

   Teilt den String beim ersten Vorkommen von *sep* und gibt ein
   3-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen
   selbst und den Teil nach dem Trennzeichen enthält. Wenn das
   Trennzeichen nicht gefunden wird, wird ein 3-Tupel zurückgegeben,
   das den String selbst enthält, gefolgt von zwei leeren Strings.

   Zum Beispiel:

      >>> 'Monty Python'.partition(' ')
      ('Monty', ' ', 'Python')
      >>> "Monty Python's Flying Circus".partition(' ')
      ('Monty', ' ', "Python's Flying Circus")
      >>> 'Monty Python'.partition('-')
      ('Monty Python', '', '')

   Siehe auch "rpartition()".

str.removeprefix(prefix, /)

   Wenn der String mit dem Präfix-String *prefix* beginnt, wird
   "string[len(prefix):]" zurückgegeben. Andernfalls wird eine Kopie
   des ursprünglichen Strings zurückgegeben:

      >>> 'TestHook'.removeprefix('Test')
      'Hook'
      >>> 'BaseTestCase'.removeprefix('Test')
      'BaseTestCase'

   Added in version 3.9.

   Siehe auch "removesuffix()" und "startswith()".

str.removesuffix(suffix, /)

   Wenn der String mit dem Suffix-String *suffix* endet und dieses
   *suffix* nicht leer ist, wird "string[:-len(suffix)]"
   zurückgegeben. Andernfalls wird eine Kopie des ursprünglichen
   Strings zurückgegeben:

      >>> 'MiscTests'.removesuffix('Tests')
      'Misc'
      >>> 'TmpDirMixin'.removesuffix('Tests')
      'TmpDirMixin'

   Added in version 3.9.

   Siehe auch "removeprefix()" und "endswith()".

str.replace(old, new, /, count=-1)

   Gibt eine Kopie des Strings zurück, bei der alle Vorkommen des
   Teilstrings *old* durch *new* ersetzt wurden. Wenn *count*
   angegeben ist, werden nur die ersten *count* Vorkommen ersetzt.
   Wenn *count* nicht angegeben oder "-1" ist, werden alle Vorkommen
   ersetzt. Zum Beispiel:

      >>> 'spam, spam, spam'.replace('spam', 'eggs')
      'eggs, eggs, eggs'
      >>> 'spam, spam, spam'.replace('spam', 'eggs', 1)
      'eggs, spam, spam'

   Geändert in Version 3.13: *count* wird nun als Schlüsselwort-
   Argument unterstützt.

str.rfind(sub[, start[, end]])

   Gibt den höchsten Index im String zurück, an dem der Teilstring
   *sub* gefunden wird, sodass *sub* innerhalb von "s[start:end]"
   enthalten ist. Die optionalen Argumente *start* und *end* werden
   wie in der Slice-Notation interpretiert. Gibt im Fehlerfall "-1"
   zurück. Zum Beipiel:

      >>> 'spam, spam, spam'.rfind('sp')
      12
      >>> 'spam, spam, spam'.rfind('sp', 0, 10)
      6

   Siehe auch "find()" und "rindex()".

str.rindex(sub[, start[, end]])

   Wie "rfind()", löst jedoch einen "ValueError" aus, wenn der
   Teilstring *sub* nicht gefunden wird. Zum Beipsiel:

      >>> 'spam, spam, spam'.rindex('spam')
      12
      >>> 'spam, spam, spam'.rindex('eggs')
      Traceback (most recent call last):
        File "<stdin-0>", line 1, in <module>
          'spam, spam, spam'.rindex('eggs')
          ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
      ValueError: substring not found

   Siehe auch "index()" und "find()".

str.rjust(width, fillchar=' ', /)

   Gibt den String rechtsbündig in einem String der Länge *width*
   zurück. Das Auffüllen erfolgt mit dem angegebenen *fillchar*
   (Standard ist ein ASCII-Leerzeichen). Der ursprüngliche String wird
   zurückgegeben, wenn *width* kleiner oder gleich "len(s)" ist.

   Zum Beispiel:

      >>> 'Python'.rjust(10)
      '    Python'
      >>> 'Python'.rjust(10, '.')
      '....Python'
      >>> 'Monty Python'.rjust(10, '.')
      'Monty Python'

   Siehe auch "ljust()" und "zfill()".

str.rpartition(sep, /)

   Teilt den String beim letzten Vorkommen von *sep* und gibt ein
   3-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen
   selbst und den Teil nach dem Trennzeichen enthält. Wenn das
   Trennzeichen nicht gefunden wird, wird ein 3-Tupel zurückgegeben,
   das zwei leere Strings enthält, gefolgt von dem String selbst.

   Zum Beispiel:

      >>> 'Monty Python'.rpartition(' ')
      ('Monty', ' ', 'Python')
      >>> "Monty Python's Flying Circus".rpartition(' ')
      ("Monty Python's Flying", ' ', 'Circus')
      >>> 'Monty Python'.rpartition('-')
      ('', '', 'Monty Python')

   Siehe auch "partition()".

str.rsplit(sep=None, maxsplit=-1)

   Gibt eine Liste der Wörter in der Zeichenkette zurück, wobei *sep*
   als Trennzeichenfolge verwendet wird. Wird *maxsplit* angegeben,
   werden höchstens *maxsplit* Aufteilungen vorgenommen, und zwar die
   *am weitesten rechts stehenden*. Ist *sep* nicht angegeben oder
   "None", ist jede "Whitespace"-Zeichenfolge ein Trennzeichen.
   Abgesehen davon, dass von rechts aufgeteilt wird, verhält sich
   "rsplit()" wie "split()", was weiter unten im Detail beschrieben
   wird.

str.rstrip(chars=None, /)

   Gibt eine Kopie der Zeichenkette zurück, bei der die abschließenden
   Zeichen entfernt wurden. Das Argument *chars* ist eine
   Zeichenkette, die die Menge der zu entfernenden Zeichen angibt.
   Wird es weggelassen oder ist "None", entfernt das Argument *chars*
   standardmäßig Whitespace. Das Argument *chars* ist kein Suffix;
   stattdessen werden alle Kombinationen seiner Werte entfernt. Zum
   Beispiel:

      >>> '   spacious   '.rstrip()
      '   spacious'
      >>> 'mississippi'.rstrip('ipz')
      'mississ'

   Siehe "removesuffix()" für eine Methode, die einen einzelnen
   Suffix-String anstelle einer Menge aller Zeichen entfernt. Zum
   Beispiel:

      >>> 'Monty Python'.rstrip(' Python')
      'M'
      >>> 'Monty Python'.removesuffix(' Python')
      'Monty'

   Siehe auch "strip()".

str.split(sep=None, maxsplit=-1)

   Gibt eine Liste der Wörter im String zurück, wobei *sep* als Trenn-
   String verwendet wird. Wenn *maxsplit* angegeben ist, werden
   höchstens *maxsplit* Trennungen vorgenommen (die Liste hat somit
   höchstens "maxsplit+1" Elemente). Wenn *maxsplit* nicht angegeben
   oder "-1" ist, gibt es keine Begrenzung für die Anzahl der
   Trennungen (alle möglichen Trennungen werden vorgenommen).

   Wenn *sep* angegeben ist, werden aufeinanderfolgende Trennzeichen
   nicht zusammengefasst und als Begrenzung leerer Strings betrachtet
   (beispielsweise gibt "'1,,2'.split(',')" "['1', '', '2']" zurück).
   Das Argument *sep* kann aus mehreren Zeichen als einzelnem
   Trennzeichen bestehen (um anhand mehrerer Trennzeichen zu teilen,
   verwende "re.split()"). Das Teilen eines leeren Strings mit einem
   angegebenen Trennzeichen gibt "['']" zurück.

   Zum Beispiel:

      >>> '1,2,3'.split(',')
      ['1', '2', '3']
      >>> '1,2,3'.split(',', maxsplit=1)
      ['1', '2,3']
      >>> '1,2,,3,'.split(',')
      ['1', '2', '', '3', '']
      >>> '1<>2<>3<4'.split('<>')
      ['1', '2', '3<4']

   Ist *sep* nicht angegeben oder "None", wird ein anderer
   Aufteilungsalgorithmus angewendet: Folgen aufeinanderfolgender
   "Whitespace"-Zeichen werden als ein einzelnes Trennzeichen
   betrachtet, und das Ergebnis enthält keine leeren Zeichenketten am
   Anfang oder Ende, wenn die Zeichenkette führenden oder
   abschließenden Whitespace hat. Folglich gibt das Aufteilen einer
   leeren Zeichenkette oder einer Zeichenkette, die nur aus Whitespace
   besteht, mit einem "None"-Trennzeichen "[]" zurück.

   Zum Beispiel:

      >>> '1 2 3'.split()
      ['1', '2', '3']
      >>> '1 2 3'.split(maxsplit=1)
      ['1', '2 3']
      >>> '   1   2   3   '.split()
      ['1', '2', '3']

   Wenn *sep* nicht angegeben ist oder "None" entspricht und
   *maxsplit* "0" ist, werden nur führende Folgen aufeinanderfolgender
   Whitespaces berücksichtigt.

   Zum Beispiel:

      >>> "".split(None, 0)
      []
      >>> "   ".split(None, 0)
      []
      >>> "   foo   ".split(maxsplit=0)
      ['foo   ']

   See also "join()" and "rsplit()".

str.splitlines(keepends=False)

   Gibt eine Liste der Zeilen im String zurück, getrennt an den
   Zeilenbegrenzungen. Zeilenumbrüche sind nicht in der Ergebnisliste
   enthalten, es sei denn, *keepends* ist angegeben und wahr.

   Diese Methode teilt an den folgenden Zeilenbegrenzungen.
   Insbesondere sind die Begrenzungen eine Obermenge von *universellen
   Zeilenenden*.

   +-------------------------+-------------------------------+
   | Darstellung             | Beschreibung                  |
   |=========================|===============================|
   | "\n"                    | Zeilenvorschub (Line Feed)    |
   +-------------------------+-------------------------------+
   | "\r"                    | Wagenrücklauf (Carriage       |
   |                         | Return)                       |
   +-------------------------+-------------------------------+
   | "\r\n"                  | Wagenrücklauf +               |
   |                         | Zeilenvorschub                |
   +-------------------------+-------------------------------+
   | "\v" oder "\x0b"        | Vertikaler Tabulator (Line    |
   |                         | Tabulation)                   |
   +-------------------------+-------------------------------+
   | "\f" oder "\x0c"        | Seitenvorschub (Form Feed)    |
   +-------------------------+-------------------------------+
   | "\x1c"                  | Dateitrennzeichen (File       |
   |                         | Separator)                    |
   +-------------------------+-------------------------------+
   | "\x1d"                  | Gruppentrennzeichen (Group    |
   |                         | Separator)                    |
   +-------------------------+-------------------------------+
   | "\x1e"                  | Datensatztrennzeichen (Record |
   |                         | Separator)                    |
   +-------------------------+-------------------------------+
   | "\x85"                  | Nächste Zeile (C1-Steuercode) |
   +-------------------------+-------------------------------+
   | "\u2028"                | Zeilentrennzeichen (Line      |
   |                         | Separator)                    |
   +-------------------------+-------------------------------+
   | "\u2029"                | Absatztrennzeichen (Paragraph |
   |                         | Separator)                    |
   +-------------------------+-------------------------------+

   Geändert in Version 3.2: "\v" und "\f" zur Liste der
   Zeilenbegrenzungen hinzugefügt.

   Zum Beispiel:

      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
      ['ab c', '', 'de fg', 'kl']
      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

   Im Gegensatz zu "split()", wenn ein Trenn-String *sep* angegeben
   ist, gibt diese Methode für den leeren String eine leere Liste
   zurück, und ein abschließender Zeilenumbruch führt nicht zu einer
   zusätzlichen Zeile:

      >>> "".splitlines()
      []
      >>> "One line\n".splitlines()
      ['One line']

   Zum Vergleich liefert "split('\n')":

      >>> ''.split('\n')
      ['']
      >>> 'Two lines\n'.split('\n')
      ['Two lines', '']

str.startswith(prefix[, start[, end]])

   Gibt "True" zurück, wenn der String mit dem *prefix* beginnt,
   andernfalls "False". *prefix* kann auch ein Tupel von zu suchenden
   Präfixen sein. Mit optionalem *start* wird der String ab dieser
   Position geprüft. Mit optionalem *end* wird der Vergleich an dieser
   Position beendet.

   Zum Beispiel:

      >>> 'Python'.startswith('Py')
      True
      >>> 'a tuple of prefixes'.startswith(('at', 'a'))
      True
      >>> 'Python is amazing'.startswith('is', 7)
      True

   Siehe auch "endswith()" und "removeprefix()".

str.strip(chars=None, /)

   Gibt eine Kopie der Zeichenkette zurück, bei der die führenden und
   abschließenden Zeichen entfernt wurden. Das Argument chars ist eine
   Zeichenkette, die die Menge der zu entfernenden Zeichen angibt.
   Wird es weggelassen oder ist None, entfernt das Argument chars
   standardmäßig Whitespace. Das Argument chars ist kein Präfix oder
   Suffix; stattdessen werden alle Kombinationen seiner Werte
   entfernt.

   Whitespace-Zeichen werden durch "str.isspace()" definiert.

   Zum Beispiel:

      >>> '   spacious   '.strip()
      'spacious'
      >>> 'www.example.com'.strip('cmowz.')
      'example'

   Die äußersten führenden und nachgestellten Werte des
   *chars*-Arguments werden vom String entfernt. Zeichen werden am
   führenden Ende entfernt, bis ein Zeichen erreicht wird, das nicht
   in der Zeichenmenge von *chars* enthalten ist. Ein entsprechender
   Vorgang findet am nachgestellten Ende statt.

   Zum Beispiel:

      >>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
      >>> comment_string.strip('.#! ')
      'Section 3.2.1 Issue #32'

   Siehe auch "rstrip()".

str.swapcase()

   Gibt eine Kopie der Zeichenkette zurück, bei der Großbuchstaben in
   Kleinbuchstaben umgewandelt werden und umgekehrt. Zum Beispiel:

      >>> 'Hello World'.swapcase()
      'hELLO wORLD'

   Beachte, dass es nicht zwangsläufig zutrifft, dass
   s.swapcase().swapcase() == s gilt. Zum Beispiel:

      >>> 'straße'.swapcase().swapcase()
      'strasse'

   Siehe auch "str.lower()" und "str.upper()".

str.title()

   Gibt eine Titlecase-Version des Strings zurück, bei der Wörter mit
   einem Großbuchstaben beginnen und die restlichen Zeichen
   kleingeschrieben sind.

   Zum Beispiel:

      >>> 'Hello world'.title()
      'Hello World'

   Der Algorithmus verwendet eine einfache sprachunabhängige
   Definition eines Wortes als Gruppen aufeinanderfolgender
   Buchstaben. Diese Definition funktioniert in vielen Kontexten,
   bedeutet jedoch, dass Apostrophe in Verkürzungen und
   Possessivformen Wortgrenzen bilden, was möglicherweise nicht das
   gewünschte Ergebnis ist:

      >>> "they're bill's friends from the UK".title()
      "They'Re Bill'S Friends From The Uk"

   Die Funktion "string.capwords()" hat dieses Problem nicht, da sie
   Wörter ausschließlich an Leerzeichen trennt.

   Alternativ kann ein Workaround für Apostrophe mithilfe regulärer
   Ausdrücke konstruiert werden:

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0).capitalize(),
      ...                   s)
      ...
      >>> titlecase("they're bill's friends.")
      "They're Bill's Friends."

   Siehe auch "istitle()".

str.translate(table, /)

   Gibt eine Kopie des Strings zurück, in der jedes Zeichen über die
   angegebene Übersetzungstabelle abgebildet wurde. Die Tabelle muss
   ein Objekt sein, das die Indizierung über "__getitem__()"
   implementiert, typischerweise ein *Mapping* oder eine *Sequenz*.
   Wenn es durch eine Unicode-Ordinalzahl (eine Ganzzahl) indiziert
   wird, kann das Tabellenobjekt Folgendes tun: eine Unicode-
   Ordinalzahl oder einen String zurückgeben, um das Zeichen auf ein
   oder mehrere andere Zeichen abzubilden; "None" zurückgeben, um das
   Zeichen aus dem Ergebnis-String zu löschen; oder eine
   "LookupError"-Ausnahme auslösen, um das Zeichen auf sich selbst
   abzubilden.

   Du kannst "str.maketrans()" verwenden, um eine Übersetzungstabelle
   aus Zeichen-zu-Zeichen-Abbildungen in verschiedenen Formaten zu
   erstellen.

   Siehe auch das Modul "codecs" für einen flexibleren Ansatz bei
   benutzerdefinierten Zeichenabbildungen.

str.upper()

   Gibt eine Kopie des Strings zurück, bei der alle Zeichen mit
   Groß-/Kleinschreibung [4] in Großbuchstaben umgewandelt wurden.
   Beachte, dass "s.upper().isupper()" "False" sein kann, wenn "s"
   Zeichen ohne Groß-/Kleinschreibung enthält oder wenn die Unicode-
   Kategorie des/der resultierenden Zeichens/Zeichen nicht "Lu"
   (Buchstabe, Großbuchstabe), sondern z. B. "Lt" (Buchstabe,
   Titlecase) ist.

   The uppercasing algorithm used is described in section 3.13
   'Default Case Folding' of the Unicode Standard.

str.zfill(width, /)

   Gibt eine Kopie des Strings links mit ASCII-"'0'"-Ziffern
   aufgefüllt zurück, um einen String der Länge *width* zu erzeugen.
   Ein führendes Vorzeichenpräfix ("'+'"/"'-'") wird behandelt, indem
   das Füllzeichen *nach* dem Vorzeichenzeichen anstelle davor
   eingefügt wird. Der ursprüngliche String wird zurückgegeben, wenn
   *width* kleiner oder gleich "len(s)" ist.

   Zum Beispiel:

      >>> "42".zfill(5)
      '00042'
      >>> "-42".zfill(5)
      '-0042'

   Siehe auch "rjust()".


Formatierte String-Literale (f-Strings)
---------------------------------------

Added in version 3.6.

Geändert in Version 3.7: "await" und "async for" können in Ausdrücken
innerhalb von f-Strings verwendet werden.

Geändert in Version 3.8: Added the debugging operator ("=")

Geändert in Version 3.12: Viele Einschränkungen für Ausdrücke
innerhalb von f-Strings wurden aufgehoben. Insbesondere sind
verschachtelte Strings, Kommentare und Backslashes nun erlaubt.

An *f-string* (formally a *formatted string literal*) is a string
literal that is prefixed with "f" or "F". This type of string literal
allows embedding arbitrary Python expressions within *replacement
fields*, which are delimited by curly brackets ("{}"). These
expressions are evaluated at runtime, similarly to "str.format()", and
are converted into regular "str" objects. For example:

   >>> who = 'nobody'
   >>> nationality = 'Spanish'
   >>> f'{who.title()} expects the {nationality} Inquisition!'
   'Nobody expects the Spanish Inquisition!'

It is also possible to use a multi line f-string:

   >>> f'''This is a string
   ... on two lines'''
   'This is a string\non two lines'

A single opening curly bracket, "'{'", marks a *replacement field*
that can contain any Python expression:

   >>> nationality = 'Spanish'
   >>> f'The {nationality} Inquisition!'
   'The Spanish Inquisition!'

To include a literal "{" or "}", use a double bracket:

   >>> x = 42
   >>> f'{{x}} is {x}'
   '{x} is 42'

Functions can also be used, and format specifiers:

   >>> from math import sqrt
   >>> f'√2 \N{ALMOST EQUAL TO} {sqrt(2):.5f}'
   '√2 ≈ 1.41421'

Any non-string expression is converted using "str()", by default:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 3)}'
   '1/3'

To use an explicit conversion, use the "!" (exclamation mark)
operator, followed by any of the valid formats, which are:

+------------+----------------+
| Konvertie  | Bedeutung      |
| rung       |                |
|============|================|
| "!a"       | "ascii()"      |
+------------+----------------+
| "!r"       | "repr()"       |
+------------+----------------+
| "!s"       | "str()"        |
+------------+----------------+

Zum Beispiel:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 3)!s}'
   '1/3'
   >>> f'{Fraction(1, 3)!r}'
   'Fraction(1, 3)'
   >>> question = '¿Dónde está el Presidente?'
   >>> print(f'{question!a}')
   '\xbfD\xf3nde est\xe1 el Presidente?'

While debugging it may be helpful to see both the expression and its
value, by using the equals sign ("=") after the expression. This
preserves spaces within the brackets, and can be used with a
converter. By default, the debugging operator uses the "repr()" ("!r")
conversion. For example:

   >>> from fractions import Fraction
   >>> calculation = Fraction(1, 3)
   >>> f'{calculation=}'
   'calculation=Fraction(1, 3)'
   >>> f'{calculation = }'
   'calculation = Fraction(1, 3)'
   >>> f'{calculation = !s}'
   'calculation = 1/3'

Once the output has been evaluated, it can be formatted using a format
specifier following a colon ("':'"). After the expression has been
evaluated, and possibly converted to a string, the "__format__()"
method of the result is called with the format specifier, or the empty
string if no format specifier is given. The formatted result is then
used as the final value for the replacement field. For example:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 7):.6f}'
   '0.142857'
   >>> f'{Fraction(1, 7):_^+10}'
   '___+1/7___'


String-Formatierung im "printf"-Stil
------------------------------------

Bemerkung:

  The formatting operations described here exhibit a variety of quirks
  that lead to a number of common errors (such as failing to display
  tuples and dictionaries correctly).  Using the newer formatted
  string literals, the "str.format()" interface, or template strings
  may help avoid these errors.  Each of these alternatives provides
  their own trade-offs and benefits of simplicity, flexibility, and/or
  extensibility.

String-Objekte besitzen eine einzigartige eingebaute Operation: den
Operator "%" (Modulo). Dieser wird auch als String-*Formatierungs*-
oder *Interpolations*-Operator bezeichnet. Bei "format % values"
(wobei *format* ein String ist) werden
"%"-Konvertierungsspezifikationen in *format* durch null oder mehr
Elemente aus *values* ersetzt. Die Wirkung ähnelt der Verwendung der
Funktion "sprintf()" in der Sprache C. Zum Beispiel:

   >>> print('%s has %d quote types.' % ('Python', 2))
   Python has 2 quote types.

Wenn *format* ein einzelnes Argument erfordert, kann *values* ein
einzelnes Nicht-Tupel-Objekt sein. [5] Andernfalls muss *values* ein
Tupel mit genau der durch den Format-String angegebenen Anzahl von
Elementen oder ein einzelnes Mapping-Objekt (z. B. ein Dictionary)
sein.

Ein Konvertierungsspezifizierer besteht aus zwei oder mehr Zeichen und
hat die folgenden Komponenten, die in dieser Reihenfolge auftreten
müssen:

1. Das Zeichen "'%'", das den Beginn des Spezifizierers markiert.

2. Mapping-Schlüssel (optional), bestehend aus einer eingeklammerten
   Zeichenfolge (zum Beispiel "(somename)").

3. Konvertierungs-Flags (optional), die das Ergebnis bestimmter
   Konvertierungstypen beeinflussen.

4. Minimale Feldbreite (optional). Wenn sie als "'*'" (Sternchen)
   angegeben ist, wird die tatsächliche Breite aus dem nächsten
   Element des Tupels in *values* gelesen, und das zu konvertierende
   Objekt folgt nach der minimalen Feldbreite und der optionalen
   Genauigkeit.

5. Genauigkeit (optional), angegeben als "'.'" (Punkt) gefolgt von der
   Genauigkeit. Wenn sie als "'*'" (Sternchen) angegeben ist, wird die
   tatsächliche Genauigkeit aus dem nächsten Element des Tupels in
   *values* gelesen, und der zu konvertierende Wert folgt nach der
   Genauigkeit.

6. Längenmodifikator (optional).

7. Konvertierungstyp.

Wenn das rechte Argument ein Dictionary (oder ein anderer Mapping-Typ)
ist, *müssen* die Formate im String einen eingeklammerten Mapping-
Schlüssel für dieses Dictionary enthalten, der unmittelbar nach dem
Zeichen "'%'" eingefügt wird. Der Mapping-Schlüssel wählt den zu
formatierenden Wert aus dem Mapping aus. Zum Beispiel:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

In diesem Fall dürfen keine "*"-Spezifizierer in einem Format
vorkommen (da diese eine sequentielle Parameterliste erfordern).

Die Konvertierungs-Flag-Zeichen sind:

+-----------+-----------------------------------------------------------------------+
| Flag      | Bedeutung                                                             |
|===========|=======================================================================|
| "'#'"     | Die Wertkonvertierung verwendet die "alternative Form" (sofern unten  |
|           | definiert).                                                           |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | Die Konvertierung wird bei numerischen Werten mit Nullen aufgefüllt.  |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | Der konvertierte Wert wird linksbündig ausgerichtet (überschreibt die |
|           | "'0'"-Konvertierung, wenn beide angegeben sind).                      |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (ein Leerzeichen) Vor einer positiven Zahl (oder einem leeren         |
|           | String), die durch eine vorzeichenbehaftete Konvertierung erzeugt     |
|           | wird, sollte ein Leerzeichen verbleiben.                              |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | Ein Vorzeichen ("'+'" oder "'-'") wird der Konvertierung              |
|           | vorangestellt (überschreibt ein "Leerzeichen"-Flag).                  |
+-----------+-----------------------------------------------------------------------+

Ein Längenmodifikator ("h", "l" oder "L") kann vorhanden sein, wird
jedoch ignoriert, da er für Python nicht erforderlich ist – so ist z.
B. "%ld" identisch mit "%d".

Die Konvertierungstypen sind:

+--------------+-------------------------------------------------------+---------+
| Konvertieru  | Bedeutung                                             | Hinwei  |
| ng           |                                                       | se      |
|==============|=======================================================|=========|
| "'d'"        | Vorzeichenbehaftete Dezimal-Ganzzahl.                 |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Vorzeichenbehaftete Dezimal-Ganzzahl.                 |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Vorzeichenbehafteter Oktalwert.                       | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Veralteter Typ – er ist identisch mit "'d'".          | (6)     |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Vorzeichenbehaftetes Hexadezimal (Kleinbuchstaben).   | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Vorzeichenbehaftetes Hexadezimal (Großbuchstaben).    | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Gleitkomma-Exponentialformat (Kleinbuchstaben).       | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Gleitkomma-Exponentialformat (Großbuchstaben).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Gleitkomma-Dezimalformat.                             | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Gleitkomma-Dezimalformat.                             | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Gleitkommaformat. Verwendet das Exponentialformat in  | (4)     |
|              | Kleinbuchstaben, wenn der Exponent kleiner als -4     |         |
|              | oder nicht kleiner als die Genauigkeit ist,           |         |
|              | andernfalls das Dezimalformat.                        |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Gleitkommaformat. Verwendet das Exponentialformat in  | (4)     |
|              | Großbuchstaben, wenn der Exponent kleiner als -4 oder |         |
|              | nicht kleiner als die Genauigkeit ist, andernfalls    |         |
|              | das Dezimalformat.                                    |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Einzelnes Zeichen (akzeptiert Ganzzahl oder           |         |
|              | einzeichenigen String).                               |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | String (konvertiert jedes Python-Objekt mittels       | (5)     |
|              | "repr()").                                            |         |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | String (konvertiert jedes Python-Objekt mittels       | (5)     |
|              | "str()").                                             |         |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | String (konvertiert jedes Python-Objekt mittels       | (5)     |
|              | "ascii()").                                           |         |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | Kein Argument wird konvertiert, führt zu einem        |         |
|              | "'%'"-Zeichen im Ergebnis.                            |         |
+--------------+-------------------------------------------------------+---------+

Bei Gleitkommaformaten sollte das Ergebnis korrekt auf eine angegebene
Präzision "p" von Nachkommastellen gerundet werden. Der Rundungsmodus
entspricht dem des eingebauten "round()".

Hinweise:

1. Die alternative Form bewirkt, dass vor der ersten Ziffer eine
   führende Oktal-Kennzeichnung ("'0o'") eingefügt wird.

2. Die alternative Form bewirkt, dass vor der ersten Ziffer ein
   führendes "'0x'" oder "'0X'" eingefügt wird (je nachdem, ob das
   Format "'x'" oder "'X'" verwendet wurde).

3. Die alternative Form bewirkt, dass das Ergebnis immer einen
   Dezimalpunkt enthält, selbst wenn keine Ziffern folgen.

   Die Genauigkeit bestimmt die Anzahl der Nachkommastellen und ist
   standardmäßig 6.

4. Die alternative Form bewirkt, dass das Ergebnis immer einen
   Dezimalpunkt enthält und nachgestellte Nullen nicht entfernt
   werden, wie es sonst der Fall wäre.

   Die Genauigkeit bestimmt die Anzahl der signifikanten Stellen vor
   und nach dem Dezimalpunkt und ist standardmäßig 6.

5. Wenn die Genauigkeit "N" beträgt, wird die Ausgabe auf "N" Zeichen
   gekürzt.

6. Siehe **PEP 237**.

Da Python-Strings eine explizite Länge haben, gehen
"%s"-Konvertierungen nicht davon aus, dass "'\0'" das Ende des Strings
markiert.

Geändert in Version 3.1: "%f"-Konvertierungen für Zahlen, deren
Absolutwert über 1e50 liegt, werden nicht mehr durch
"%g"-Konvertierungen ersetzt.


Binäre Sequenztypen – "bytes", "bytearray", "memoryview"
========================================================

Die grundlegenden eingebauten Typen zur Manipulation binärer Daten
sind "bytes" und "bytearray". Sie werden durch "memoryview"
unterstützt, das das Pufferprotokoll nutzt, um auf den Speicher
anderer binärer Objekte zuzugreifen, ohne eine Kopie anfertigen zu
müssen.

Das Modul "array" unterstützt die effiziente Speicherung grundlegender
Datentypen wie 32-Bit-Ganzzahlen und IEEE754-Gleitkommazahlen mit
doppelter Genauigkeit.


Bytes-Objekte
-------------

Bytes-Objekte sind unveränderliche Sequenzen einzelner Bytes. Da viele
wichtige Binärprotokolle auf der ASCII-Textkodierung basieren, bieten
Bytes-Objekte mehrere Methoden, die nur bei der Arbeit mit ASCII-
kompatiblen Daten gültig sind, und sind auf vielfältige Weise eng mit
String-Objekten verwandt.

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

   Erstens entspricht die Syntax für Bytes-Literale weitgehend der für
   String-Literale, außer dass ein Präfix "b" vorangestellt wird:

   * Einfache Anführungszeichen: "b'still allows embedded "double"
     quotes'"

   * Doppelte Anführungszeichen: "b"still allows embedded 'single'
     quotes""

   * Dreifache Anführungszeichen: "b'''3 single quotes'''", "b"""3
     double quotes""""

   In Bytes-Literalen sind nur ASCII-Zeichen erlaubt (unabhängig von
   der deklarierten Quellcode-Kodierung). Alle Binärwerte über 127
   müssen über die entsprechende Escape-Sequenz in Bytes-Literale
   eingegeben werden.

   Wie bei String-Literalen können auch Bytes-Literale ein "r"-Präfix
   verwenden, um die Verarbeitung von Escape-Sequenzen zu
   deaktivieren. Siehe String and Bytes literals für weitere Details
   zu den verschiedenen Formen von Bytes-Literalen einschließlich der
   unterstützten Escape-Sequenzen.

   Während Bytes-Literale und deren Darstellungen auf ASCII-Text
   basieren, verhalten sich Bytes-Objekte tatsächlich wie
   unveränderliche Sequenzen von Ganzzahlen, wobei jeder Wert in der
   Sequenz so eingeschränkt ist, dass "0 <= x < 256" gilt (Versuche,
   diese Einschränkung zu verletzen, lösen einen "ValueError" aus).
   Dies geschieht bewusst, um zu unterstreichen, dass viele
   Binärformate zwar ASCII-basierte Elemente enthalten und mit einigen
   textorientierten Algorithmen sinnvoll verarbeitet werden können,
   dies jedoch für beliebige Binärdaten im Allgemeinen nicht zutrifft
   (das unbedachte Anwenden von Textverarbeitungsalgorithmen auf nicht
   ASCII-kompatible Binärdatenformate führt in der Regel zu
   Datenbeschädigung).

   Zusätzlich zu den Literalformen können Bytes-Objekte auf
   verschiedene andere Arten erzeugt werden:

   * Ein mit Nullen gefülltes Bytes-Objekt einer angegebenen Länge:
     "bytes(10)"

   * Aus einem Iterable von Ganzzahlen: "bytes(range(20))"

   * Kopieren vorhandener Binärdaten über das Pufferprotokoll:
     "bytes(obj)"

   Siehe auch die eingebaute Funktion bytes.

   Da 2 Hexadezimalziffern exakt einem einzelnen Byte entsprechen,
   sind Hexadezimalzahlen ein häufig verwendetes Format zur
   Beschreibung von Binärdaten. Dementsprechend besitzt der Bytes-Typ
   eine zusätzliche Klassenmethode zum Einlesen von Daten in diesem
   Format:

   classmethod fromhex(string, /)

      Diese "bytes"-Klassenmethode gibt ein Bytes-Objekt zurück, indem
      sie das angegebene String-Objekt dekodiert. Der String muss zwei
      Hexadezimalziffern pro Byte enthalten, wobei ASCII-Whitespaces
      ignoriert werden.

      >>> bytes.fromhex('2Ef0 F1f2  ')
      b'.\xf0\xf1\xf2'

      Geändert in Version 3.7: "bytes.fromhex()" überspringt nun alle
      ASCII-Whitespaces im String, nicht nur Leerzeichen.

   Es existiert eine umgekehrte Konvertierungsfunktion, um ein Bytes-
   Objekt in seine hexadezimale Darstellung umzuwandeln.

   hex(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

      Gibt ein String-Objekt zurück, das zwei Hexadezimalziffern für
      jedes Byte in der Instanz enthält.

      >>> b'\xf0\xf1\xf2'.hex()
      'f0f1f2'

      Wenn der Hex-String besser lesbar sein soll, kann ein
      Einzelzeichen als Trennzeichen-Parameter *sep* für die Ausgabe
      angegeben werden. Standardmäßig wird dieses Trennzeichen
      zwischen jedem Byte eingefügt. Ein zweiter optionaler Parameter
      *bytes_per_sep* steuert den Abstand. Positive Werte berechnen
      die Position des Trennzeichens von rechts, negative Werte von
      links.

      >>> value = b'\xf0\xf1\xf2'
      >>> value.hex('-')
      'f0-f1-f2'
      >>> value.hex('_', 2)
      'f0_f1f2'
      >>> b'UUDDLRLRAB'.hex(' ', -4)
      '55554444 4c524c52 4142'

      Added in version 3.5.

      Geändert in Version 3.8: "bytes.hex()" unterstützt nun die
      optionalen Parameter *sep* und *bytes_per_sep*, um Trennzeichen
      zwischen Bytes in der Hex-Ausgabe einzufügen.

Da Bytes-Objekte Ganzzahlsequenzen sind (ähnlich wie ein Tupel), ist
für ein Bytes-Objekt *b* "b[0]" eine Ganzzahl, während "b[0:1]" ein
Bytes-Objekt der Länge 1 ist. (Dies steht im Gegensatz zu Text-
Strings, bei denen sowohl Indizierung als auch Slicing einen String
der Länge 1 erzeugen)

Die Darstellung von Bytes-Objekten verwendet das Literalformat
("b'...'"), da dies oft nützlicher ist als z. B. "bytes([46, 46,
46])". Ein Bytes-Objekt kann mittels "list(b)" jederzeit in eine Liste
von Ganzzahlen umgewandelt werden.


Bytearray-Objekte
-----------------

"bytearray"-Objekte sind ein veränderliches Gegenstück zu
"bytes"-Objekten.

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

   Es gibt keine eigene Literalsyntax für Bytearray-Objekte;
   stattdessen werden sie immer über den Konstruktor erzeugt:

   * Erstellen einer leeren Instanz: "bytearray()"

   * Erstellen einer mit Nullen gefüllten Instanz mit angegebener
     Länge: "bytearray(10)"

   * Aus einem Iterable von Ganzzahlen: "bytearray(range(20))"

   * Kopieren vorhandener Binärdaten über das Pufferprotokoll:
     "bytearray(b'Hi!')"

   Da Bytearray-Objekte veränderlich sind, unterstützen sie zusätzlich
   zu den unter Bytes- und Bytearray-Operationen beschriebenen
   gemeinsamen Bytes- und Bytearray-Operationen die veränderlichen
   Sequenzoperationen.

   Siehe auch die eingebaute Funktion bytearray.

   Da 2 Hexadezimalziffern exakt einem einzelnen Byte entsprechen,
   sind Hexadezimalzahlen ein häufig verwendetes Format zur
   Beschreibung von Binärdaten. Dementsprechend besitzt der Bytearray-
   Typ eine zusätzliche Klassenmethode zum Einlesen von Daten in
   diesem Format:

   classmethod fromhex(string, /)

      Diese Klassenmethode von "bytearray" gibt ein Bytearray-Objekt
      zurück, indem sie das angegebene Zeichenkettenobjekt dekodiert.
      Die Zeichenkette muss zwei Hexadezimalziffern pro Byte
      enthalten, wobei ASCII-Whitespace ignoriert wird.

      >>> bytearray.fromhex('2Ef0 F1f2  ')
      bytearray(b'.\xf0\xf1\xf2')

      Geändert in Version 3.7: "bytearray.fromhex()" überspringt nun
      alle ASCII-Whitespaces im String, nicht nur Leerzeichen.

   Es existiert eine umgekehrte Konvertierungsfunktion, um ein
   Bytearray-Objekt in seine hexadezimale Darstellung umzuwandeln.

   hex(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

      Gibt ein String-Objekt zurück, das zwei Hexadezimalziffern für
      jedes Byte in der Instanz enthält.

      >>> bytearray(b'\xf0\xf1\xf2').hex()
      'f0f1f2'

      Added in version 3.5.

      Geändert in Version 3.8: Ähnlich wie "bytes.hex()" unterstützt
      nun auch "bytearray.hex()" die optionalen Parameter *sep* und
      *bytes_per_sep*, um Trennzeichen zwischen Bytes in der Hex-
      Ausgabe einzufügen.

Da Bytearray-Objekte Ganzzahlsequenzen sind (ähnlich wie eine Liste),
ist für ein Bytearray-Objekt *b* "b[0]" eine Ganzzahl, während
"b[0:1]" ein Bytearray-Objekt der Länge 1 ist. (Dies steht im
Gegensatz zu Text-Strings, bei denen sowohl Indizierung als auch
Slicing einen String der Länge 1 erzeugen)

Die Darstellung von Bytearray-Objekten verwendet das Bytes-
Literalformat ("bytearray(b'...')"), da dies oft nützlicher ist als z.
B. "bytearray([46, 46, 46])". Ein Bytearray-Objekt kann mittels
"list(b)" jederzeit in eine Liste von Ganzzahlen umgewandelt werden.


Bytes- und Bytearray-Operationen
--------------------------------

Sowohl Bytes- als auch Bytearray-Objekte unterstützen die gemeinsamen
Sequenzoperationen. Sie interagieren nicht nur mit Operanden desselben
Typs, sondern mit jedem *Byte-ähnlichen Objekt*. Aufgrund dieser
Flexibilität können sie in Operationen frei gemischt werden, ohne
Fehler zu verursachen. Der Rückgabetyp des Ergebnisses kann jedoch von
der Reihenfolge der Operanden abhängen.

Bemerkung:

  Die Methoden auf Bytes- und Bytearray-Objekten akzeptieren keine
  Strings als Argumente, genauso wie die Methoden auf Strings keine
  Bytes als Argumente akzeptieren. Zum Beispiel muss man schreiben:

     a = "abc"
     b = a.replace("a", "f")

  and:

     a = b"abc"
     b = a.replace(b"a", b"f")

Einige Bytes- und Bytearray-Operationen setzen die Verwendung ASCII-
kompatibler Binärformate voraus und sollten daher bei der Arbeit mit
beliebigen Binärdaten vermieden werden. Diese Einschränkungen werden
unten behandelt.

Bemerkung:

  Die Verwendung dieser ASCII-basierten Operationen zur Manipulation
  von Binärdaten, die nicht in einem ASCII-basierten Format
  gespeichert sind, kann zu Datenbeschädigung führen.

Die folgenden Methoden auf Bytes- und Bytearray-Objekten können mit
beliebigen Binärdaten verwendet werden.

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

   Gibt die Anzahl der nicht überlappenden Vorkommen der Teilsequenz
   *sub* im Bereich [*start*, *end*] zurück. Die optionalen Argumente
   *start* und *end* werden wie in der Slice-Notation interpretiert.

   Die zu suchende Teilsequenz kann jedes *Byte-ähnliche Objekt* oder
   eine Ganzzahl im Bereich von 0 bis 255 sein.

   Wenn *sub* leer ist, wird die Anzahl der leeren Slices zwischen den
   Zeichen zurückgegeben, was der Länge des Bytes-Objekts plus eins
   entspricht.

   Geändert in Version 3.3: Akzeptiert nun auch eine Ganzzahl im
   Bereich von 0 bis 255 als Teilsequenz.

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

   Wenn die Binärdaten mit dem Präfix-String *prefix* beginnen, wird
   "bytes[len(prefix):]" zurückgegeben. Andernfalls wird eine Kopie
   der ursprünglichen Binärdaten zurückgegeben:

      >>> b'TestHook'.removeprefix(b'Test')
      b'Hook'
      >>> b'BaseTestCase'.removeprefix(b'Test')
      b'BaseTestCase'

   Das *prefix* kann jedes *Byte-ähnliche Objekt* sein.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

   Added in version 3.9.

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

   Wenn die Binärdaten mit dem Suffix-String *suffix* enden und dieses
   *suffix* nicht leer ist, wird "bytes[:-len(suffix)]" zurückgegeben.
   Andernfalls wird eine Kopie der ursprünglichen Binärdaten
   zurückgegeben:

      >>> b'MiscTests'.removesuffix(b'Tests')
      b'Misc'
      >>> b'TmpDirMixin'.removesuffix(b'Tests')
      b'TmpDirMixin'

   Das *suffix* kann jedes *Byte-ähnliche Objekt* sein.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

   Added in version 3.9.

bytes.decode(encoding='utf-8', errors='strict')
bytearray.decode(encoding='utf-8', errors='strict')

   Gibt die als "str" dekodierten Bytes zurück.

   *encoding* ist standardmäßig "'utf-8'"; siehe Standard Encodings
   für mögliche Werte.

   *errors* steuert, wie Dekodierungsfehler behandelt werden. Bei
   "'strict'" (Standardwert) wird eine "UnicodeError"-Ausnahme
   ausgelöst. Andere mögliche Werte sind "'ignore'", "'replace'" und
   jeder andere über "codecs.register_error()" registrierte Name.
   Siehe Error Handlers für Details.

   Aus Leistungsgründen wird der Wert von *errors* nicht auf
   Gültigkeit geprüft, es sei denn, es tritt tatsächlich ein
   Dekodierungsfehler auf, der Python Development Mode ist aktiviert
   oder es wird ein Debug-Build verwendet.

   Bemerkung:

     Die Übergabe des Arguments *encoding* an "str" ermöglicht das
     direkte Dekodieren jedes *Byte-ähnlichen Objekts*, ohne ein
     temporäres "bytes"- oder "bytearray"-Objekt erstellen zu müssen.

   Geändert in Version 3.1: Unterstützung für Schlüsselwort-Argumente
   hinzugefügt.

   Geändert in Version 3.9: Der Wert des Arguments *errors* wird nun
   im Python Development Mode und im Debug-Modus geprüft.

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

   Gibt "True" zurück, wenn die Binärdaten mit dem angegebenen
   *suffix* enden, andernfalls "False". *suffix* kann auch ein Tupel
   von zu suchenden Suffixen sein. Mit optionalem *start* wird ab
   dieser Position geprüft. Mit optionalem *end* wird der Vergleich an
   dieser Position beendet.

   Die zu suchenden Suffixe können jedes *Byte-ähnliche Objekt* sein.

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

   Gibt den niedrigsten Index in den Daten zurück, an dem die
   Teilsequenz *sub* gefunden wird, sodass *sub* im Slice
   "s[start:end]" enthalten ist. Die optionalen Argumente *start* und
   *end* werden wie in der Slice-Notation interpretiert. Gibt "-1"
   zurück, wenn *sub* nicht gefunden wird.

   Die zu suchende Teilsequenz kann jedes *Byte-ähnliche Objekt* oder
   eine Ganzzahl im Bereich von 0 bis 255 sein.

   Bemerkung:

     Die Methode "find()" sollte nur verwendet werden, wenn die
     Position von *sub* benötigt wird. Um zu prüfen, ob *sub* ein
     Teilstring ist oder nicht, verwende den Operator "in":

        >>> b'Py' in b'Python'
        True

   Geändert in Version 3.3: Akzeptiert nun auch eine Ganzzahl im
   Bereich von 0 bis 255 als Teilsequenz.

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

   Wie "find()", löst jedoch einen "ValueError" aus, wenn die
   Teilsequenz nicht gefunden wird.

   Die zu suchende Teilsequenz kann jedes *Byte-ähnliche Objekt* oder
   eine Ganzzahl im Bereich von 0 bis 255 sein.

   Geändert in Version 3.3: Akzeptiert nun auch eine Ganzzahl im
   Bereich von 0 bis 255 als Teilsequenz.

bytes.join(iterable, /)
bytearray.join(iterable, /)

   Gibt ein Bytes- oder Bytearray-Objekt zurück, das die Verkettung
   der binären Datensequenzen in *iterable* ist. Ein "TypeError" wird
   ausgelöst, wenn sich in *iterable* Werte befinden, die keine *Byte-
   ähnlichen Objekte* sind, einschließlich "str"-Objekten. Das
   Trennzeichen zwischen den Elementen ist der Inhalt des Bytes- oder
   Bytearray-Objekts, das diese Methode bereitstellt.

static bytes.maketrans(from, to, /)
static bytearray.maketrans(from, to, /)

   Diese statische Methode gibt eine für "bytes.translate()"
   verwendbare Übersetzungstabelle zurück, die jedes Zeichen in *from*
   auf das Zeichen an derselben Position in *to* abbildet; *from* und
   *to* müssen beide *Byte-ähnliche Objekte* sein und dieselbe Länge
   haben.

   Added in version 3.1.

bytes.partition(sep, /)
bytearray.partition(sep, /)

   Teilt die Sequenz beim ersten Vorkommen von *sep* und gibt ein
   3-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen
   selbst oder dessen Bytearray-Kopie und den Teil nach dem
   Trennzeichen enthält. Wenn das Trennzeichen nicht gefunden wird,
   wird ein 3-Tupel zurückgegeben, das eine Kopie der ursprünglichen
   Sequenz gefolgt von zwei leeren Bytes- oder Bytearray-Objekten
   enthält.

   Das zu suchende Trennzeichen kann jedes *Byte-ähnliche Objekt*
   sein.

bytes.replace(old, new, count=-1, /)
bytearray.replace(old, new, count=-1, /)

   Gibt eine Kopie der Sequenz zurück, bei der alle Vorkommen der
   Teilsequenz *old* durch *new* ersetzt wurden. Wenn das optionale
   Argument *count* angegeben ist, werden nur die ersten *count*
   Vorkommen ersetzt.

   Die zu suchende Teilsequenz und deren Ersetzung können jedes *Byte-
   ähnliche Objekt* sein.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

   Gibt den höchsten Index in der Sequenz zurück, an dem die
   Teilsequenz *sub* gefunden wird, sodass *sub* innerhalb von
   "s[start:end]" enthalten ist. Die optionalen Argumente *start* und
   *end* werden wie in der Slice-Notation interpretiert. Gibt im
   Fehlerfall "-1" zurück.

   Die zu suchende Teilsequenz kann jedes *Byte-ähnliche Objekt* oder
   eine Ganzzahl im Bereich von 0 bis 255 sein.

   Geändert in Version 3.3: Akzeptiert nun auch eine Ganzzahl im
   Bereich von 0 bis 255 als Teilsequenz.

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

   Wie "rfind()", löst jedoch einen "ValueError" aus, wenn die
   Teilsequenz *sub* nicht gefunden wird.

   Die zu suchende Teilsequenz kann jedes *Byte-ähnliche Objekt* oder
   eine Ganzzahl im Bereich von 0 bis 255 sein.

   Geändert in Version 3.3: Akzeptiert nun auch eine Ganzzahl im
   Bereich von 0 bis 255 als Teilsequenz.

bytes.rpartition(sep, /)
bytearray.rpartition(sep, /)

   Teilt die Sequenz beim letzten Vorkommen von *sep* und gibt ein
   3-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen
   selbst oder dessen Bytearray-Kopie und den Teil nach dem
   Trennzeichen enthält. Wenn das Trennzeichen nicht gefunden wird,
   wird ein 3-Tupel zurückgegeben, das zwei leere Bytes- oder
   Bytearray-Objekte enthält, gefolgt von einer Kopie der
   ursprünglichen Sequenz.

   Das zu suchende Trennzeichen kann jedes *Byte-ähnliche Objekt*
   sein.

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

   Gibt "True" zurück, wenn die Binärdaten mit dem angegebenen
   *prefix* beginnen, andernfalls "False". *prefix* kann auch ein
   Tupel von zu suchenden Präfixen sein. Mit optionalem *start* wird
   ab dieser Position geprüft. Mit optionalem *end* wird der Vergleich
   an dieser Position beendet.

   Die zu suchenden Präfixe können jedes *Byte-ähnliche Objekt* sein.

bytes.translate(table, /, delete=b'')
bytearray.translate(table, /, delete=b'')

   Gibt eine Kopie des Bytes- oder Bytearray-Objekts zurück, bei der
   alle im optionalen Argument *delete* vorkommenden Bytes entfernt
   wurden und die verbleibenden Bytes über die angegebene
   Übersetzungstabelle abgebildet wurden, die ein Bytes-Objekt der
   Länge 256 sein muss.

   Du kannst die Methode "bytes.maketrans()" verwenden, um eine
   Übersetzungstabelle zu erstellen.

   Setze das Argument *table* auf "None" für Übersetzungen, die
   lediglich Zeichen löschen:

      >>> b'read this short text'.translate(None, b'aeiou')
      b'rd ths shrt txt'

   Geändert in Version 3.6: *delete* wird nun als Schlüsselwort-
   Argument unterstützt.

Die folgenden Methoden auf Bytes- und Bytearray-Objekten besitzen ein
Standardverhalten, das die Verwendung ASCII-kompatibler Binärformate
voraussetzt, können jedoch durch Übergabe geeigneter Argumente
weiterhin mit beliebigen Binärdaten verwendet werden. Beachte, dass
alle Bytearray-Methoden in diesem Abschnitt *nicht* in-place arbeiten,
sondern stattdessen neue Objekte erzeugen.

bytes.center(width, fillbyte=b' ', /)
bytearray.center(width, fillbyte=b' ', /)

   Gibt eine Kopie des Objekts zentriert in einer Sequenz der Länge
   *width* zurück. Das Auffüllen erfolgt mit dem angegebenen
   *fillbyte* (Standard ist ein ASCII-Leerzeichen). Für
   "bytes"-Objekte wird die ursprüngliche Sequenz zurückgegeben, wenn
   *width* kleiner oder gleich "len(s)" ist.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.ljust(width, fillbyte=b' ', /)
bytearray.ljust(width, fillbyte=b' ', /)

   Gibt eine Kopie des Objekts linksbündig in einer Sequenz der Länge
   *width* zurück. Das Auffüllen erfolgt mit dem angegebenen
   *fillbyte* (Standard ist ein ASCII-Leerzeichen). Für
   "bytes"-Objekte wird die ursprüngliche Sequenz zurückgegeben, wenn
   *width* kleiner oder gleich "len(s)" ist.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.lstrip(bytes=None, /)
bytearray.lstrip(bytes=None, /)

   Gibt eine Kopie der Sequenz zurück, bei der die angegebenen
   führenden Bytes entfernt wurden. Das Argument *bytes* ist eine
   binäre Sequenz, die die Menge der zu entfernenden Byte-Werte
   angibt. Wird es weggelassen oder ist "None", entfernt das Argument
   *bytes* standardmäßig "ASCII-Whitespace". Das Argument *bytes* ist
   kein Präfix; stattdessen werden alle Kombinationen seiner Werte
   entfernt:

      >>> b'   spacious   '.lstrip()
      b'spacious   '
      >>> b'www.example.com'.lstrip(b'cmowz.')
      b'example.com'

   Die binäre Sequenz der zu entfernenden Bytewerte kann jedes *Byte-
   ähnliche Objekt* sein. Siehe "removeprefix()" für eine Methode, die
   einen einzelnen Präfix-String anstelle einer Menge aller Zeichen
   entfernt. Zum Beispiel:

      >>> b'Arthur: three!'.lstrip(b'Arthur: ')
      b'ee!'
      >>> b'Arthur: three!'.removeprefix(b'Arthur: ')
      b'three!'

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.rjust(width, fillbyte=b' ', /)
bytearray.rjust(width, fillbyte=b' ', /)

   Gibt eine Kopie des Objekts rechtsbündig in einer Sequenz der Länge
   *width* zurück. Das Auffüllen erfolgt mit dem angegebenen
   *fillbyte* (Standard ist ein ASCII-Leerzeichen). Für
   "bytes"-Objekte wird die ursprüngliche Sequenz zurückgegeben, wenn
   *width* kleiner oder gleich "len(s)" ist.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.rsplit(sep=None, maxsplit=-1)
bytearray.rsplit(sep=None, maxsplit=-1)

   Teilt die binäre Sequenz in Teilsequenzen desselben Typs unter
   Verwendung von *sep* als Trenn-String. Wenn *maxsplit* angegeben
   ist, werden höchstens *maxsplit* Trennungen vorgenommen, und zwar
   die *am weitesten rechts liegenden*. Wenn *sep* nicht angegeben
   oder "None" ist, fungiert jede Teilsequenz, die ausschließlich aus
   "ASCII-Whitespace" besteht, als Trennzeichen. Abgesehen vom Trennen
   von rechts verhält sich "rsplit()" wie "split()", was weiter unten
   ausführlich beschrieben ist.

bytes.rstrip(bytes=None, /)
bytearray.rstrip(bytes=None, /)

   Gibt eine Kopie der Sequenz zurück, bei der die angegebenen
   abschließenden Bytes entfernt wurden. Das Argument *bytes* ist eine
   binäre Sequenz, die die Menge der zu entfernenden Byte-Werte
   angibt. Wird es weggelassen oder ist "None", entfernt das Argument
   *bytes* standardmäßig "ASCII-Whitespace". Das Argument *bytes* ist
   kein Suffix; stattdessen werden alle Kombinationen seiner Werte
   entfernt:

      >>> b'   spacious   '.rstrip()
      b'   spacious'
      >>> b'mississippi'.rstrip(b'ipz')
      b'mississ'

   Die binäre Sequenz der zu entfernenden Bytewerte kann jedes *Byte-
   ähnliche Objekt* sein. Siehe "removesuffix()" für eine Methode, die
   einen einzelnen Suffix-String anstelle einer Menge aller Zeichen
   entfernt. Zum Beispiel:

      >>> b'Monty Python'.rstrip(b' Python')
      b'M'
      >>> b'Monty Python'.removesuffix(b' Python')
      b'Monty'

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.split(sep=None, maxsplit=-1)
bytearray.split(sep=None, maxsplit=-1)

   Teilt die binäre Sequenz in Teilsequenzen desselben Typs unter
   Verwendung von *sep* als Trenn-String. Wenn *maxsplit* angegeben
   und nicht-negativ ist, werden höchstens *maxsplit* Trennungen
   vorgenommen (die Liste hat somit höchstens "maxsplit+1" Elemente).
   Wenn *maxsplit* nicht angegeben oder "-1" ist, gibt es keine
   Begrenzung für die Anzahl der Trennungen (alle möglichen Trennungen
   werden vorgenommen).

   Wenn *sep* angegeben ist, werden aufeinanderfolgende Trennzeichen
   nicht zusammengefasst und als Begrenzung leerer Teilsequenzen
   betrachtet (beispielsweise gibt "b'1,,2'.split(b',')" "[b'1', b'',
   b'2']" zurück). Das Argument *sep* kann aus einer Multibyte-Sequenz
   als einzelnem Trennzeichen bestehen. Das Teilen einer leeren
   Sequenz mit einem angegebenen Trennzeichen gibt je nach Typ des
   geteilten Objekts "[b'']" oder "[bytearray(b'')]" zurück. Das
   Argument *sep* kann jedes *Byte-ähnliche Objekt* sein.

   Zum Beispiel:

      >>> b'1,2,3'.split(b',')
      [b'1', b'2', b'3']
      >>> b'1,2,3'.split(b',', maxsplit=1)
      [b'1', b'2,3']
      >>> b'1,2,,3,'.split(b',')
      [b'1', b'2', b'', b'3', b'']
      >>> b'1<>2<>3<4'.split(b'<>')
      [b'1', b'2', b'3<4']

   Ist *sep* nicht angegeben oder "None", wird ein anderer
   Aufteilungsalgorithmus angewendet: Folgen aufeinanderfolgender
   "ASCII-Whitespace"-Zeichen werden als ein einzelnes Trennzeichen
   betrachtet, und das Ergebnis enthält keine leeren Zeichenketten am
   Anfang oder Ende, wenn die Sequenz führenden oder abschließenden
   Whitespace hat. Folglich gibt das Aufteilen einer leeren Sequenz
   oder einer Sequenz, die ausschließlich aus ASCII-Whitespace
   besteht, ohne angegebenes Trennzeichen "[]" zurück.

   Zum Beispiel:

      >>> b'1 2 3'.split()
      [b'1', b'2', b'3']
      >>> b'1 2 3'.split(maxsplit=1)
      [b'1', b'2 3']
      >>> b'   1   2   3   '.split()
      [b'1', b'2', b'3']

bytes.strip(bytes=None, /)
bytearray.strip(bytes=None, /)

   Gibt eine Kopie der Sequenz zurück, bei der die angegebenen
   führenden und abschließenden Bytes entfernt wurden. Das Argument
   *bytes* ist eine binäre Sequenz, die die Menge der zu entfernenden
   Byte-Werte angibt. Wird es weggelassen oder ist "None", entfernt
   das Argument *bytes* standardmäßig "ASCII-Whitespace". Das Argument
   *bytes* ist kein Präfix oder Suffix; stattdessen werden alle
   Kombinationen seiner Werte entfernt:

      >>> b'   spacious   '.strip()
      b'spacious'
      >>> b'www.example.com'.strip(b'cmowz.')
      b'example'

   Die binäre Sequenz der zu entfernenden Bytewerte kann jedes *Byte-
   ähnliche Objekt* sein.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

Die folgenden Methoden auf Bytes- und Bytearray-Objekten setzen die
Verwendung ASCII-kompatibler Binärformate voraus und sollten nicht auf
beliebige Binärdaten angewendet werden. Beachte, dass alle Bytearray-
Methoden in diesem Abschnitt *nicht* in-place arbeiten, sondern
stattdessen neue Objekte erzeugen.

bytes.capitalize()
bytearray.capitalize()

   Gibt eine Kopie der Sequenz zurück, bei der jedes Byte als ASCII-
   Zeichen interpretiert wird, wobei das erste Byte großgeschrieben
   und der Rest kleingeschrieben wird. Nicht-ASCII-Bytewerte werden
   unverändert übernommen.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

   Gibt eine Kopie der Sequenz zurück, bei der alle ASCII-
   Tabulatorzeichen abhängig von der aktuellen Spalte und der
   angegebenen Tabulatorgröße durch ein oder mehrere ASCII-Leerzeichen
   ersetzt werden. Tabulatorpositionen treten alle *tabsize* Bytes auf
   (Standardwert ist 8, was Tabulatorpositionen in den Spalten 0, 8,
   16 usw. ergibt). Um die Sequenz zu expandieren, wird die aktuelle
   Spalte auf null gesetzt und die Sequenz Byte für Byte durchlaufen.
   Wenn das Byte ein ASCII-Tabulatorzeichen ("b'\t'") ist, werden ein
   oder mehrere Leerzeichen in das Ergebnis eingefügt, bis die
   aktuelle Spalte der nächsten Tabulatorposition entspricht. (Das
   Tabulatorzeichen selbst wird nicht kopiert.) Wenn das aktuelle Byte
   ein ASCII-Zeilenvorschub ("b'\n'") oder Wagenrücklauf ("b'\r'")
   ist, wird es kopiert und die aktuelle Spalte auf null
   zurückgesetzt. Jeder andere Bytewert wird unverändert kopiert und
   die aktuelle Spalte um eins erhöht, unabhängig davon, wie der
   Bytewert bei der Ausgabe dargestellt wird:

      >>> b'01\t012\t0123\t01234'.expandtabs()
      b'01      012     0123    01234'
      >>> b'01\t012\t0123\t01234'.expandtabs(4)
      b'01  012 0123    01234'

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.isalnum()
bytearray.isalnum()

   Gibt "True" zurück, wenn alle Bytes in der Sequenz alphabetische
   ASCII-Zeichen oder ASCII-Dezimalziffern sind und die Sequenz nicht
   leer ist, andernfalls "False". Alphabetische ASCII-Zeichen sind
   diejenigen Bytewerte in der Sequenz
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'". ASCII-
   Dezimalziffern sind diejenigen Bytewerte in der Sequenz
   "b'0123456789'".

   Zum Beispiel:

      >>> b'ABCabc1'.isalnum()
      True
      >>> b'ABC abc1'.isalnum()
      False

bytes.isalpha()
bytearray.isalpha()

   Gibt "True" zurück, wenn alle Bytes in der Sequenz alphabetische
   ASCII-Zeichen sind und die Sequenz nicht leer ist, andernfalls
   "False". Alphabetische ASCII-Zeichen sind diejenigen Bytewerte in
   der Sequenz
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Zum Beispiel:

      >>> b'ABCabc'.isalpha()
      True
      >>> b'ABCabc1'.isalpha()
      False

bytes.isascii()
bytearray.isascii()

   Gibt "True" zurück, wenn die Sequenz leer ist oder alle Bytes in
   der Sequenz ASCII sind, andernfalls "False". ASCII-Bytes liegen im
   Bereich 0–0x7F.

   Added in version 3.7.

bytes.isdigit()
bytearray.isdigit()

   Gibt "True" zurück, wenn alle Bytes in der Sequenz ASCII-
   Dezimalziffern sind und die Sequenz nicht leer ist, andernfalls
   "False". ASCII-Dezimalziffern sind diejenigen Bytewerte in der
   Sequenz "b'0123456789'".

   Zum Beispiel:

      >>> b'1234'.isdigit()
      True
      >>> b'1.23'.isdigit()
      False

bytes.islower()
bytearray.islower()

   Gibt "True" zurück, wenn mindestens ein kleingeschriebenes ASCII-
   Zeichen in der Sequenz vorhanden ist und keine großgeschriebenen
   ASCII-Zeichen, andernfalls "False".

   Zum Beispiel:

      >>> b'hello world'.islower()
      True
      >>> b'Hello world'.islower()
      False

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.isspace()
bytearray.isspace()

   Gibt "True" zurück, wenn alle Bytes in der Sequenz ASCII-
   Whitespaces sind und die Sequenz nicht leer ist, andernfalls
   "False". ASCII-Whitespace-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b' \t\n\r\x0b\f'" (Leerzeichen, Tabulator, Zeilenvorschub,
   Wagenrücklauf, vertikaler Tabulator, Seitenvorschub).

bytes.istitle()
bytearray.istitle()

   Gibt "True" zurück, wenn die Sequenz im ASCII-Titlecase vorliegt
   und die Sequenz nicht leer ist, andernfalls "False". Siehe
   "bytes.title()" für weitere Details zur Definition von "Titlecase".

   Zum Beispiel:

      >>> b'Hello World'.istitle()
      True
      >>> b'Hello world'.istitle()
      False

bytes.isupper()
bytearray.isupper()

   Gibt "True" zurück, wenn mindestens ein großgeschriebenes
   alphabetisches ASCII-Zeichen in der Sequenz vorhanden ist und keine
   kleingeschriebenen ASCII-Zeichen, andernfalls "False".

   Zum Beispiel:

      >>> b'HELLO WORLD'.isupper()
      True
      >>> b'Hello world'.isupper()
      False

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.lower()
bytearray.lower()

   Gibt eine Kopie der Sequenz zurück, bei der alle großgeschriebenen
   ASCII-Zeichen in ihre entsprechenden kleingeschriebenen Gegenstücke
   umgewandelt wurden.

   Zum Beispiel:

      >>> b'Hello World'.lower()
      b'hello world'

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

   Gibt eine Liste der Zeilen in der binären Sequenz zurück, getrennt
   an ASCII-Zeilenbegrenzungen. Diese Methode verwendet den Ansatz der
   *universellen Zeilenenden* zum Trennen von Zeilen. Zeilenumbrüche
   sind nicht in der Ergebnisliste enthalten, es sei denn, *keepends*
   ist angegeben und wahr.

   Zum Beispiel:

      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
      [b'ab c', b'', b'de fg', b'kl']
      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

   Im Gegensatz zu "split()", wenn ein Trenn-String *sep* angegeben
   ist, gibt diese Methode für den leeren String eine leere Liste
   zurück, und ein abschließender Zeilenumbruch führt nicht zu einer
   zusätzlichen Zeile:

      >>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
      ([b''], [b'Two lines', b''])
      >>> b"".splitlines(), b"One line\n".splitlines()
      ([], [b'One line'])

bytes.swapcase()
bytearray.swapcase()

   Gibt eine Kopie der Sequenz zurück, bei der alle kleingeschriebenen
   ASCII-Zeichen in ihre entsprechenden großgeschriebenen Gegenstücke
   umgewandelt wurden und umgekehrt.

   Zum Beispiel:

      >>> b'Hello World'.swapcase()
      b'hELLO wORLD'

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Im Gegensatz zu "str.swapcase()" gilt für die binären Versionen
   immer "bin.swapcase().swapcase() == bin".
   Groß-/Kleinschreibungskonvertierungen sind in ASCII symmetrisch,
   auch wenn dies für beliebige Unicode-Codepunkte im Allgemeinen
   nicht zutrifft.

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.title()
bytearray.title()

   Gibt eine Titlecase-Version der binären Sequenz zurück, bei der
   Wörter mit einem großgeschriebenen ASCII-Zeichen beginnen und die
   restlichen Zeichen kleingeschrieben sind. Bytewerte ohne
   Groß-/Kleinschreibung bleiben unverändert.

   Zum Beispiel:

      >>> b'Hello world'.title()
      b'Hello World'

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'". Alle anderen Bytewerte haben keine
   Groß-/Kleinschreibung.

   Der Algorithmus verwendet eine einfache sprachunabhängige
   Definition eines Wortes als Gruppen aufeinanderfolgender
   Buchstaben. Diese Definition funktioniert in vielen Kontexten,
   bedeutet jedoch, dass Apostrophe in Verkürzungen und
   Possessivformen Wortgrenzen bilden, was möglicherweise nicht das
   gewünschte Ergebnis ist:

      >>> b"they're bill's friends from the UK".title()
      b"They'Re Bill'S Friends From The Uk"

   Ein Workaround für Apostrophe kann mithilfe regulärer Ausdrücke
   konstruiert werden:

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0)[0:1].upper() +
      ...                              mo.group(0)[1:].lower(),
      ...                   s)
      ...
      >>> titlecase(b"they're bill's friends.")
      b"They're Bill's Friends."

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.upper()
bytearray.upper()

   Gibt eine Kopie der Sequenz zurück, bei der alle kleingeschriebenen
   ASCII-Zeichen in ihre entsprechenden großgeschriebenen Gegenstücke
   umgewandelt wurden.

   Zum Beispiel:

      >>> b'Hello World'.upper()
      b'HELLO WORLD'

   Kleingeschriebene ASCII-Zeichen sind diejenigen Bytewerte in der
   Sequenz "b'abcdefghijklmnopqrstuvwxyz'". Großgeschriebene ASCII-
   Zeichen sind diejenigen Bytewerte in der Sequenz
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.

bytes.zfill(width, /)
bytearray.zfill(width, /)

   Gibt eine Kopie der Sequenz links mit ASCII-"b'0'"-Ziffern
   aufgefüllt zurück, um eine Sequenz der Länge *width* zu erzeugen.
   Ein führendes Vorzeichenpräfix ("b'+'"/"b'-'") wird behandelt,
   indem das Füllzeichen *nach* dem Vorzeichenzeichen anstelle davor
   eingefügt wird. Für "bytes"-Objekte wird die ursprüngliche Sequenz
   zurückgegeben, wenn *width* kleiner oder gleich "len(seq)" ist.

   Zum Beispiel:

      >>> b"42".zfill(5)
      b'00042'
      >>> b"-42".zfill(5)
      b'-0042'

   Bemerkung:

     Die Bytearray-Version dieser Methode arbeitet *nicht* in-place –
     sie erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
     vorgenommen wurden.


Bytes-Formatierung im "printf"-Stil
-----------------------------------

Bemerkung:

  Die hier beschriebenen Formatierungsoperationen weisen eine Reihe
  von Eigenheiten auf, die zu häufigen Fehlern führen (wie z. B. dem
  fehlerhaften Darstellen von Tupeln und Dictionaries). Wenn der
  auszugebende Wert ein Tupel oder Dictionary sein kann, packe ihn in
  ein Tupel.

Bytes-Objekte ("bytes"/"bytearray") besitzen eine einzigartige
eingebaute Operation: den Operator "%" (Modulo). Dieser wird auch als
Bytes-*Formatierungs*- oder *Interpolations*-Operator bezeichnet. Bei
"format % values" (wobei *format* ein Bytes-Objekt ist) werden
"%"-Konvertierungsspezifikationen in *format* durch null oder mehr
Elemente aus *values* ersetzt. Die Wirkung ähnelt der Verwendung von
"sprintf()" in der Sprache C.

Wenn *format* ein einzelnes Argument erfordert, kann *values* ein
einzelnes Nicht-Tupel-Objekt sein. [5] Andernfalls muss *values* ein
Tupel mit genau der durch das Format-Bytes-Objekt angegebenen Anzahl
von Elementen oder ein einzelnes Mapping-Objekt (z. B. ein Dictionary)
sein.

Ein Konvertierungsspezifizierer besteht aus zwei oder mehr Zeichen und
hat die folgenden Komponenten, die in dieser Reihenfolge auftreten
müssen:

1. Das Zeichen "'%'", das den Beginn des Spezifizierers markiert.

2. Mapping-Schlüssel (optional), bestehend aus einer eingeklammerten
   Zeichenfolge (zum Beispiel "(somename)").

3. Konvertierungs-Flags (optional), die das Ergebnis bestimmter
   Konvertierungstypen beeinflussen.

4. Minimale Feldbreite (optional). Wenn sie als "'*'" (Sternchen)
   angegeben ist, wird die tatsächliche Breite aus dem nächsten
   Element des Tupels in *values* gelesen, und das zu konvertierende
   Objekt folgt nach der minimalen Feldbreite und der optionalen
   Genauigkeit.

5. Genauigkeit (optional), angegeben als "'.'" (Punkt) gefolgt von der
   Genauigkeit. Wenn sie als "'*'" (Sternchen) angegeben ist, wird die
   tatsächliche Genauigkeit aus dem nächsten Element des Tupels in
   *values* gelesen, und der zu konvertierende Wert folgt nach der
   Genauigkeit.

6. Längenmodifikator (optional).

7. Konvertierungstyp.

Wenn das rechte Argument ein Dictionary (oder ein anderer Mapping-Typ)
ist, *müssen* die Formate im Bytes-Objekt einen eingeklammerten
Mapping-Schlüssel für dieses Dictionary enthalten, der unmittelbar
nach dem Zeichen "'%'" eingefügt wird. Der Mapping-Schlüssel wählt den
zu formatierenden Wert aus dem Mapping aus. Zum Beispiel:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

In diesem Fall dürfen keine "*"-Spezifizierer in einem Format
vorkommen (da diese eine sequentielle Parameterliste erfordern).

Die Konvertierungs-Flag-Zeichen sind:

+-----------+-----------------------------------------------------------------------+
| Flag      | Bedeutung                                                             |
|===========|=======================================================================|
| "'#'"     | Die Wertkonvertierung verwendet die "alternative Form" (sofern unten  |
|           | definiert).                                                           |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | Die Konvertierung wird bei numerischen Werten mit Nullen aufgefüllt.  |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | Der konvertierte Wert wird linksbündig ausgerichtet (überschreibt die |
|           | "'0'"-Konvertierung, wenn beide angegeben sind).                      |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (ein Leerzeichen) Vor einer positiven Zahl (oder einem leeren         |
|           | String), die durch eine vorzeichenbehaftete Konvertierung erzeugt     |
|           | wird, sollte ein Leerzeichen verbleiben.                              |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | Ein Vorzeichen ("'+'" oder "'-'") wird der Konvertierung              |
|           | vorangestellt (überschreibt ein "Leerzeichen"-Flag).                  |
+-----------+-----------------------------------------------------------------------+

Ein Längenmodifikator ("h", "l" oder "L") kann vorhanden sein, wird
jedoch ignoriert, da er für Python nicht erforderlich ist – so ist z.
B. "%ld" identisch mit "%d".

Die Konvertierungstypen sind:

+--------------+-------------------------------------------------------+---------+
| Konvertieru  | Bedeutung                                             | Hinwei  |
| ng           |                                                       | se      |
|==============|=======================================================|=========|
| "'d'"        | Vorzeichenbehaftete Dezimal-Ganzzahl.                 |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Vorzeichenbehaftete Dezimal-Ganzzahl.                 |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Vorzeichenbehafteter Oktalwert.                       | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Veralteter Typ – er ist identisch mit "'d'".          | (8)     |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Vorzeichenbehaftetes Hexadezimal (Kleinbuchstaben).   | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Vorzeichenbehaftetes Hexadezimal (Großbuchstaben).    | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Gleitkomma-Exponentialformat (Kleinbuchstaben).       | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Gleitkomma-Exponentialformat (Großbuchstaben).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Gleitkomma-Dezimalformat.                             | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Gleitkomma-Dezimalformat.                             | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Gleitkommaformat. Verwendet das Exponentialformat in  | (4)     |
|              | Kleinbuchstaben, wenn der Exponent kleiner als -4     |         |
|              | oder nicht kleiner als die Genauigkeit ist,           |         |
|              | andernfalls das Dezimalformat.                        |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Gleitkommaformat. Verwendet das Exponentialformat in  | (4)     |
|              | Großbuchstaben, wenn der Exponent kleiner als -4 oder |         |
|              | nicht kleiner als die Genauigkeit ist, andernfalls    |         |
|              | das Dezimalformat.                                    |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Einzelnes Byte (akzeptiert Ganzzahl oder Einzel-Byte- |         |
|              | Objekte).                                             |         |
+--------------+-------------------------------------------------------+---------+
| "'b'"        | Bytes (jedes Objekt, das dem Pufferprotokoll folgt    | (5)     |
|              | oder "__bytes__()" besitzt).                          |         |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | "'s'" ist ein Alias für "'b'" und sollte nur für      | (6)     |
|              | Python-2/3-Codebasen verwendet werden.                |         |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | Bytes (konvertiert jedes Python-Objekt mittels        | (5)     |
|              | "repr(obj).encode('ascii', 'backslashreplace')").     |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | "'r'" ist ein Alias für "'a'" und sollte nur für      | (7)     |
|              | Python-2/3-Codebasen verwendet werden.                |         |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | Kein Argument wird konvertiert, führt zu einem        |         |
|              | "'%'"-Zeichen im Ergebnis.                            |         |
+--------------+-------------------------------------------------------+---------+

Hinweise:

1. Die alternative Form bewirkt, dass vor der ersten Ziffer eine
   führende Oktal-Kennzeichnung ("'0o'") eingefügt wird.

2. Die alternative Form bewirkt, dass vor der ersten Ziffer ein
   führendes "'0x'" oder "'0X'" eingefügt wird (je nachdem, ob das
   Format "'x'" oder "'X'" verwendet wurde).

3. Die alternative Form bewirkt, dass das Ergebnis immer einen
   Dezimalpunkt enthält, selbst wenn keine Ziffern folgen.

   Die Genauigkeit bestimmt die Anzahl der Nachkommastellen und ist
   standardmäßig 6.

4. Die alternative Form bewirkt, dass das Ergebnis immer einen
   Dezimalpunkt enthält und nachgestellte Nullen nicht entfernt
   werden, wie es sonst der Fall wäre.

   Die Genauigkeit bestimmt die Anzahl der signifikanten Stellen vor
   und nach dem Dezimalpunkt und ist standardmäßig 6.

5. Wenn die Genauigkeit "N" beträgt, wird die Ausgabe auf "N" Zeichen
   gekürzt.

6. "b'%s'" ist veraltet, wird jedoch während der 3.x-Reihe nicht
   entfernt.

7. "b'%r'" ist veraltet, wird jedoch während der 3.x-Reihe nicht
   entfernt.

8. Siehe **PEP 237**.

Bemerkung:

  Die Bytearray-Version dieser Methode arbeitet *nicht* in-place – sie
  erzeugt immer ein neues Objekt, selbst wenn keine Änderungen
  vorgenommen wurden.

Siehe auch: **PEP 461** - Adding % formatting to bytes and bytearray

Added in version 3.5.


Memory-Views
------------

"memoryview"-Objekte ermöglichen es Python-Code, ohne Kopieren auf die
internen Daten eines Objekts zuzugreifen, das das Pufferprotokoll
unterstützt.

class memoryview(object)

   Erstellt eine "memoryview", die *object* referenziert. *object*
   muss das Pufferprotokoll unterstützen. Zu den eingebauten Objekten,
   die das Pufferprotokoll unterstützen, gehören "bytes" und
   "bytearray".

   Eine "memoryview" hat das Konzept eines *Elements*, bei dem es sich
   um die atomare Speichereinheit handelt, die vom ursprünglichen
   *object* verwaltet wird. Für viele einfache Typen wie "bytes" und
   "bytearray" ist ein Element ein einzelnes Byte, andere Typen wie
   "array.array" können jedoch größere Elemente haben.

   "len(view)" is equal to the length of "tolist", which is the nested
   list representation of the view. If "view.ndim == 1", this is equal
   to the number of elements in the view.

   Geändert in Version 3.12: Wenn "view.ndim == 0" ist, löst
   "len(view)" nun einen "TypeError" aus, anstatt 1 zurückzugeben.

   Das Attribut "itemsize" gibt die Anzahl der Bytes in einem
   einzelnen Element an.

   Eine "memoryview" unterstützt Slicing und Indizierung zum
   Bereitstellen ihrer Daten. Eindimensionales Slicing führt zu einem
   Subview:

      >>> v = memoryview(b'abcefg')
      >>> v[1]
      98
      >>> v[-1]
      103
      >>> v[1:4]
      <memory at 0x7f3ddc9f4350>
      >>> bytes(v[1:4])
      b'bce'

   Wenn "format" einer der nativen Formatspezifizierer aus dem Modul
   "struct" ist, wird auch die Indizierung mit einer Ganzzahl oder
   einem Tupel von Ganzzahlen unterstützt und gibt ein einzelnes
   *Element* mit dem korrekten Typ zurück. Eindimensionale Memoryviews
   können mit einer Ganzzahl oder einem Ein-Ganzzahl-Tupel indiziert
   werden. Mehrdimensionale Memoryviews können mit Tupeln aus genau
   *ndim* Ganzzahlen indiziert werden, wobei *ndim* die Anzahl der
   Dimensionen ist. Nulldimensionale Memoryviews können mit dem leeren
   Tupel indiziert werden.

   Hier ist ein Beispiel mit einem Nicht-Byte-Format:

      >>> import array
      >>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
      >>> m = memoryview(a)
      >>> m[0]
      -11111111
      >>> m[-1]
      44444444
      >>> m[::2].tolist()
      [-11111111, -33333333]

   Wenn das zugrunde liegende Objekt beschreibbar ist, unterstützt die
   Memoryview die eindimensionale Slice-Zuweisung. Größenänderungen
   sind nicht erlaubt:

      >>> data = bytearray(b'abcefg')
      >>> v = memoryview(data)
      >>> v.readonly
      False
      >>> v[0] = ord(b'z')
      >>> data
      bytearray(b'zbcefg')
      >>> v[1:4] = b'123'
      >>> data
      bytearray(b'z123fg')
      >>> v[2:3] = b'spam'
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: memoryview assignment: lvalue and rvalue have different structures
      >>> v[2:6] = b'spam'
      >>> data
      bytearray(b'z1spam')

   Eindimensionale Memoryviews von *hashbaren* (schreibgeschützten)
   Typen mit den Formaten 'B', 'b' oder 'c' sind ebenfalls hashbar.
   Der Hash ist definiert als "hash(m) == hash(m.tobytes())":

      >>> v = memoryview(b'abcefg')
      >>> hash(v) == hash(b'abcefg')
      True
      >>> hash(v[2:4]) == hash(b'ce')
      True
      >>> hash(v[::-2]) == hash(b'abcefg'[::-2])
      True

   Geändert in Version 3.3: Eindimensionale Memoryviews können nun
   gesliced werden. Eindimensionale Memoryviews mit den Formaten 'B',
   'b' oder 'c' sind nun *hashbar*.

   Geändert in Version 3.4: memoryview wird nun automatisch bei
   "collections.abc.Sequence" registriert

   Geändert in Version 3.5: Memoryviews können nun mit Tupeln aus
   Ganzzahlen indiziert werden.

   "memoryview" besitzt mehrere Methoden:

   __eq__(exporter)

      Eine Memoryview und ein **PEP 3118**-Exporter sind gleich, wenn
      ihre Shapes äquivalent sind und alle entsprechenden Werte gleich
      sind, wenn die jeweiligen Formatcodes der Operanden unter
      Verwendung der "struct"-Syntax interpretiert werden.

      Für die Teilmenge der "struct"-Format-Strings, die derzeit von
      "tolist()" unterstützt werden, sind "v" und "w" gleich, wenn
      "v.tolist() == w.tolist()" gilt:

         >>> import array
         >>> a = array.array('I', [1, 2, 3, 4, 5])
         >>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
         >>> c = array.array('b', [5, 3, 1])
         >>> x = memoryview(a)
         >>> y = memoryview(b)
         >>> x == a == y == b
         True
         >>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
         True
         >>> z = y[::-2]
         >>> z == c
         True
         >>> z.tolist() == c.tolist()
         True

      Wenn einer der beiden Format-Strings vom Modul "struct" nicht
      unterstützt wird, werden die Objekte immer als ungleich bewertet
      (selbst wenn die Format-Strings und Pufferinhalte identisch
      sind):

         >>> from ctypes import BigEndianStructure, c_long
         >>> class BEPoint(BigEndianStructure):
         ...     _fields_ = [("x", c_long), ("y", c_long)]
         ...
         >>> point = BEPoint(100, 200)
         >>> a = memoryview(point)
         >>> b = memoryview(point)
         >>> a == point
         False
         >>> a == b
         False

      Beachte, dass wie bei Gleitkommazahlen für Memoryview-Objekte "v
      is w" *nicht* bedeutet, dass "v == w" gilt.

      Geändert in Version 3.3: Frühere Versionen verglichen den
      Rohspeicher ohne Berücksichtigung des Elementformats und der
      logischen Array-Struktur.

   tobytes(order='C')

      Gibt die Daten im Puffer als Byte-String zurück. Dies entspricht
      dem Aufruf des "bytes"-Konstruktors auf der Memoryview.

         >>> m = memoryview(b"abc")
         >>> m.tobytes()
         b'abc'
         >>> bytes(m)
         b'abc'

      Für nicht-zusammenhängende Arrays entspricht das Ergebnis der
      flachen Listendarstellung, bei der alle Elemente in Bytes
      konvertiert wurden. "tobytes()" unterstützt alle Format-Strings,
      einschließlich derer, die nicht in der Syntax des Moduls
      "struct" vorliegen.

      Added in version 3.8: *order* kann {'C', 'F', 'A'} sein. Wenn
      *order* 'C' oder 'F' ist, werden die Daten des ursprünglichen
      Arrays in C- oder Fortran-Reihenfolge konvertiert. Für
      zusammenhängende Views gibt 'A' eine exakte Kopie des physischen
      Speichers zurück. Insbesondere bleibt die Fortran-Reihenfolge im
      Speicher erhalten. Für nicht-zusammenhängende Views werden die
      Daten zuerst nach C konvertiert. *order=None* entspricht
      *order='C'*.

   hex(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

      Gibt ein String-Objekt zurück, das zwei Hexadezimalziffern für
      jedes Byte im Puffer enthält.

         >>> m = memoryview(b"abc")
         >>> m.hex()
         '616263'

      Added in version 3.5.

      Geändert in Version 3.8: Ähnlich wie "bytes.hex()" unterstützt
      nun auch "memoryview.hex()" die optionalen Parameter *sep* und
      *bytes_per_sep*, um Trennzeichen zwischen Bytes in der Hex-
      Ausgabe einzufügen.

   tolist()

      Gibt die Daten im Puffer als eine Liste von Elementen zurück.

         >>> memoryview(b'abc').tolist()
         [97, 98, 99]
         >>> import array
         >>> a = array.array('d', [1.1, 2.2, 3.3])
         >>> m = memoryview(a)
         >>> m.tolist()
         [1.1, 2.2, 3.3]

      Geändert in Version 3.3: "tolist()" unterstützt nun alle nativen
      Einzelzeichen-Formate in der Syntax des Moduls "struct" sowie
      mehrdimensionale Darstellungen.

   toreadonly()

      Gibt eine schreibgeschützte Version des Memoryview-Objekts
      zurück. Das ursprüngliche Memoryview-Objekt bleibt unverändert.

         >>> m = memoryview(bytearray(b'abc'))
         >>> mm = m.toreadonly()
         >>> mm.tolist()
         [97, 98, 99]
         >>> mm[0] = 42
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         TypeError: cannot modify read-only memory
         >>> m[0] = 43
         >>> mm.tolist()
         [43, 98, 99]

      Added in version 3.8.

   release()

      Gibt den zugrunde liegenden Puffer frei, der durch das
      Memoryview-Objekt bereitgestellt wird. Viele Objekte ergreifen
      besondere Maßnahmen, wenn ein View auf sie gehalten wird
      (beispielsweise verbietet ein "bytearray" vorübergehend
      Größenänderungen); daher ist der Aufruf von release() praktisch,
      um diese Einschränkungen so schnell wie möglich aufzuheben (und
      verbleibende Ressourcen freizugeben).

      Nachdem diese Methode aufgerufen wurde, löst jede weitere
      Operation auf dem View einen "ValueError" aus (außer "release()"
      selbst, das mehrmals aufgerufen werden kann):

         >>> m = memoryview(b'abc')
         >>> m.release()
         >>> m[0]
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: operation forbidden on released memoryview object

      Das Kontextmanagement-Protokoll kann für einen ähnlichen Effekt
      unter Verwendung der "with"-Anweisung genutzt werden:

         >>> with memoryview(b'abc') as m:
         ...     m[0]
         ...
         97
         >>> m[0]
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: operation forbidden on released memoryview object

      Added in version 3.2.

   cast(format, /)
   cast(format, shape, /)

      Wandelt eine Memoryview in ein neues Format oder ein neues Shape
      um. Für *shape* ist der Standardwert
      "[byte_length//new_itemsize]", was bedeutet, dass der Ergebnis-
      View eindimensional ist. Der Rückgabewert ist eine neue
      Memoryview, der Puffer selbst wird jedoch nicht kopiert.
      Unterstützte Typumwandlungen (Casts) sind 1D ->
      C-*zusammenhängend* und C-zusammenhängend -> 1D.

      Das Zielformat ist auf ein natives Einzelelementformat in der
      "struct"-Syntax beschränkt. Eines der Formate muss ein Byte-
      Format ('B', 'b' oder 'c') sein. Die Byte-Länge des Ergebnisses
      muss mit der ursprünglichen Länge übereinstimmen. Beachte, dass
      alle Byte-Längen vom Betriebssystem abhängen können.

      Umwandlung von 1D/Long in 1D/Unsigned Bytes:

         >>> import array
         >>> a = array.array('l', [1,2,3])
         >>> x = memoryview(a)
         >>> x.format
         'l'
         >>> x.itemsize
         8
         >>> len(x)
         3
         >>> x.nbytes
         24
         >>> y = x.cast('B')
         >>> y.format
         'B'
         >>> y.itemsize
         1
         >>> len(y)
         24
         >>> y.nbytes
         24

      Umwandlung von 1D/Unsigned Bytes in 1D/Char:

         >>> b = bytearray(b'zyz')
         >>> x = memoryview(b)
         >>> x[0] = b'a'
         Traceback (most recent call last):
           ...
         TypeError: memoryview: invalid type for format 'B'
         >>> y = x.cast('c')
         >>> y[0] = b'a'
         >>> b
         bytearray(b'ayz')

      Umwandlung von 1D/Bytes in 3D/Ints in 1D/Signed Char:

         >>> import struct
         >>> buf = struct.pack("i"*12, *list(range(12)))
         >>> x = memoryview(buf)
         >>> y = x.cast('i', shape=[2,2,3])
         >>> y.tolist()
         [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
         >>> y.format
         'i'
         >>> y.itemsize
         4
         >>> len(y)
         2
         >>> y.nbytes
         48
         >>> z = y.cast('b')
         >>> z.format
         'b'
         >>> z.itemsize
         1
         >>> len(z)
         48
         >>> z.nbytes
         48

      Umwandlung von 1D/Unsigned Long in 2D/Unsigned Long:

         >>> buf = struct.pack("L"*6, *list(range(6)))
         >>> x = memoryview(buf)
         >>> y = x.cast('L', shape=[2,3])
         >>> len(y)
         2
         >>> y.nbytes
         48
         >>> y.tolist()
         [[0, 1, 2], [3, 4, 5]]

      Added in version 3.3.

      Geändert in Version 3.5: Das Quellformat ist bei der Umwandlung
      in einen Byte-View nicht mehr eingeschränkt.

   Es stehen außerdem mehrere schreibgeschützte Attribute zur
   Verfügung:

   obj

      Das zugrunde liegende Objekt der Memoryview:

         >>> b  = bytearray(b'xyz')
         >>> m = memoryview(b)
         >>> m.obj is b
         True

      Added in version 3.3.

   nbytes

      "nbytes == product(shape) * itemsize == len(m.tobytes())". Dies
      ist der Speicherplatz in Bytes, den das Array in einer
      zusammenhängenden Darstellung belegen würde. Er ist nicht
      zwingend gleich "len(m)":

         >>> import array
         >>> a = array.array('i', [1,2,3,4,5])
         >>> m = memoryview(a)
         >>> len(m)
         5
         >>> m.nbytes
         20
         >>> y = m[::2]
         >>> len(y)
         3
         >>> y.nbytes
         12
         >>> len(y.tobytes())
         12

      Mehrdimensionale Arrays:

         >>> import struct
         >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
         >>> x = memoryview(buf)
         >>> y = x.cast('d', shape=[3,4])
         >>> y.tolist()
         [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
         >>> len(y)
         3
         >>> y.nbytes
         96

      Added in version 3.3.

   readonly

      Ein boolescher Wert, der angibt, ob der Speicher
      schreibgeschützt ist.

   format

      Ein String, der das Format (im Stil des Moduls "struct") für
      jedes Element im View enthält. Eine Memoryview kann von
      Exportern mit beliebigen Format-Strings erzeugt werden, einige
      Methoden (z. B. "tolist()") sind jedoch auf native Einzel-
      Element-Formate beschränkt.

      Geändert in Version 3.3: Das Format "'B'" wird nun gemäß der
      Syntax des Moduls struct behandelt. Das bedeutet, dass
      "memoryview(b'abc')[0] == b'abc'[0] == 97" gilt.

   itemsize

      Die Größe jedes Elements der Memoryview in Bytes:

         >>> import array, struct
         >>> m = memoryview(array.array('H', [32000, 32001, 32002]))
         >>> m.itemsize
         2
         >>> m[0]
         32000
         >>> struct.calcsize('H') == m.itemsize
         True

   ndim

      Eine Ganzzahl, die angibt, wie viele Dimensionen eines
      mehrdimensionalen Arrays der Speicher darstellt.

   shape

      Ein Tupel aus Ganzzahlen mit der Länge von "ndim", das das Shape
      des Speichers als N-dimensionales Array angibt.

      Geändert in Version 3.3: Ein leeres Tupel anstelle von "None",
      wenn ndim = 0 ist.

   strides

      Ein Tupel aus Ganzzahlen mit der Länge von "ndim", das die Größe
      in Bytes für den Zugriff auf jedes Element für jede Dimension
      des Arrays angibt.

      Geändert in Version 3.3: Ein leeres Tupel anstelle von "None",
      wenn ndim = 0 ist.

   suboffsets

      Wird intern für Arrays im PIL-Stil verwendet. Der Wert dient nur
      zur Information.

   c_contiguous

      Ein boolescher Wert, der angibt, ob der Speicher
      C-*zusammenhängend* ist.

      Added in version 3.3.

   f_contiguous

      Ein boolescher Wert, der angibt, ob der Speicher
      Fortran-*zusammenhängend* ist.

      Added in version 3.3.

   contiguous

      Ein boolescher Wert, der angibt, ob der Speicher
      *zusammenhängend* ist.

      Added in version 3.3.


Mengen-Typen – "set", "frozenset"
=================================

A *set* object is an unordered collection of distinct *hashable*
objects. Common uses include membership testing, removing duplicates
from a sequence, and computing mathematical operations such as
intersection, union, difference, and symmetric difference. (For other
containers see the built-in "dict", "list", and "tuple" classes, and
the "collections" module.)

Wie andere Sammlungen unterstützen Mengen "x in set", "len(set)" und
"for x in set". Als ungeordnete Sammlung speichern Mengen weder die
Position der Elemente noch die Einfügereihenfolge. Dementsprechend
unterstützen Mengen weder Indizierung, Slicing noch anderes
sequenzartiges Verhalten.

There are currently two built-in set types, "set" and "frozenset". The
"set" type is mutable --- the contents can be changed using methods
like "add()" and "remove()".  Since it is mutable, it has no hash
value and cannot be used as either a dictionary key or as an element
of another set.  The "frozenset" type is immutable and *hashable* ---
its contents cannot be altered after it is created; it can therefore
be used as a dictionary key or as an element of another set.

Nicht-leere Mengen (keine Frozensets) können neben dem Konstruktor
"set" auch durch eine kommagetrennte Liste von Elementen in
geschweiften Klammern erstellt werden, zum Beispiel: "{'jack',
'sjoerd'}".

Die Konstruktoren für beide Klassen funktionieren gleich:

class set(iterable=(), /)
class frozenset(iterable=(), /)

   Gibt ein neues Set- oder Frozenset-Objekt zurück, dessen Elemente
   aus *iterable* stammen. Die Elemente einer Menge müssen *hashbar*
   sein. Um Mengen von Mengen darzustellen, müssen die inneren Mengen
   "frozenset"-Objekte sein. Wenn *iterable* nicht angegeben ist, wird
   eine neue leere Menge zurückgegeben.

Mengen können auf verschiedene Arten erstellt werden:

* Verwendung einer kommagetrennten Liste von Elementen in geschweiften
  Klammern: "{'jack', 'sjoerd'}"

* Verwendung einer Set-Comprehension: "{c for c in 'abracadabra' if c
  not in 'abc'}"

* Verwendung des Typ-Konstruktors: "set()", "set('foobar')",
  "set(['a', 'b', 'foo'])"

Instanzen von "set" und "frozenset" bieten die folgenden Operationen:

len(s)

   Gibt die Anzahl der Elemente in der Menge *s* zurück (Kardinalität
   von *s*).

x in s

   Prüft *x* auf Mitgliedschaft in *s*.

x not in s

   Prüft *x* auf Nicht-Mitgliedschaft in *s*.

frozenset.isdisjoint(other, /)
set.isdisjoint(other, /)

   Gibt "True" zurück, wenn die Menge keine gemeinsamen Elemente mit
   *other* hat. Mengen sind genau dann disjunkt, wenn ihre
   Schnittmenge die leere Menge ist.

frozenset.issubset(other, /)
set.issubset(other, /)

set <= other

   Prüft, ob jedes Element der Menge in *other* enthalten ist.

set < other

   Prüft, ob die Menge eine echte Teilmenge von *other* ist, das heißt
   "set <= other and set != other".

frozenset.issuperset(other, /)
set.issuperset(other, /)

set >= other

   Prüft, ob jedes Element in *other* in der Menge enthalten ist.

set > other

   Prüft, ob die Menge eine echte Obermenge von *other* ist, das heißt
   "set >= other and set != other".

frozenset.union(*others)
set.union(*others)

set | other | ...

   Gibt eine neue Menge mit Elementen aus der Menge und allen anderen
   zurück.

frozenset.intersection(*others)
set.intersection(*others)

set & other & ...

   Gibt eine neue Menge mit Elementen zurück, die der Menge und allen
   anderen gemeinsam sind.

frozenset.difference(*others)
set.difference(*others)

set - other - ...

   Gibt eine neue Menge mit Elementen der Menge zurück, die nicht in
   den anderen enthalten sind.

frozenset.symmetric_difference(other, /)
set.symmetric_difference(other, /)

set ^ other

   Gibt eine neue Menge mit Elementen zurück, die entweder in der
   Menge oder in *other*, aber nicht in beiden enthalten sind.

frozenset.copy()
set.copy()

   Gibt eine flache Kopie (Shallow Copy) der Menge zurück.

Beachte, dass die Nicht-Operator-Versionen der Methoden "union()",
"intersection()", "difference()", "symmetric_difference()",
"issubset()" und "issuperset()" jedes Iterable als Argument
akzeptieren. Im Gegensatz dazu erfordern deren operatorbasierte
Gegenstücke, dass ihre Argumente Mengen sind. Dies schließt
fehleranfällige Konstruktionen wie "set('abc') & 'cbs'" zugunsten des
lesbareren "set('abc').intersection('cbs')" aus.

Sowohl "set" als auch "frozenset" unterstützen Menge-zu-Menge-
Vergleiche. Zwei Mengen sind genau dann gleich, wenn jedes Element
jeder Menge in der jeweils anderen enthalten ist (jede eine Teilmenge
der anderen ist). Eine Menge ist kleiner als eine andere Menge genau
dann, wenn die erste Menge eine echte Teilmenge der zweiten Menge ist
(eine Teilmenge ist, aber nicht gleich ist). Eine Menge ist größer als
eine andere Menge genau dann, wenn die erste Menge eine echte
Obermenge der zweiten Menge ist (eine Obermenge ist, aber nicht gleich
ist).

Instanzen von "set" werden basierend auf ihren Elementen mit Instanzen
von "frozenset" verglichen. Zum Beispiel gibt "set('abc') ==
frozenset('abc')" "True" zurück, ebenso wie "set('abc') in
set([frozenset('abc')])".

Die Teilmengen- und Gleichheitsvergleiche lassen sich nicht zu einer
totalen Ordnungsfunktion verallgemeinern. Beispielsweise sind zwei
beliebige nicht-leere, disjunkte Mengen weder gleich noch Teilmengen
voneinander, sodass *alle* der folgenden Vergleiche "False"
zurückgeben: "a<b", "a==b" oder "a>b".

Da Mengen nur eine Halbordnung (Teilmengenbeziehungen) definieren, ist
die Ausgabe der Methode "list.sort()" für Listen von Mengen
undefiniert.

Mengenelemente müssen, wie Dictionary-Schlüssel, *hashbar* sein.

Binäre Operationen, die "set"-Instanzen mit "frozenset" mischen, geben
den Typ des ersten Operanden zurück. Zum Beispiel gibt
"frozenset('ab') | set('bc')" eine Instanz von "frozenset" zurück.

Die folgende Tabelle listet Operationen auf, die für "set" verfügbar
sind, jedoch nicht für unveränderliche Instanzen von "frozenset"
gelten:

set.update(*others)

set |= other | ...

   Aktualisiert die Menge und fügt Elemente aus allen anderen hinzu.

set.intersection_update(*others)

set &= other & ...

   Aktualisiert die Menge und behält nur Elemente bei, die sowohl in
   ihr als auch in allen anderen vorkommen.

set.difference_update(*others)

set -= other | ...

   Aktualisiert die Menge und entfernt Elemente, die in den anderen
   vorkommen.

set.symmetric_difference_update(other, /)

set ^= other

   Aktualisiert die Menge und behält nur Elemente bei, die in einer
   der beiden Mengen vorkommen, jedoch nicht in beiden.

set.add(elem, /)

   Fügt das Element *elem* zur Menge hinzu.

set.remove(elem, /)

   Entfernt das Element *elem* aus der Menge. Löst einen "KeyError"
   aus, wenn *elem* nicht in der Menge enthalten ist.

set.discard(elem, /)

   Entfernt das Element *elem* aus der Menge, falls es vorhanden ist.

set.pop()

   Entfernt ein beliebiges Element aus der Menge und gibt es zurück.
   Löst einen "KeyError" aus, wenn die Menge leer ist.

set.clear()

   Entfernt alle Elemente aus der Menge.

Beachte, dass die Nicht-Operator-Versionen der Methoden "update()",
"intersection_update()", "difference_update()" und
"symmetric_difference_update()" jedes Iterable als Argument
akzeptieren.

Beachte, dass das Argument *elem* für die Methoden "__contains__()",
"remove()" und "discard()" eine Menge sein kann. Um die Suche nach
einem äquivalenten Frozenset zu unterstützen, wird aus *elem*
vorübergehend ein solches erstellt.

Sets und Frozensets sind über einen Typparameter generisch, der den
Typ ihrer Elemente angibt.


Mapping-Typen – "dict"
======================

A *mapping* object maps *hashable* values to arbitrary objects.
Mappings are mutable objects.  There is currently only one standard
mapping type, the *dictionary*.  (For other containers see the built-
in "list", "set", and "tuple" classes, and the "collections" module.)

Die Schlüssel eines Dictionaries sind *fast* beliebige Werte. Werte,
die nicht *hashbar* sind – also Werte, die Listen, Dictionaries oder
andere veränderliche Typen enthalten (die nach Wert statt nach
Objektidentität verglichen werden) –, dürfen nicht als Schlüssel
verwendet werden. Werte, die als gleich gelten (wie "1", "1.0" und
"True"), können austauschbar verwendet werden, um denselben
Dictionary-Eintrag zu indizieren.

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

   Gibt ein neues Dictionary zurück, initialisiert aus einem
   optionalen Positionsargument und einer möglicherweise leeren Menge
   von Schlüsselwort-Argumenten.

   Dictionaries können auf verschiedene Arten erstellt werden:

   * Verwendung einer kommagetrennten Liste von "key: value"-Paaren in
     geschweiften Klammern: "{'jack': 4098, 'sjoerd': 4127}" oder
     "{4098: 'jack', 4127: 'sjoerd'}"

   * Verwendung einer Dict-Comprehension: "{}", "{x: x ** 2 for x in
     range(10)}"

   * Verwendung des Typ-Konstruktors: "dict()", "dict([('foo', 100),
     ('bar', 200)])", "dict(foo=100, bar=200)"

   Wenn kein Positionsargument angegeben ist, wird ein leeres
   Dictionary erstellt. Wenn ein Positionsargument angegeben ist und
   eine "keys()"-Methode definiert, wird ein Dictionary erstellt,
   indem "__getitem__()" auf dem Argument mit jedem von der Methode
   zurückgegebenen Schlüssel aufgerufen wird. Andernfalls muss das
   Positionsargument ein *iterierbares Objekt* sein. Jedes Element im
   Iterable muss selbst ein Iterable mit genau zwei Elementen sein.
   Das erste Element jedes Eintrags wird zu einem Schlüssel im neuen
   Dictionary und das zweite Element zum entsprechenden Wert. Wenn ein
   Schlüssel mehrfach vorkommt, wird der letzte Wert für diesen
   Schlüssel zum entsprechenden Wert im neuen Dictionary.

   Wenn Schlüsselwort-Argumente angegeben sind, werden diese und ihre
   Werte zu dem aus dem Positionsargument erstellten Dictionary
   hinzugefügt. Wenn ein hinzuzufügender Schlüssel bereits vorhanden
   ist, ersetzt der Wert aus dem Schlüsselwort-Argument den Wert aus
   dem Positionsargument.

   Dictionaries sind genau dann gleich, wenn sie dieselben "(key,
   value)"-Paare enthalten (unabhängig von der Reihenfolge).
   Ordnungsvergleiche ('<', '<=', '>=', '>') lösen einen "TypeError"
   aus. Zur Veranschaulichung der Dictionary-Erstellung und
   -Gleichheit geben die folgenden Beispiele alle ein Dictionary
   zurück, das gleich "{"one": 1, "two": 2, "three": 3}" ist:

      >>> a = dict(one=1, two=2, three=3)
      >>> b = {'one': 1, 'two': 2, 'three': 3}
      >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
      >>> d = dict([('two', 2), ('one', 1), ('three', 3)])
      >>> e = dict({'three': 3, 'one': 1, 'two': 2})
      >>> f = dict({'one': 1, 'three': 3}, two=2)
      >>> a == b == c == d == e == f
      True

   Die Übergabe von Schlüsselwort-Argumenten wie im ersten Beispiel
   funktioniert nur für Schlüssel, die gültige Python-Bezeichner sind.
   Andernfalls können alle gültigen Schlüssel verwendet werden.

   Dictionaries behalten die Einfügereihenfolge bei. Beachte, dass das
   Aktualisieren eines Schlüssels die Reihenfolge nicht beeinflusst.
   Schlüssel, die nach dem Löschen hinzugefügt werden, werden am Ende
   eingefügt.

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(d)
      ['one', 'two', 'three', 'four']
      >>> list(d.values())
      [1, 2, 3, 4]
      >>> d["one"] = 42
      >>> d
      {'one': 42, 'two': 2, 'three': 3, 'four': 4}
      >>> del d["two"]
      >>> d["two"] = None
      >>> d
      {'one': 42, 'three': 3, 'four': 4, 'two': None}

   Geändert in Version 3.7: Die Dictionary-Reihenfolge ist garantiert
   die Einfügereihenfolge. Dieses Verhalten war ab 3.6 ein
   Implementierungsdetail von CPython.

   Dictionaries sind über zwei Typparameter generisch, was (jeweils)
   die Typen der Schlüssel und Werte des Dictionarys angeben.

   Dies sind die Operationen, die Dictionaries unterstützen (und die
   daher auch benutzerdefinierte Mapping-Typen unterstützen sollten):

   list(d)

      Gibt eine Liste aller im Dictionary *d* verwendeten Schlüssel
      zurück.

   len(d)

      Gibt die Anzahl der Elemente im Dictionary *d* zurück.

   d[key]

      Gibt das Element von *d* mit dem Schlüssel *key* zurück. Löst
      einen "KeyError" aus, wenn *key* nicht in der Map vorhanden ist.

      Wenn eine Unterklasse von dict eine Methode "__missing__()"
      definiert und *key* nicht vorhanden ist, ruft die Operation
      "d[key]" diese Methode mit dem Schlüssel *key* als Argument auf.
      Die Operation "d[key]" gibt dann zurück oder löst aus, was immer
      der Aufruf "__missing__(key)" zurückgibt oder auslöst. Keine
      anderen Operationen oder Methoden rufen "__missing__()" auf.
      Wenn "__missing__()" nicht definiert ist, wird ein "KeyError"
      ausgelöst. "__missing__()" muss eine Methode sein; es kann keine
      Instanzvariable sein:

         >>> class Counter(dict):
         ...     def __missing__(self, key):
         ...         return 0
         ...
         >>> c = Counter()
         >>> c['red']
         0
         >>> c['red'] += 1
         >>> c['red']
         1

      Das obige Beispiel zeigt einen Teil der Implementierung von
      "collections.Counter". Eine andere "__missing__()"-Methode wird
      von "collections.defaultdict" verwendet.

   d[key] = value

      Setzt "d[key]" auf *value*.

   del d[key]

      Entfernt "d[key]" aus *d*. Löst einen "KeyError" aus, wenn *key*
      nicht in der Map vorhanden ist.

   key in d

      Gibt "True" zurück, wenn *d* einen Schlüssel *key* besitzt,
      andernfalls "False".

   key not in d

      Äquivalent zu "not key in d".

   iter(d)

      Gibt einen Iterator über die Schlüssel des Dictionaries zurück.
      Dies ist eine Abkürzung für "iter(d.keys())".

   clear()

      Entfernt alle Elemente aus dem Dictionary.

   copy()

      Gibt eine flache Kopie des Dictionaries zurück.

   classmethod fromkeys(iterable, value=None, /)

      Erstellt ein neues Dictionary mit Schlüsseln aus *iterable* und
      auf *value* gesetzten Werten.

      "fromkeys()" ist eine Klassenmethode, die ein neues Dictionary
      zurückgibt. *value* ist standardmäßig "None". Alle Werte
      verweisen auf dieselbe Instanz, daher ist es im Allgemeinen
      nicht sinnvoll, wenn *value* ein veränderliches Objekt wie eine
      leere Liste ist. Um verschiedene Werte zu erhalten, verwende
      stattdessen eine Dict-Comprehension.

   get(key, default=None, /)

      Gibt den Wert für *key* zurück, wenn *key* im Dictionary
      vorhanden ist, andernfalls *default*. Wenn *default* nicht
      angegeben ist, ist der Standardwert "None", sodass diese Methode
      niemals einen "KeyError" auslöst.

   items()

      Gibt einen neuen View der Elemente des Dictionaries ("(key,
      value)"-Paare) zurück. Siehe die Dokumentation zu View-Objekten.

   keys()

      Gibt einen neuen View der Schlüssel des Dictionaries zurück.
      Siehe die Dokumentation zu View-Objekten.

   pop(key, /)
   pop(key, default, /)

      Wenn *key* im Dictionary vorhanden ist, entferne ihn und gib
      seinen Wert zurück, andernfalls gib *default* zurück. Wenn
      *default* nicht angegeben ist und *key* nicht im Dictionary
      vorhanden ist, wird ein "KeyError" ausgelöst.

   popitem()

      Entfernt ein "(key, value)"-Paar aus dem Dictionary und gibt es
      zurück. Paare werden in LIFO (last-in, first-out)-Reihenfolge
      zurückgegeben.

      "popitem()" ist nützlich, um destruktiv über ein Dictionary zu
      iterieren, wie es oft in Mengenalgorithmen verwendet wird. Wenn
      das Dictionary leer ist, löst der Aufruf von "popitem()" einen
      "KeyError" aus.

      Geändert in Version 3.7: Die LIFO-Reihenfolge ist nun
      garantiert. In früheren Versionen gab "popitem()" ein beliebiges
      Schlüssel/Wert-Paar zurück.

   reversed(d)

      Gibt einen umgekehrten Iterator über die Schlüssel des
      Dictionaries zurück. Dies ist eine Abkürzung für
      "reversed(d.keys())".

      Added in version 3.8.

   setdefault(key, default=None, /)

      Wenn *key* im Dictionary vorhanden ist, gib seinen Wert zurück.
      Wenn nicht, füge *key* mit einem Wert von *default* ein und gib
      *default* zurück. *default* ist standardmäßig "None".

   update(**kwargs)
   update(mapping, /, **kwargs)
   update(iterable, /, **kwargs)

      Aktualisiert das Dictionary mit den Schlüssel/Wert-Paaren aus
      *mapping* oder *iterable* und *kwargs*, wobei bestehende
      Schlüssel überschrieben werden. Gibt "None" zurück.

      "update()" akzeptiert entweder ein anderes Objekt mit einer
      "keys()"-Methode (in diesem Fall wird "__getitem__()" mit jedem
      von der Methode zurückgegebenen Schlüssel aufgerufen) oder ein
      Iterable von Schlüssel/Wert-Paaren (als Tupel oder andere
      Iterables der Länge zwei). Wenn Schlüsselwort-Argumente
      angegeben sind, wird das Dictionary mit diesen Schlüssel/Wert-
      Paaren aktualisiert: "d.update(red=1, blue=2)".

   values()

      Gibt einen neuen View der Werte des Dictionaries zurück. Siehe
      die Dokumentation zu View-Objekten.

      Ein Gleichheitsvergleich zwischen einem "dict.values()"-View und
      einem anderen gibt immer "False" zurück. Dies gilt auch für den
      Vergleich von "dict.values()" mit sich selbst:

         >>> d = {'a': 1}
         >>> d.values() == d.values()
         False

   d | other

      Erstellt ein neues Dictionary mit den zusammengeführten
      Schlüsseln und Werten von *d* und *other*, die beide
      Dictionaries sein müssen. Die Werte von *other* haben Vorrang,
      wenn *d* und *other* gemeinsame Schlüssel besitzen.

      Added in version 3.9.

   d |= other

      Aktualisiert das Dictionary *d* mit Schlüsseln und Werten aus
      *other*, was entweder ein *Mapping* oder ein *Iterierbares* von
      Schlüssel/Wert-Paaren sein kann. Die Werte von *other* haben
      Vorrang, wenn *d* und *other* gemeinsame Schlüssel besitzen.

      Added in version 3.9.

   Dictionaries und Dictionary-Views sind umkehrbar (reversible).

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(reversed(d))
      ['four', 'three', 'two', 'one']
      >>> list(reversed(d.values()))
      [4, 3, 2, 1]
      >>> list(reversed(d.items()))
      [('four', 4), ('three', 3), ('two', 2), ('one', 1)]

   Geändert in Version 3.8: Dictionaries sind nun umkehrbar.

Siehe auch:

  "types.MappingProxyType" kann verwendet werden, um einen
  schreibgeschützten View eines "dict" zu erstellen.


Dictionary-View-Objekte
-----------------------

Die von "dict.keys()", "dict.values()" und "dict.items()"
zurückgegebenen Objekte sind *View-Objekte*. Sie bieten einen
dynamischen View auf die Einträge des Dictionaries, was bedeutet, dass
der View Änderungen am Dictionary widerspiegelt.

Über Dictionary-Views kann iteriert werden, um ihre jeweiligen Daten
abzurufen, und sie unterstützen Mitgliedschaftstests:

len(dictview)

   Gibt die Anzahl der Einträge im Dictionary zurück.

iter(dictview)

   Gibt einen Iterator über die Schlüssel, Werte oder Elemente
   (dargestellt als Tupel von "(key, value)") im Dictionary zurück.

   Schlüssel und Werte werden in der Einfügereihenfolge durchlaufen.
   Dies ermöglicht die Erstellung von "(value, key)"-Paaren mittels
   "zip()": "pairs = zip(d.values(), d.keys())". Eine andere
   Möglichkeit, dieselbe Liste zu erstellen, ist "pairs = [(v, k) for
   (k, v) in d.items()]".

   Das Iterieren über Views, während Einträge im Dictionary
   hinzugefügt oder gelöscht werden, kann einen "RuntimeError"
   auslösen oder dazu führen, dass nicht alle Einträge durchlaufen
   werden.

   Geändert in Version 3.7: Die Dictionary-Reihenfolge ist garantiert
   die Einfügereihenfolge.

x in dictview

   Gibt "True" zurück, wenn *x* in den Schlüsseln, Werten oder
   Elementen des zugrunde liegenden Dictionaries enthalten ist (im
   letzteren Fall sollte *x* ein "(key, value)"-Tupel sein).

reversed(dictview)

   Gibt einen umgekehrten Iterator über die Schlüssel, Werte oder
   Elemente des Dictionaries zurück. Der View wird in umgekehrter
   Reihenfolge der Einfügung durchlaufen.

   Geändert in Version 3.8: Dictionary-Views sind nun umkehrbar.

dictview.mapping

   Gibt einen "types.MappingProxyType" zurück, der das ursprüngliche
   Dictionary umhüllt, auf das sich der View bezieht.

   Added in version 3.10.

Keys-Views sind mengenartig, da ihre Einträge eindeutig und *hashbar*
sind. Items-Views besitzen ebenfalls mengenartige Operationen, da die
(key, value)-Paare eindeutig sind und die Schlüssel hashbar sind. Wenn
alle Werte in einem Items-View ebenfalls hashbar sind, kann der Items-
View mit anderen Mengen interagieren. (Values-Views werden nicht als
mengenartig behandelt, da die Einträge im Allgemeinen nicht eindeutig
sind.) Für mengenartige Views sind alle Operationen verfügbar, die für
die abstrakte Basisklasse "collections.abc.Set" definiert sind (zum
Beispiel "==", "<" oder "^"). Bei der Verwendung von Mengenoperatoren
akzeptieren mengenartige Views jedes Iterable als weiteren Operanden,
im Gegensatz zu Mengen, die nur Mengen als Eingabe akzeptieren.

Ein Beispiel für die Verwendung von Dictionary-Views:

   >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
   >>> keys = dishes.keys()
   >>> values = dishes.values()

   >>> # iteration
   >>> n = 0
   >>> for val in values:
   ...     n += val
   ...
   >>> print(n)
   504

   >>> # keys and values are iterated over in the same order (insertion order)
   >>> list(keys)
   ['eggs', 'sausage', 'bacon', 'spam']
   >>> list(values)
   [2, 1, 1, 500]

   >>> # view objects are dynamic and reflect dict changes
   >>> del dishes['eggs']
   >>> del dishes['sausage']
   >>> list(keys)
   ['bacon', 'spam']

   >>> # set operations
   >>> keys & {'eggs', 'bacon', 'salad'}
   {'bacon'}
   >>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
   True
   >>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
   True

   >>> # get back a read-only proxy for the original dictionary
   >>> values.mapping
   mappingproxy({'bacon': 1, 'spam': 500})
   >>> values.mapping['spam']
   500


Kontext-Manager-Typen
=====================

Pythons "with"-Anweisung unterstützt das Konzept eines
Laufzeitkontexts, der durch einen Kontext-Manager definiert wird. Dies
wird mittels eines Methodenpaars implementiert, das es
benutzerdefinierten Klassen ermöglicht, einen Laufzeitkontext zu
definieren, der vor der Ausführung des Anweisungskörpers betreten und
beim Beenden der Anweisung verlassen wird:

contextmanager.__enter__()

   Betritt den Laufzeitkontext und gibt entweder dieses Objekt oder
   ein anderes, auf den Laufzeitkontext bezogenes Objekt zurück. Der
   von dieser Methode zurückgegebene Wert wird an den Bezeichner in
   der "as"-Klausel von "with"-Anweisungen gebunden, die diesen
   Kontext-Manager verwenden.

   Ein Beispiel für einen Kontext-Manager, der sich selbst zurückgibt,
   ist ein *Dateiobjekt*. Dateiobjekte geben sich selbst aus
   __enter__() zurück, damit "open()" als Kontextausdruck in einer
   "with"-Anweisung verwendet werden kann.

   Ein Beispiel für einen Kontext-Manager, der ein zugehöriges Objekt
   zurückgibt, ist der von "decimal.localcontext()" zurückgegebene.
   Diese Manager setzen den aktiven Dezimalkontext auf eine Kopie des
   ursprünglichen Dezimalkontexts und geben dann die Kopie zurück.
   Dies ermöglicht Änderungen am aktuellen Dezimalkontext im Körper
   der "with"-Anweisung, ohne Code außerhalb der "with"-Anweisung zu
   beeinflussen.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

   Verlässt den Laufzeitkontext und gibt ein boolesches Flag zurück,
   das angibt, ob eine aufgetretene Ausnahme unterdrückt werden soll.
   Wenn während der Ausführung des Körpers der "with"-Anweisung eine
   Ausnahme aufgetreten ist, enthalten die Argumente den Ausnahmetyp,
   den Wert und Traceback-Informationen. Andernfalls sind alle drei
   Argumente "None".

   Die Rückgabe eines wahren Wertes aus dieser Methode bewirkt, dass
   die "with"-Anweisung die Ausnahme unterdrückt und die Ausführung
   mit der Anweisung unmittelbar nach der "with"-Anweisung fortsetzt.
   Andernfalls wird die Ausnahme nach Beendigung dieser Methode weiter
   propagiert.

   Wenn diese Methode während der Behandlung einer früheren Ausnahme
   aus dem "with"-Block eine Ausnahme auslöst, wird die neue Ausnahme
   weitergegeben, und die ursprüngliche Ausnahme wird in ihrem
   Attribut "__context__" gespeichert.

   Die übergebene Ausnahme sollte niemals explizit erneut ausgelöst
   werden – stattdessen sollte diese Methode einen falschen Wert
   zurückgeben, um anzuzeigen, dass die Methode erfolgreich
   abgeschlossen wurde und die ausgelöste Ausnahme nicht unterdrücken
   möchte. Dies ermöglicht es dem Kontextmanagement-Code, leicht zu
   erkennen, ob eine "__exit__()"-Methode tatsächlich fehlgeschlagen
   ist oder nicht.

Python definiert mehrere Kontext-Manager, um eine einfache Thread-
Synchronisation, das zeitnahe Schließen von Dateien oder anderen
Objekten und eine einfachere Manipulation des aktiven
Dezimalarithmetik-Kontexts zu unterstützen. Die spezifischen Typen
werden über ihre Implementierung des Kontextmanagement-Protokolls
hinaus nicht besonders behandelt. Siehe das Modul "contextlib" für
einige Beispiele.

Pythons *Generatoren* und der Dekorator "contextlib.contextmanager"
bieten eine bequeme Möglichkeit, diese Protokolle zu implementieren.
Wenn eine Generatorfunktion mit dem Dekorator
"contextlib.contextmanager" dekoriert ist, gibt sie einen Kontext-
Manager zurück, der die notwendigen Methoden "__enter__()" und
"__exit__()" implementiert, anstelle des Iterators, der von einer
undekorierten Generatorfunktion erzeugt wird.

Beachte, dass es in der Typstruktur für Python-Objekte in der
Python/C-API keinen speziellen Slot für eine dieser Methoden gibt.
Erweiterungstypen, die diese Methoden definieren möchten, müssen sie
als normale, über Python zugängliche Methode bereitstellen. Im
Vergleich zum Overhead beim Einrichten des Laufzeitkontexts ist der
Overhead eines einzelnen Class-Dictionary-Lookups zu vernachlässigen.


Typ-Annotations-Typen – Generic Alias, Union
============================================

Die zentralen eingebauten Typen für *Typ-Annotationen* sind Generic
Alias und Union.


Generic-Alias-Typ
-----------------

"GenericAlias"-Objekte werden im Allgemeinen durch Subskription einer
Klasse erstellt. Sie werden am häufigsten mit Container-Klassen wie
"list" oder "dict" verwendet. Beispielsweise ist "list[int]" ein
"GenericAlias"-Objekt, das durch Subskription der Klasse "list" mit
dem Argument "int" erstellt wird. "GenericAlias"-Objekte sind in
erster Linie für die Verwendung mit *Typ-Annotationen* vorgesehen.

Bemerkung:

  Das Subskribieren einer Klasse ist im Allgemeinen nur möglich, wenn
  die Klasse die spezielle Methode "__class_getitem__()"
  implementiert.

Ein "GenericAlias"-Objekt fungiert als Proxy für einen *generischen
Typ* und implementiert *parametrisierte Generics*.

Bei einer Container-Klasse können die Argumente, die einer
Subskription der Klasse übergeben werden, den bzw. die Typ(en) der
Elemente angeben, die ein Objekt enthält. Beispielsweise kann
"set[bytes]" in Typ-Annotationen verwendet werden, um ein "set" zu
kennzeichnen, in dem alle Elemente vom Typ "bytes" sind.

Bei einer Klasse, die "__class_getitem__()" definiert, aber kein
Container ist, geben die Argumente einer Subskription der Klasse
häufig den bzw. die Rückgabetyp(en) einer oder mehrerer für ein Objekt
definierter Methoden an. Beispielsweise können "reguläre Ausdrücke"
sowohl auf den Datentyp "str" als auch auf den Datentyp "bytes"
angewendet werden:

* Wenn "x = re.search('foo', 'foo')" ist, ist "x" ein re.Match-Objekt,
  bei dem die Rückgabewerte von "x.group(0)" und "x[0]" beide vom Typ
  "str" sind. Wir können diese Art von Objekt in Typ-Annotationen mit
  dem "GenericAlias" "re.Match[str]" darstellen.

* Wenn "y = re.search(b'bar', b'bar')" ist (beachte das "b" für
  "bytes"), ist "y" ebenfalls eine Instanz von "re.Match", die
  Rückgabewerte von "y.group(0)" und "y[0]" sind jedoch beide vom Typ
  "bytes". In Typ-Annotationen würden wir diese Variante von re.Match-
  Objekten mit "re.Match[bytes]" darstellen.

"GenericAlias"-Objekte sind Instanzen der Klasse "types.GenericAlias",
mit der "GenericAlias"-Objekte auch direkt erstellt werden können.
Spezialisierungen benutzerdefinierter generischer Klassen sind
möglicherweise keine Instanzen von "types.GenericAlias", bieten aber
ähnliche Funktionalität.

T[X, Y, ...]

   Erstellt ein "GenericAlias", das einen Typ "T" darstellt, der durch
   die Typen *X*, *Y* und weitere (je nach verwendetem "T")
   parametrisiert ist. Beispielsweise eine Funktion, die eine "list"
   mit "float"-Elementen erwartet:

      def average(values: list[float]) -> float:
          return sum(values) / len(values)

   Ein weiteres Beispiel für *Mapping*-Objekte unter Verwendung eines
   "dict", welches ein generischer Typ ist, der zwei Typparameter für
   den Schlüsseltyp und den Werttyp erwartet. In diesem Beispiel
   erwartet die Funktion ein "dict" mit Schlüsseln vom Typ "str" und
   Werten vom Typ "int":

      def send_post_request(url: str, body: dict[str, int]) -> None:
          ...

Die eingebauten Funktionen "isinstance()" und "issubclass()"
akzeptieren keine "GenericAlias"-Typen als zweites Argument:

   >>> isinstance([1, 2], list[str])
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: isinstance() argument 2 cannot be a parameterized generic

Die Python-Laufzeitumgebung erzwingt keine *Typ-Annotationen*. Dies
erstreckt sich auch auf generische Typen und deren Typparameter. Beim
Erstellen eines Container-Objekts aus einem "GenericAlias" werden die
Elemente im Container nicht auf ihren Typ überprüft. Der folgende Code
wird beispielsweise nicht empfohlen, läuft aber fehlerfrei durch:

   >>> t = list[str]
   >>> t([1, 2, 3])
   [1, 2, 3]

Darüber hinaus löschen parametrisierte Generics Typparameter während
der Objekterstellung (Type Erasure):

   >>> t = list[str]
   >>> type(t)
   <class 'types.GenericAlias'>

   >>> l = t()
   >>> type(l)
   <class 'list'>

Instanzen von "GenericAlias" sind zur Laufzeit keine Klassen, auch
wenn sie sich wie Klassen verhalten (sie können instanziiert und
abgeleitet werden):

   >>> import inspect
   >>> inspect.isclass(list[int])
   False

Dies gilt auch für benutzerdefinierte Generics.

Der Aufruf von "repr()" oder "str()" auf einem Generic zeigt den
parametrisierten Typ:

   >>> repr(list[int])
   'list[int]'

   >>> str(list[int])
   'list[int]'

Die Methode "__getitem__()" generischer Container löst eine Ausnahme
aus, um Fehler wie "dict[str][str]" zu verhindern:

   >>> dict[str][str]
   Traceback (most recent call last):
     ...
   TypeError: dict[str] is not a generic class

Solche Ausdrücke sind jedoch gültig, wenn Typvariablen verwendet
werden. Der Index muss so viele Elemente haben, wie es Typvariablen-
Einträge in "__args__" des "GenericAlias"-Objekts gibt.

   >>> from typing import TypeVar
   >>> Y = TypeVar('Y')
   >>> dict[str, Y][int]
   dict[str, int]


Standard-Generische Klassen
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Die folgenden Klassen der Standardbibliothek unterstützen
parametrisierte Generics. Diese Liste ist nicht vollständig.

* "tuple"

* "list"

* "dict"

* "set"

* "frozenset"

* "type"

* "asyncio.Future"

* "asyncio.Task"

* "collections.deque"

* "collections.defaultdict"

* "collections.OrderedDict"

* "collections.Counter"

* "collections.ChainMap"

* "collections.abc.Awaitable"

* "collections.abc.Coroutine"

* "collections.abc.AsyncIterable"

* "collections.abc.AsyncIterator"

* "collections.abc.AsyncGenerator"

* "collections.abc.Iterable"

* "collections.abc.Iterator"

* "collections.abc.Generator"

* "collections.abc.Reversible"

* "collections.abc.Container"

* "collections.abc.Collection"

* "collections.abc.Callable"

* "collections.abc.Set"

* "collections.abc.MutableSet"

* "collections.abc.Mapping"

* "collections.abc.MutableMapping"

* "collections.abc.Sequence"

* "collections.abc.MutableSequence"

* "collections.abc.ByteString"

* "collections.abc.MappingView"

* "collections.abc.KeysView"

* "collections.abc.ItemsView"

* "collections.abc.ValuesView"

* "contextlib.AbstractContextManager"

* "contextlib.AbstractAsyncContextManager"

* "dataclasses.Field"

* "functools.cached_property"

* "functools.partialmethod"

* "os.PathLike"

* "queue.LifoQueue"

* "queue.Queue"

* "queue.PriorityQueue"

* "queue.SimpleQueue"

* re.Pattern

* re.Match

* "shelve.BsdDbShelf"

* "shelve.DbfilenameShelf"

* "shelve.Shelf"

* "types.MappingProxyType"

* "weakref.WeakKeyDictionary"

* "weakref.WeakMethod"

* "weakref.WeakSet"

* "weakref.WeakValueDictionary"


Spezielle Attribute von "GenericAlias"-Objekten
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Alle parametrisierten Generics implementieren spezielle
schreibgeschützte Attribute.

genericalias.__origin__

   Dieses Attribut verweist auf die nicht-parametrisierte generische
   Klasse:

      >>> list[int].__origin__
      <class 'list'>

genericalias.__args__

   Dieses Attribut ist ein "tuple" (möglicherweise der Länge 1) von
   generischen Typen, die an das ursprüngliche "__class_getitem__()"
   der generischen Klasse übergeben wurden:

      >>> dict[str, list[int]].__args__
      (<class 'str'>, list[int])

genericalias.__parameters__

   Dieses Attribut ist ein verzögert ausgewertetes (möglicherweise
   leeres) Tupel von eindeutigen Typvariablen, die in "__args__"
   gefunden wurden:

      >>> from typing import TypeVar

      >>> T = TypeVar('T')
      >>> list[T].__parameters__
      (~T,)

   Bemerkung:

     Ein "GenericAlias"-Objekt mit "typing.ParamSpec"-Parametern hat
     nach der Ersetzung möglicherweise keine korrekten
     "__parameters__", da "typing.ParamSpec" in erster Linie für die
     statische Typprüfung gedacht ist.

genericalias.__unpacked__

   Ein boolescher Wert, der wahr ist, wenn das Alias mit dem Operator
   "*" entpackt wurde (siehe "TypeVarTuple").

   Added in version 3.11.

Siehe auch:

  **PEP 484** - Type Hints
     Einführung von Pythons Framework für Typ-Annotationen.

  **PEP 585** - Type Hinting Generics In Standard Collections
     Einführung der Möglichkeit zur nativen Parametrisierung von
     Standardbibliotheksklassen, sofern sie die spezielle
     Klassenmethode "__class_getitem__()" implementieren.

  Generics, benutzerdefinierte Generics und "typing.Generic"
     Dokumentation zur Implementierung generischer Klassen, die zur
     Laufzeit parametrisiert und von statischen Typprüfern verstanden
     werden können.

Added in version 3.9.


Union-Typ
---------

A union object holds the value of the "|" (bitwise or) operation on
multiple type objects.  These types are intended primarily for *type
annotations*. The union type expression enables cleaner type hinting
syntax compared to "typing.Union".

X | Y | ...

   Definiert ein Union-Objekt, das die Typen *X*, *Y* usw. enthält. "X
   | Y" bedeutet entweder X oder Y. Es ist äquivalent zu
   "typing.Union[X, Y]". Zum Beispiel erwartet die folgende Funktion
   ein Argument vom Typ "int" oder "float":

      def square(number: int | float) -> int | float:
          return number ** 2

   Bemerkung:

     Der Operator "|" kann zur Laufzeit nicht verwendet werden, um
     Unions zu definieren, bei denen ein oder mehrere Elemente
     Vorwärtsreferenzen (Forward References) sind. Beispielsweise
     schlägt "int | "Foo"" zur Laufzeit fehl, wenn ""Foo"" eine
     Referenz auf eine noch nicht definierte Klasse ist. Für Unions,
     die Vorwärtsreferenzen enthalten, sollte der gesamte Ausdruck als
     String angegeben werden, z. B. ""int | Foo"".

union_object == other

   Union-Objekte können mit anderen Union-Objekten auf Gleichheit
   getestet werden. Details:

   * Unions von Unions werden verflacht:

        (int | str) | float == int | str | float

   * Redundante Typen werden entfernt:

        int | str | int == int | str

   * Beim Vergleich von Unions wird die Reihenfolge ignoriert:

        int | str == str | int

   * It is compatible with "typing.Union":

        int | str == typing.Union[int, str]

   * Optionale Typen können als Union mit "None" geschrieben werden:

        str | None == typing.Optional[str]

isinstance(obj, union_object)

issubclass(obj, union_object)

   Aufrufe von "isinstance()" und "issubclass()" werden ebenfalls mit
   einem Union-Objekt unterstützt:

      >>> isinstance("", int | str)
      True

   Parametrisierte Generics in Union-Objekten können jedoch nicht
   geprüft werden:

      >>> isinstance(1, int | list[int])  # short-circuit evaluation
      True
      >>> isinstance([1], int | list[int])
      Traceback (most recent call last):
        ...
      TypeError: isinstance() argument 2 cannot be a parameterized generic

The user-exposed type for the union object can be accessed from
"types.UnionType" and used for "isinstance()" checks.  An object
cannot be instantiated from the type:

   >>> import types
   >>> isinstance(int | str, types.UnionType)
   True
   >>> types.UnionType()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: cannot create 'types.UnionType' instances

Bemerkung:

  Die Methode "__or__()" für Typobjekte wurde hinzugefügt, um die
  Syntax "X | Y" zu unterstützen. Wenn eine Metaklasse "__or__()"
  implementiert, kann die Union diese überschreiben:

     >>> class M(type):
     ...     def __or__(self, other):
     ...         return "Hello"
     ...
     >>> class C(metaclass=M):
     ...     pass
     ...
     >>> C | int
     'Hello'
     >>> int | C
     int | C

Siehe auch:

  **PEP 604** -- PEP zum Vorschlag der Syntax "X | Y" und des Union-
  Typs.

Added in version 3.10.


Andere eingebaute Typen
=======================

Der Interpreter unterstützt mehrere andere Arten von Objekten. Die
meisten von ihnen unterstützen nur eine oder zwei Operationen.


Module
------

Die einzige spezielle Operation auf einem Modul ist der
Attributzugriff: "m.name", wobei *m* ein Modul ist und *name* auf
einen in *m*s Symboltabelle definierten Namen zugreift.
Modulattributen können Werte zugewiesen werden. (Beachte, dass die
Anweisung :keyword:`import` genau genommen keine Operation auf einem
Modulobjekt ist; ``import foo`` erfordert nicht, dass ein Modulobjekt
namens *foo* existiert, sondern eine (externe) *Definition* für ein
Modul namens *foo* irgendwo vorhanden ist.)

Ein spezielles Attribut jedes Moduls ist "__dict__". Dies ist das
Dictionary, das die Symboltabelle des Moduls enthält. Das Ändern
dieses Dictionaries verändert tatsächlich die Symboltabelle des
Moduls, eine direkte Zuweisung an das Attribut "__dict__" ist jedoch
nicht möglich (man kann "m.__dict__['a'] = 1" schreiben, was "m.a" als
"1" definiert, aber nicht "m.__dict__ = {}"). Die direkte Modifikation
von "__dict__" wird nicht empfohlen.

In den Interpreter eingebaute Module werden so geschrieben: "<module
'sys' (built-in)>". Wenn sie aus einer Datei geladen werden, werden
sie als "<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>"
geschrieben.


Klassen und Klasseninstanzen
----------------------------

Siehe Objekte, Werte und Typen und Klassendefinitionen für diese.


Funktionen
----------

Funktionsobjekte werden durch Funktionsdefinitionen erstellt. Die
einzige Operation auf einem Funktionsobjekt ist dessen Aufruf: "func
(argument-list)".

Es gibt im Wesentlichen zwei Arten von Funktionsobjekten: eingebaute
Funktionen und benutzerdefinierte Funktionen. Beide unterstützen
dieselbe Operation (den Funktionsaufruf), die Implementierung ist
jedoch unterschiedlich, daher die verschiedenen Objekttypen.

Siehe Funktionsdefinitionen für weitere Informationen.


Methoden
--------

Methoden sind Funktionen, die mittels Attributnotation aufgerufen
werden. Es gibt zwei Arten: eingebaute Methoden (wie "append()" bei
Listen) und Klasseninstanzmethoden. Eingebaute Methoden werden bei den
Typen beschrieben, die sie unterstützen.

Wenn man über eine Instanz auf eine Methode (eine im Namensraum einer
Klasse definierte Funktion) zugreift, erhält man ein spezielles
Objekt: ein *gebundene Methode <bound method>*-Objekt (auch
Instanzmethode genannt). Beim Aufruf fügt es das "self"-Argument zur
Argumentliste hinzu. Gebundene Methoden besitzen zwei spezielle
schreibgeschützte Attribute: "m.__self__" ist das Objekt, auf dem die
Methode operiert, und "m.__func__" ist die Funktion, die die Methode
implementiert. Der Aufruf von "m(arg-1, arg-2, ..., arg-n)" ist
vollkommen äquivalent zum Aufruf von "m.__func__(m.__self__, arg-1,
arg-2, ..., arg-n)".

Wie Funktionsobjekte unterstützen gebundene Methodenobjekte das
Abrufen beliebiger Attribute. Da Methodenattribute jedoch tatsächlich
auf dem zugrunde liegenden Funktionsobjekt ("method.__func__")
gespeichert sind, ist das Setzen von Methodenattributen auf gebundenen
Methoden nicht zulässig. Der Versuch, ein Attribut auf einer Methode
zu setzen, führt dazu, dass ein "AttributeError" ausgelöst wird. Um
ein Methodenattribut zu setzen, muss es explizit auf dem zugrunde
liegenden Funktionsobjekt gesetzt werden:

   >>> class C:
   ...     def method(self):
   ...         pass
   ...
   >>> c = C()
   >>> c.method.whoami = 'my name is method'  # can't set on the method
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   AttributeError: 'method' object has no attribute 'whoami'
   >>> c.method.__func__.whoami = 'my name is method'
   >>> c.method.whoami
   'my name is method'

Siehe Instanzmethoden für weitere Informationen.


Code-Objekte
------------

Code-Objekte werden von der Implementierung verwendet, um "pseudo-
kompilierten" ausführbaren Python-Code wie beispielsweise einen
Funktionskörper darzustellen. Sie unterscheiden sich von
Funktionsobjekten dadurch, dass sie keine Referenz auf ihre globale
Ausführungsumgebung enthalten. Code-Objekte werden von der eingebauten
Funktion "compile()" zurückgegeben und können über ihr Attribut
"__code__" aus Funktionsobjekten extrahiert werden. Siehe auch das
Modul "code".

Der Zugriff auf "__code__" löst ein Auditing-Event
"object.__getattr__" mit den Argumenten "obj" und ""__code__"" aus.

Ein Code-Objekt kann ausgeführt oder ausgewertet werden, indem es
(anstelle eines Quell-Strings) an die eingebauten Funktionen "exec()"
oder "eval()" übergeben wird.

Siehe Die Standardtyp-Hierarchie für weitere Informationen.


Typ-Objekte
-----------

Typ-Objekte stellen die verschiedenen Objekttypen dar. Auf den Typ
eines Objekts wird über die eingebaute Funktion "type()" zugegriffen.
Es gibt keine speziellen Operationen auf Typen. Das Standardmodul
"types" definiert Namen für alle standardmäßigen eingebauten Typen.

Typen werden so geschrieben: "<class 'int'>".


Das Null-Objekt
---------------

Dieses Objekt wird von Funktionen zurückgegeben, die nicht explizit
einen Wert zurückgeben. Es unterstützt keine speziellen Operationen.
Es gibt genau ein Null-Objekt namens "None" (ein eingebauter Name).
"type(None)()" erzeugt dasselbe Singleton.

Es wird als "None" geschrieben.


Das Ellipsis-Objekt
-------------------

Dieses Objekt wird üblicherweise verwendet, um anzuzeigen, dass etwas
ausgelassen wurde. Es unterstützt keine speziellen Operationen. Es
gibt genau ein Ellipsis-Objekt namens "Ellipsis" (ein eingebauter
Name). "type(Ellipsis)()" erzeugt das Singleton "Ellipsis".

Es wird als "Ellipsis" oder "..." geschrieben.

In typischer Verwendung erscheint "..." als das "Ellipsis"-Objekt an
einigen verschiedenen Stellen, zum Beispiel:

* In Typ-Annotationen, wie z. B. Callable-Argumente oder Tupel-
  Elemente.

* Als Körper einer Funktion anstelle einer pass-Anweisung.

* In Drittanbieter-Bibliotheken, wie etwa Numpys Slicing and Striding.

Python verwendet drei Punkte auch auf Weisen, die keine
"Ellipsis"-Objekte sind, zum Beispiel:

* Doctests "ELLIPSIS", als Muster für fehlenden Inhalt.

* Der Standard-Python-Prompt der *interaktiven* Shell, wenn eine
  unvollständige Eingabe vorliegt.

Schließlich verwendet die Python-Dokumentation drei Punkte oft im
Sinne des herkömmlichen Sprachgebrauchs, um ausgelassenen Inhalt zu
kennzeichnen, selbst in Codebeispielen, die sie auch als "Ellipsis"
verwenden.


Das NotImplemented-Objekt
-------------------------

Dieses Objekt wird bei Vergleichen und binären Operationen
zurückgegeben, wenn sie auf Typen angewendet werden sollen, die sie
nicht unterstützen. Siehe Vergleiche für weitere Informationen. Es
gibt genau ein "NotImplemented"-Objekt. "type(NotImplemented)()"
erzeugt die Singleton-Instanz.

Es wird als "NotImplemented" geschrieben.


Interne Objekte
---------------

Siehe Die Standardtyp-Hierarchie für diese Informationen. Dort werden
Stack-Frame-Objekte, Traceback-Objekte und Slice-Objekte beschrieben.


Spezielle Attribute
===================

Die Implementierung fügt einigen Objekttypen einige spezielle
schreibgeschützte Attribute hinzu, wo sie relevant sind. Einige davon
werden von der eingebauten Funktion "dir()" nicht gemeldet.

definition.__name__

   Der Name der Klasse, Funktion, Methode, des Deskriptors oder der
   Generatorinstanz.

definition.__qualname__

   Der *voll qualifizierte Name* der Klasse, Funktion, Methode, des
   Deskriptors oder der Generatorinstanz.

   Added in version 3.3.

definition.__module__

   Der Name des Moduls, in dem eine Klasse oder Funktion definiert
   wurde.

definition.__doc__

   Der Dokumentations-String (Docstring) einer Klasse oder Funktion
   oder "None", falls nicht definiert.

definition.__type_params__

   Die Typparameter generischer Klassen, Funktionen und Typaliase. Für
   Klassen und Funktionen, die nicht generisch sind, ist dies ein
   leeres Tupel.

   Added in version 3.12.


Längenbeschränkung bei der Ganzzahl-String-Konvertierung
========================================================

CPython besitzt ein globales Limit für die Konvertierung zwischen
"int" und "str", um Denial-of-Service-Angriffe abzumildern. Dieses
Limit gilt *nur* für dezimale oder andere Zahlenbasen, die keine
Zweierpotenz sind. Hexadezimale, oktale und binäre Konvertierungen
sind unbegrenzt. Das Limit kann konfiguriert werden.

Der Typ "int" in CPython ist eine Zahl beliebiger Länge, die in
binärer Form gespeichert wird (allgemein bekannt als "Bignum"). Es
gibt keinen Algorithmus, der einen String in linearer Zeit in eine
binäre Ganzzahl oder eine binäre Ganzzahl in einen String umwandeln
kann, *es sei denn*, die Basis ist eine Zweierpotenz. Selbst die
bekanntesten Algorithmen für Basis 10 weisen eine sub-quadratische
Komplexität auf. Die Konvertierung eines großen Werts wie "int('1' *
500_000)" kann auf einer schnellen CPU über eine Sekunde dauern.

Die Begrenzung der Konvertierungsgröße bietet eine praktische
Möglichkeit, **CVE 2020-10735** zu vermeiden.

Das Limit wird auf die Anzahl der Ziffernzeichen im Eingabe- oder
Ausgabe-String angewendet, wenn ein nicht-linearer
Konvertierungsalgorithmus beteiligt wäre. Unterstriche und das
Vorzeichen zählen nicht zum Limit.

Wenn eine Operation das Limit überschreiten würde, wird ein
"ValueError" ausgelöst:

   >>> import sys
   >>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
   >>> _ = int('2' * 5432)
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit
   >>> i = int('2' * 4300)
   >>> len(str(i))
   4300
   >>> i_squared = i*i
   >>> len(str(i_squared))
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
   >>> len(hex(i_squared))
   7144
   >>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

Das Standardlimit beträgt 4300 Ziffern, wie in
"sys.int_info.default_max_str_digits" angegeben. Das niedrigste Limit,
das konfiguriert werden kann, beträgt 640 Ziffern, wie in
"sys.int_info.str_digits_check_threshold" angegeben.

Verifizierung:

   >>> import sys
   >>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
   >>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
   >>> msg = int('578966293710682886880994035146873798396722250538762761564'
   ...           '9252925514383915483333812743580549779436104706260696366600'
   ...           '571186405732').to_bytes(53, 'big')
   ...

Added in version 3.11.


Betroffene APIs
---------------

Die Einschränkung gilt nur für potenziell langsame Konvertierungen
zwischen "int" und "str" oder "bytes":

* "int(string)" mit der Standardbasis 10.

* "int(string, base)" für alle Basen, die keine Zweierpotenz sind.

* "str(integer)".

* "repr(integer)".

* jede andere String-Konvertierung zur Basis 10, zum Beispiel
  "f"{integer}"", ""{}".format(integer)" oder "b"%d" % integer".

Die Einschränkungen gelten nicht für Funktionen mit einem linearen
Algorithmus:

* "int(string, base)" mit Basis 2, 4, 8, 16 oder 32.

* "int.from_bytes()" und "int.to_bytes()".

* "hex()", "oct()", "bin()".

* Formatspezifikation Mini-Sprache für Hexadezimal-, Oktal- und
  Binärzahlen.

* "str" zu "float".

* "str" zu "decimal.Decimal".


Konfigurieren des Limits
------------------------

Vor dem Start von Python kann eine Umgebungsvariable oder ein
Kommandozeilen-Flag des Interpreters verwendet werden, um das Limit zu
konfigurieren:

* "PYTHONINTMAXSTRDIGITS", z. B. "PYTHONINTMAXSTRDIGITS=640 python3",
  um das Limit auf 640 zu setzen, oder "PYTHONINTMAXSTRDIGITS=0
  python3", um die Beschränkung zu deaktivieren.

* "-X int_max_str_digits", z. B. "python3 -X int_max_str_digits=640"

* "sys.flags.int_max_str_digits" enthält den Wert von
  "PYTHONINTMAXSTRDIGITS" oder "-X int_max_str_digits". Wenn sowohl
  die Umgebungsvariable als auch die Option "-X" gesetzt sind, hat die
  Option "-X" Vorrang. Ein Wert von *-1* zeigt an, dass beide nicht
  gesetzt waren, weshalb bei der Initialisierung ein Wert von
  "sys.int_info.default_max_str_digits" verwendet wurde.

Aus dem Code heraus kann das aktuelle Limit eingesehen und über diese
"sys"-APIs ein neues festgelegt werden:

* "sys.get_int_max_str_digits()" und "sys.set_int_max_str_digits()"
  sind Getter und Setter für das interpreterweite Limit. Sub-
  Interpreter haben ihr eigenes Limit.

Informationen über den Standardwert und das Minimum finden sich in
"sys.int_info":

* "sys.int_info.default_max_str_digits" ist das einkompilierte
  Standardlimit.

* "sys.int_info.str_digits_check_threshold" ist der niedrigste
  akzeptierte Wert für das Limit (außer 0, was es deaktiviert).

Added in version 3.11.

Vorsicht:

  Das Festlegen eines niedrigen Limits *kann* zu Problemen führen.
  Wenn auch selten, existiert Code, der in seinem Quelltext dezimale
  Ganzzahlkonstanten enthält, die den Mindestschwellenwert
  überschreiten. Eine Folge des Festlegens des Limits ist, dass
  Python-Quellcode, der dezimale Ganzzahlliterale enthält, die länger
  als das Limit sind, beim Parsen auf einen Fehler stößt – meist beim
  Start, beim Importieren oder sogar bei der Installation, wann immer
  noch keine aktuelle ".pyc"-Datei für den Code existiert. Ein
  Workaround für Quellcode, der solch große Konstanten enthält,
  besteht darin, sie in die hexadezimale "0x"-Form umzuwandeln, da
  diese kein Limit besitzt.Teste deine Anwendung gründlich, wenn du
  ein niedriges Limit verwendest. Stelle sicher, dass Tests mit
  frühzeitig über die Umgebung oder das Flag gesetztem Limit
  ausgeführt werden, sodass es beim Start und sogar bei jedem
  Installationsschritt greift, der Python aufrufen könnte, um
  ".py"-Quellen in ".pyc"-Dateien vorzukompilieren.


Empfohlene Konfiguration
------------------------

Das Standardlimit "sys.int_info.default_max_str_digits" ist für die
meisten Anwendungen voraussichtlich angemessen. Wenn deine Anwendung
ein anderes Limit erfordert, setze es vom Haupteinstiegspunkt aus mit
Python-versionsunabhängigem Code, da diese APIs in Versionen vor 3.12
in Sicherheits-Patch-Releases hinzugefügt wurden.

Beispiel:

   >>> import sys
   >>> if hasattr(sys, "set_int_max_str_digits"):
   ...     upper_bound = 68000
   ...     lower_bound = 4004
   ...     current_limit = sys.get_int_max_str_digits()
   ...     if current_limit == 0 or current_limit > upper_bound:
   ...         sys.set_int_max_str_digits(upper_bound)
   ...     elif current_limit < lower_bound:
   ...         sys.set_int_max_str_digits(lower_bound)

Wenn es vollständig deaktiviert werden soll, setze es auf "0".

-[ Fußnoten ]-

[1] Zusätzliche Informationen zu diesen speziellen Methoden finden
    sich im Python-Referenzhandbuch (Grundlegende Anpassungen).

[2] Folglich gilt die Liste "[1, 2]" als gleich zu "[1.0, 2.0]", und
    Entsprechendes gilt für Tupel.

[3] Sie müssen dieselbe Priorität haben, da der Parser den Typ der
    Operanden nicht unterscheiden kann.

[4] Zeichen mit Groß-/Kleinschreibung sind solche, deren allgemeine
    Kategorie-Eigenschaft "Lu" (Letter, uppercase), "Ll" (Letter,
    lowercase) oder "Lt" (Letter, titlecase) ist.

[5] Um ausschließlich ein Tupel zu formatieren, sollte man daher ein
    Singleton-Tupel bereitstellen, dessen einziges Element das zu
    formatierende Tupel ist.
