Eingebettete Datentypen

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

Die wichtigsten eingebauten Typen sind numerische Typen, Sequenzen, Abbildungen, Klassen, Instanzen und Ausnahmen.

Einige Sammlungsdatentypen sind veränderlich. Die Methoden, die ihre Elemente hinzufügen, subtrahieren oder neu anordnen, ohne einen bestimmten Wert zurückzugeben, geben niemals die Sammlung selbst, sondern None zurück.

Einige Operationen werden von mehreren Objekttypen unterstützt; insbesondere können praktisch alle Objekte auf Gleichheit verglichen, auf Wahrheitswert getestet und in eine Zeichenkette konvertiert werden (mit der Funktion repr() oder der leicht abweichenden Funktion str()). Letztere Funktion wird implizit verwendet, wenn ein Objekt von der Funktion print() ausgegeben wird.

Wahrheitswertprüfung

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

Standardmäßig gilt ein Objekt als wahr, es sei denn, seine Klasse definiert entweder eine Methode __bool__(), die False zurückgibt, oder eine Methode __len__(), die Null zurückgibt, wenn sie mit dem Objekt aufgerufen wird. [1] Hier sind die meisten der eingebauten Objekte, die als falsch gelten:

• 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 Sammlungen: '', (), [], {}, set(), range(0)

Operationen und eingebaute Funktionen, die ein boolesches Ergebnis liefern, 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, sortiert nach aufsteigender Priorität

Operation	Ergebnis	Hinweise
x or y	wenn x wahr ist, dann x, ansonsten y	(1)
x and y	wenn x falsch ist, dann x, ansonsten y	(2)
not x	wenn x falsch ist, dann True, ansonsten False	(3)

Hinweise

1. Dies ist ein Short-Circuit-Operator, der das zweite Argument nur auswertet, wenn das erste falsch ist.

2. Dies ist ein Short-Circuit-Operator, der das zweite Argument nur auswertet, 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

In Python gibt es acht Vergleichsoperationen. Sie alle haben die gleiche Priorität (die 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, außer dass y nur einmal ausgewertet wird (aber in beiden Fällen z gar nicht ausgewertet wird, wenn x < y als falsch befunden wird).

Diese Tabelle fasst die Vergleichsoperationen zusammen

Operation	Bedeutung
<	strikt kleiner als
<=	kleiner als oder gleich
>	strikt größer als
>=	größer als oder gleich
==	gleich
!=	ungleich
is	Objektidentität
is not	negierte Objektidentität

Objekte unterschiedlicher Typen, außer verschiedenen numerischen Typen, sind niemals gleich. Der Operator == ist immer definiert, aber für einige Objekttypen (z.B. Klassenobjekte) ist er äquivalent zu is. Die Operatoren <, <=, > und >= sind nur dort definiert, wo sie sinnvoll sind; zum Beispiel lösen sie eine TypeError-Ausnahme aus, wenn einer der Operanden eine komplexe Zahl ist.

Nicht identische Instanzen einer Klasse vergleichen sich normalerweise als ungleich, es sei denn, die Klasse definiert die Methode __eq__().

Instanzen einer Klasse können nicht mit anderen Instanzen derselben Klasse oder anderen Objekttypen geordnet werden, es sei denn, die Klasse definiert genügend der Methoden __lt__(), __le__(), __gt__() und __ge__() (im Allgemeinen reichen __lt__() und __eq__() aus, wenn die konventionellen Bedeutungen der Vergleichsoperatoren gewünscht sind).

Das Verhalten der Operatoren is und is not kann nicht angepasst werden; außerdem können sie auf jedes beliebige Objekt angewendet werden und lösen niemals eine Ausnahme aus.

Zwei weitere Operationen mit der gleichen syntaktischen Priorität, in und not in, werden von Typen unterstützt, die iterierbar 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). Darüber hinaus sind Booleans ein Subtyp von Ganzzahlen. Ganzzahlen haben unbegrenzte Präzision. Gleitkommazahlen werden normalerweise mit double in C implementiert; Informationen über die Präzision und interne Darstellung von Gleitkommazahlen für die Maschine, auf der Ihr Programm läuft, sind in sys.float_info verfügbar. Komplexe Zahlen haben einen Real- und einen Imaginärteil, die jeweils eine Gleitkommazahl sind. Um diese Teile aus einer komplexen Zahl z zu extrahieren, verwenden Sie 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 Präzision.)

Zahlen werden durch numerische Literale oder als Ergebnis von eingebauten Funktionen und Operatoren erstellt. Unverzierten Ganzzahlliterale (einschließlich Hex-, Oktal- und Binärzahlen) ergeben Ganzzahlen. Numerische Literale, die einen Dezimalpunkt oder ein Exponentenzeichen enthalten, ergeben Gleitkommazahlen. Das Anhängen von 'j' oder 'J' an ein numerisches Literal ergibt eine imaginäre Zahl (eine komplexe Zahl mit einem reellen Teil von Null), die Sie zu einer Ganzzahl oder Fließkommazahl addieren können, um eine komplexe Zahl mit reellem und imaginärem Teil zu erhalten.

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

Python unterstützt vollständig gemischte Arithmetik: Wenn ein binärer arithmetischer Operator Operanden unterschiedlicher numerischer Typen hat, wird der Operand mit dem „schmaleren“ Typ auf den des anderen erweitert, wobei Ganzzahlen schmaler als Gleitkommazahlen sind. Die Arithmetik mit komplexen und reellen Operanden wird durch die üblichen mathematischen Formeln definiert, zum Beispiel

x + complex(u, v) = complex(x + u, v)
x * complex(u, v) = complex(x * u, x * v)

Ein Vergleich zwischen Zahlen unterschiedlicher Typen verhält sich so, als ob die exakten Werte dieser Zahlen verglichen würden. [2]

Alle numerischen Typen (außer komplexen) unterstützen die folgenden Operationen (Prioritäten der Operationen siehe Operatorrangfolge)

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	Ganzzahliger Quotient von x und y	(1)(2)
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 konvertiert zu Ganzzahl	(3)(6)	int()
float(x)	x konvertiert zu Gleitkommazahl	(4)(6)	float()
complex(re, im)	eine komplexe Zahl mit Realteil re und Imaginärteil im. im ist standardmäßig Null.	(6)	complex()
c.conjugate()	konjugierte komplexe Zahl von 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. Auch Ganzzahldivision genannt. Bei Operanden vom Typ int hat das Ergebnis den Typ int. Bei Operanden vom Typ float hat das Ergebnis den Typ float. Im Allgemeinen ist das Ergebnis eine ganze Zahl, auch wenn der Typ des Ergebnisses nicht unbedingt int ist. Das Ergebnis wird immer zur Minus-Unendlich-Richtung gerundet: 1//2 ist 0, (-1)//2 ist -1, 1//(-2) ist -1 und (-1)//(-2) ist 0.

2. Nicht für komplexe Zahlen. Konvertieren Sie stattdessen in Fließkommazahlen mit abs(), falls zutreffend.

3. Die Konvertierung von float in int schneidet ab und verwirft den Bruchteil. Siehe die Funktionen math.floor() und math.ceil() für alternative Konvertierungen.

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

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

6. Die akzeptierten numerischen Literale umfassen die Ziffern 0 bis 9 oder ein beliebiges 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) beinhalten auch die folgenden Operationen

Operation	Ergebnis
math.trunc(x)	x gekürzt auf Integral
round(x[, n])	x gerundet auf n Nachkommastellen, Rundung zur nächsten geraden Zahl. Wenn n weggelassen wird, ist der Standardwert 0.
math.floor(x)	die größte Integral <= x
math.ceil(x)	die kleinste Integral >= x

Für zusätzliche numerische Operationen siehe die Module math und cmath.

Bitweise Operationen auf Ganzzahltypen

Bitweise Operationen sind nur für Ganzzahlen sinnvoll. Das Ergebnis von bitweisen Operationen wird berechnet, als ob es in Zweierkomplement mit einer unendlichen Anzahl von Vorzeichenbits durchgeführt worden wäre.

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 in aufsteigender Priorität

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

Hinweise

1. Negative Verschiebungsanzahlen sind illegal und verursachen eine ValueError.

2. Eine Linksverschiebung um n Bits entspricht einer Multiplikation mit pow(2, n).

3. Eine Rechtsverschiebung um n Bits entspricht einer Ganzzahldivision durch pow(2, n).

4. Die Durchführung dieser Berechnungen mit mindestens einem zusätzlichen Vorzeichenerweiterungsbit in einer endlichen Zweierkomplementdarstellung (einer Arbeitsbitbreite von 1 + max(x.bit_length(), y.bit_length()) oder mehr) ist ausreichend, um das gleiche Ergebnis zu erzielen, als ob es eine unendliche Anzahl von Vorzeichenbits gäbe.

Zusätzliche Methoden für Ganzzahltypen

Der Typ `int` implementiert die numbers.Integral abstrakte Basisklasse. Zusätzlich bietet er einige weitere Methoden

int.bit_length()

Gibt die Anzahl der Bits zurück, die zur Darstellung einer Ganzzahl in binärer Form benötigt werden, ohne Vorzeichen und führende 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 ganze Zahl k, so dass 2**(k-1) <= abs(x) < 2**k. Äquivalent dazu, 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.

Entspricht

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

Hinzugefügt 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 Populationsanzahl bekannt. Beispiel

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

Entspricht

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

Hinzugefügt 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 und hat standardmäßig den Wert 1. Es wird ein OverflowError ausgelöst, wenn die Ganzzahl nicht mit der angegebenen Anzahl von Bytes dargestellt werden kann.

Das Argument byteorder bestimmt die Byte-Reihenfolge, die zur Darstellung der Ganzzahl verwendet wird, und hat standardmäßig den Wert "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 False ist 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 Sie jedoch die Standardargumente verwenden, versuchen Sie nicht, einen Wert größer als 255 umzuwandeln, da Sie sonst einen OverflowError erhalten.

Entspricht

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)

Hinzugefügt in Version 3.2.

Geändert in Version 3.11: Standardargumentwerte für length und byteorder hinzugefügt.

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

Gibt die Ganzzahl zurück, die durch das gegebene 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 iterierbares Objekt sein, das Bytes liefert.

Das Argument byteorder bestimmt die Byte-Reihenfolge, die zur Darstellung der Ganzzahl verwendet wird, und hat standardmäßig den Wert "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 Byte-Reihenfolge des Hostsystems anzufordern, verwenden Sie sys.byteorder als Byte-Reihenfolgenwert.

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

Entspricht

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

Hinzugefügt in Version 3.2.

Geändert in Version 3.11: Standardargumentwert für byteorder hinzugefügt.

int.as_integer_ratio()

Gibt ein Paar von ganzen Zahlen zurück, deren Verhältnis gleich der ursprünglichen ganzen Zahl ist und einen positiven Nenner hat. Das ganzzahlige Verhältnis von ganzen Zahlen (ganzen Zahlen) ist immer die ganze Zahl als Zähler und 1 als Nenner.

Hinzugefügt in Version 3.8.

int.is_integer()

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

Hinzugefügt in Version 3.12.

Zusätzliche Methoden für Float

Der Float-Typ implementiert die numbers.Real abstrakte Basisklasse. Float hat auch die folgenden zusätzlichen Methoden.

classmethod float.from_number(x)

Klassenmethode zur Rückgabe einer Gleitkommazahl, die aus einer Zahl x konstruiert wurde.

Wenn das Argument eine ganze Zahl oder eine Gleitkommazahl ist, wird eine Gleitkommazahl mit demselben Wert (innerhalb der Gleitkommagenauigkeit von Python) zurückgegeben. Wenn das Argument außerhalb des Bereichs eines Python-Floats liegt, wird ein OverflowError ausgelöst.

Für ein allgemeines Python-Objekt x delegiert float.from_number(x) an x.__float__(). Wenn __float__() nicht definiert ist, wird auf __index__() zurückgegriffen.

Hinzugefügt in Version 3.14.

float.as_integer_ratio()

Gibt ein Paar von ganzen Zahlen zurück, deren Verhältnis exakt gleich dem ursprünglichen Float ist. Das Verhältnis ist in gekürzter Form und hat einen positiven Nenner. Löst OverflowError bei Unendlichkeiten und einen ValueError bei NaNs aus.

float.is_integer()

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

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

Zwei Methoden unterstützen die Konvertierung von und zu hexadezimalen Strings. Da Pythons Floats intern als Binärzahlen gespeichert werden, beinhaltet die Konvertierung eines Floats von oder zu einem *Dezimal*-String normalerweise einen kleinen Rundungsfehler. Im Gegensatz dazu ermöglichen hexadezimale Strings eine exakte Darstellung und Spezifikation von Gleitkommazahlen. Dies kann bei der Fehlersuche und in numerischen Arbeiten nützlich sein.

float.hex()

Gibt eine Darstellung einer Gleitkommazahl als hexadezimalen String zurück. Für endliche Gleitkommazahlen enthält diese Darstellung immer eine führende 0x und eine nachfolgende p mit Exponent.

classmethod float.fromhex(s)

Klassenmethode zur Rückgabe des Floats, der durch einen hexadezimalen String s dargestellt wird. Der String s kann führende und nachfolgende Leerzeichen enthalten.

Beachten Sie, dass float.hex() eine Instanzmethode ist, während float.fromhex() eine Klassenmethode ist.

Ein hexadezimaler String hat das Format

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

wobei das optionale sign entweder + oder - sein kann, integer und fraction Strings hexadezimaler Ziffern sind und exponent eine dezimale ganze Zahl mit optionalem führenden Vorzeichen ist. Die Groß-/Kleinschreibung wird nicht beachtet, und es muss mindestens eine hexadezimale Ziffer entweder im ganzzahligen Teil oder im Bruchteil vorhanden sein. Diese Syntax ähnelt der in Abschnitt 6.4.4.2 des C99-Standards angegebenen Syntax und auch der in Java 1.5 und neuer 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 hexadezimale Strings werden von float.fromhex() akzeptiert.

Beachten Sie, dass der Exponent dezimal statt hexadezimal geschrieben wird und die Potenz von 2 angibt, mit der der Koeffizient multipliziert werden soll. Zum Beispiel repräsentiert der hexadezimale String 0x3.a7p10 die Gleitkommazahl (3 + 10./16 + 7./16**2) * 2.0**10 oder 3740.0.

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

Die Rückkonvertierung von 3740.0 ergibt einen anderen hexadezimalen String, der dieselbe Zahl darstellt:

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

Zusätzliche Methoden für Complex

Der complex-Typ implementiert die numbers.Complex abstrakte Basisklasse. complex hat auch die folgenden zusätzlichen Methoden.

classmethod complex.from_number(x)

Klassenmethode zur Konvertierung einer Zahl in eine komplexe Zahl.

Für ein allgemeines Python-Objekt x delegiert complex.from_number(x) an x.__complex__(). Wenn __complex__() nicht definiert ist, wird auf __float__() zurückgegriffen. Wenn __float__() nicht definiert ist, wird auf __index__() zurückgegriffen.

Hinzugefügt in Version 3.14.

Hashing numerischer Typen

Für Zahlen x und y, möglicherweise unterschiedlichen Typs, ist es eine Anforderung, dass hash(x) == hash(y) ist, wann immer x == y (siehe die Dokumentation der Methode __hash__() für weitere Details). Zur Vereinfachung der Implementierung und Effizienz über eine Vielzahl von numerischen Typen (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 daher für alle Instanzen von int und fractions.Fraction und alle endlichen Instanzen von float und decimal.Decimal gilt. Im Wesentlichen wird diese Funktion durch Reduktion modulo P für eine feste Primzahl P gegeben. Der Wert von P ist Python als Attribut modulus von sys.hash_info zugänglich.

CPython-Implementierungsdetail: Derzeit wird die verwendete Primzahl P = 2**31 - 1 auf Maschinen mit 32-Bit-C-Longs und P = 2**61 - 1 auf Maschinen mit 64-Bit-C-Longs verwendet.

Hier sind die Regeln im Detail:

• Wenn x = m / n eine nicht-negative rationale Zahl ist und n nicht durch P teilbar ist, definieren Sie hash(x) als m * invmod(n, P) % P, wobei invmod(n, P) den Inversen von n modulo P angibt.

• Wenn x = m / n eine nicht-negative rationale Zahl ist und n durch P teilbar ist (aber m nicht), dann hat n keinen inversen modulo P und die obige Regel gilt nicht; in diesem Fall definieren Sie hash(x) als den konstanten Wert sys.hash_info.inf.

• Wenn x = m / n eine negative rationale Zahl ist, definieren Sie hash(x) als -hash(-x). Wenn der resultierende Hash -1 ist, ersetzen Sie ihn durch -2.

• Die spezifischen Werte sys.hash_info.inf und -sys.hash_info.inf werden als Hash-Werte für positive Unendlichkeit bzw. negative Unendlichkeit verwendet.

• Für eine complex-Zahl z werden die Hash-Werte der realen und imaginären Teile kombiniert, indem hash(z.real) + sys.hash_info.imag * hash(z.imag) berechnet wird, reduziert modulo 2**sys.hash_info.width, so dass er im Bereich range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) liegt. Auch hier wird das Ergebnis durch -2 ersetzt, wenn es -1 ist.

Zur Verdeutlichung der obigen Regeln, hier ist ein Beispiel-Python-Code, der dem integrierten Hash entspricht und zur Berechnung des Hash einer rationalen Zahl, eines float oder eines complex verwendet wird:

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 repräsentieren Wahrheitswerte. Der bool-Typ hat genau zwei konstante Instanzen: True und False.

Die eingebaute Funktion bool() konvertiert jeden Wert in einen Boolean, wenn der Wert als Wahrheitswert interpretiert werden kann (siehe Abschnitt Wahrheitswertprüfung oben).

Für logische Operationen verwenden Sie die Booleschen Operatoren and, or und not. Wenn die bitweisen Operatoren &, |, ^ auf zwei Booleans angewendet werden, geben sie einen Bool zurück, der äquivalent zu den logischen Operationen „and“, „or“, „xor“ ist. Die logischen Operatoren and, or und != sollten jedoch &, | und ^ vorgezogen werden.

Veraltet seit 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 ganzen Zahlen 0 und 1. Dies zu nutzen, wird jedoch nicht empfohlen; konvertieren Sie stattdessen explizit mit int().

Iteratortypen

Python unterstützt das Konzept der Iteration über Container. Dies wird durch zwei verschiedene Methoden implementiert; diese werden verwendet, um benutzerdefinierten Klassen die Unterstützung der Iteration zu ermöglichen. Sequenzen, die im Folgenden detaillierter beschrieben werden, unterstützen immer die Iterationsmethoden.

Eine Methode muss für Containerobjekte definiert werden, um iterable-Unterstützung bereitzustellen:

container.__iter__()

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

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

iterator.__iter__()

Gibt das iterator-Objekt selbst zurück. Dies ist erforderlich, um sowohl Container als auch Iteratoren mit den for- und in-Anweisungen verwenden zu können. Diese Methode entspricht dem tp_iter-Slot der Typenstruktur 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 StopIteration-Ausnahme ausgelöst. Diese Methode entspricht dem tp_iternext-Slot der Typenstruktur für Python-Objekte in der Python/C-API.

Python definiert mehrere Iteratortypen, um die Iteration über allgemeine und spezifische Sequenztypen, Wörterbücher und andere spezialisiertere Formen zu unterstützen. Die spezifischen Typen sind nicht wichtig, abgesehen von ihrer Implementierung des Iterator-Protokolls.

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

Generatortypen

Pythons generatoren bieten eine bequeme Möglichkeit, das Iterator-Protokoll zu implementieren. Wenn die __iter__()-Methode eines Container-Objekts als Generator implementiert ist, gibt sie automatisch ein Iterator-Objekt zurück (technisch gesehen ein Generator-Objekt), das die Methoden __iter__() und __next__() bereitstellt. Weitere Informationen zu Generatoren finden Sie in der Dokumentation für den 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 Textstrings zugeschnitten sind, werden in separaten Abschnitten beschrieben.

Gemeinsame Sequenzoperationen

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

Diese Tabelle listet die Sequenzoperationen nach aufsteigender Priorität auf. In der Tabelle sind s und t Sequenzen desselben Typs, n, i, j und k sind ganze Zahlen und x ist ein beliebiges Objekt, das die von s auferlegten Typ- und Wertbeschränkungen erfüllt.

Die Operationen in und not in haben die gleiche Priorität wie die Vergleichsoperationen. Die Operationen + (Konkatenation) 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 gleich x ist, sonst False.	(1)
x not in s	False, wenn ein Element von s gleich x ist, sonst True.	(1)
s + t	die Konkatenation von s und t.	(6)(7)
s * n oder n * s	entspricht der Addition von s zu sich selbst n Mal.	(2)(7)
s[i]	i-tes Element von s, Index 0	(3)(8)
s[i:j]	Slice von s von i bis j.	(3)(4)
s[i:j:k]	Slice von s von i bis j mit Schrittweite k.	(3)(5)
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 Tupel und Listen werden lexikografisch verglichen, indem entsprechende Elemente verglichen werden. Das bedeutet, dass zur Gleichheit jedes Element gleich sein muss und die beiden Sequenzen vom selben Typ sein und die gleiche Länge haben müssen. (Vollständige Details finden Sie unter Vergleiche in der Sprachreferenz.)

Vorwärts- und Rückwärtsiteratoren über mutierbare Sequenzen greifen über einen Index auf Werte zu. Dieser Index wird weiter vorwärts (oder rückwärts) laufen, auch wenn die zugrunde liegende Sequenz mutiert wird. Der Iterator endet nur, wenn ein IndexError oder ein StopIteration angetroffen wird (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 Enthaltungstests verwendet werden, verwenden einige spezialisierte Sequenzen (wie str, bytes und bytearray) sie auch für Untersequenztests.

   >>> "gg" in "eggs"
   True
   

2. Werte von n kleiner als 0 werden als 0 behandelt (was eine leere Sequenz des gleichen Typs wie s ergibt). Beachten Sie, dass Elemente in der Sequenz s nicht kopiert werden; sie werden mehrmals referenziert. Dies plagt oft neue Python-Programmierer; betrachten Sie

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

   Was passiert ist, dass [[]] eine Ein-Element-Liste ist, die eine leere Liste enthält, so dass alle drei Elemente von [[]] * 3 Referenzen auf diese einzelne leere Liste sind. Das Ändern eines beliebigen Elements von lists ändert diese einzelne Liste. Sie können auf diese Weise eine Liste verschiedener 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 Sie im FAQ-Eintrag Wie erstelle ich eine mehrdimensionale Liste?.

3. Wenn i oder j negativ sind, ist der Index relativ zum Ende der Sequenz s: len(s) + i oder len(s) + j wird substituiert. Beachten Sie jedoch, dass -0 immer noch 0 ist.

4. Der Slice von s von i bis j ist definiert als die Sequenz von Elementen mit dem Index k, so dass i <= k < j. Wenn i oder j größer als len(s) ist, wird len(s) verwendet. Wenn i weggelassen wird oder None ist, wird 0 verwendet. Wenn j weggelassen wird oder None ist, wird len(s) verwendet. Wenn i größer oder gleich j ist, ist der Slice leer.

5. Der Slice von s von i bis j mit Schrittweite k ist definiert als die Sequenz von Elementen mit dem Index x = i + n*k, so dass 0 <= n < (j-i)/k. Anders ausgedrückt sind die Indizes i, i+k, i+2*k, i+3*k und so weiter, wobei gestoppt wird, wenn j erreicht wird (aber j niemals eingeschlossen wird). Wenn k positiv ist, werden i und j auf len(s) reduziert, wenn sie größer sind. Wenn k negativ ist, werden i und j auf len(s) - 1 reduziert, wenn sie größer sind. Wenn i oder j weggelassen werden oder None sind, werden sie zu „Endwert“-Werten (welches Ende hängt vom Vorzeichen von k ab). Beachten Sie, dass k nicht Null sein kann. Wenn k None ist, wird es wie 1 behandelt.

6. Das Verketten von unveränderlichen Sequenzen ergibt immer ein neues Objekt. Das bedeutet, dass das Aufbauen einer Sequenz durch wiederholtes Verketten eine Laufzeitkosten quadratisch zur gesamten Sequenzlänge hat. Um eine lineare Laufzeit zu erzielen, müssen Sie zu einer der folgenden Alternativen wechseln.

   • Wenn Sie str Objekte verketten, können Sie eine Liste erstellen und am Ende str.join() verwenden oder alternativ in eine io.StringIO Instanz schreiben und ihren Wert abrufen, wenn sie vollständig ist.

   • Wenn Sie bytes Objekte verketten, können Sie ähnlich bytes.join() oder io.BytesIO verwenden, oder Sie können die In-Place-Verkettung mit einem bytearray Objekt durchführen. bytearray Objekte sind veränderlich und verfügen über einen effizienten Mechanismus zur Vorabzuallokation.

   • Wenn Sie tuple Objekte verketten, erweitern Sie stattdessen eine list.

   • Für andere Typen untersuchen Sie die Dokumentation der entsprechenden Klasse.

7. Einige Sequenztypen (wie z. B. range) unterstützen nur Elementsequenzen, die bestimmten Mustern folgen, und unterstützen daher keine Sequenzverkettung oder -wiederholung.

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

Sequenzmethoden

Sequenztypen unterstützen auch 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 und stop ermöglichen eine effiziente Suche in Teilabschnitten der Sequenz, beginnend bei start und endend bei stop. Dies ist ungefähr gleichbedeutend mit start + sequence[start:stop].index(value), nur ohne das 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 generell implementieren und die nicht auch von veränderlichen Sequenztypen implementiert wird, ist die Unterstützung für die eingebaute Funktion hash().

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

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

Veränderliche Sequenztypen

Die Operationen in der folgenden Tabelle sind für veränderliche Sequenztypen definiert. Die collections.abc.MutableSequence ABC wird bereitgestellt, um die korrekte Implementierung dieser Operationen für benutzerdefinierte Sequenztypen zu erleichtern.

In der Tabelle ist s eine Instanz eines veränderlichen Sequenztyps, t ist ein beliebiges iterierbares Objekt und x ist ein beliebiges Objekt, das die von s auferlegten Typ- und Wertbeschränkungen erfüllt (zum Beispiel akzeptiert bytearray nur ganze Zahlen, die die Wertbeschrä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 aus s.
s[i:j] = t	Slice 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] werden durch die von t ersetzt.	(1)
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 dasselbe wie s[len(s):len(s)] = t).
s *= n	Aktualisiert s mit seinem Inhalt, wiederholt n Mal.	(2)

Hinweise

1. Wenn k ungleich 1 ist, muss t die gleiche Länge haben wie der Slice, den es ersetzt.

2. Der Wert n ist eine ganze Zahl 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 erklärt.

Methoden veränderlicher Sequenzen

Veränderliche Sequenztypen unterstützen auch die folgenden Methoden

sequence.append(value, /)

Fügt value am Ende der Sequenz an. Dies entspricht dem Schreiben von seq[len(seq):len(seq)] = [value].

sequence.clear()

Hinzugefügt in Version 3.3.

Entfernt alle Elemente aus sequence. Dies entspricht dem Schreiben von del sequence[:].

sequence.copy()

Hinzugefügt in Version 3.3.

Erstellt eine flache Kopie von sequence. Dies entspricht dem Schreiben von sequence[:].

Hinweis

Die Methode copy() ist kein Teil der MutableSequence ABC, aber die meisten konkreten veränderlichen Sequenztypen stellen sie bereit.

sequence.extend(iterable, /)

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

sequence.insert(index, value, /)

Fügt value an der angegebenen index in sequence ein. Dies entspricht dem Schreiben von sequence[index:index] = [value].

sequence.pop(index=-1, /)

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

sequence.remove(value, /)

Entfernt das erste Element aus sequence, bei dem sequence[i] == value gilt.

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

sequence.reverse()

Kehrt die Elemente von sequence an Ort und Stelle um. Diese Methode spart Speicherplatz beim Umkehren einer großen Sequenz. Um Benutzer daran zu erinnern, dass sie per Nebeneffekt 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 Paares eckiger Klammern, um die leere Liste zu bezeichnen: []

• Verwendung eckiger Klammern, Elemente durch Kommas getrennt: [a], [a, b, c]

• Verwendung einer Listen-Komprehension: [x for x in iterable]

• Verwendung des Typkonstruktors: list() oder list(iterable)

Der Konstruktor erstellt eine Liste, deren Elemente die gleichen sind und in der gleichen Reihenfolge wie die von iterable’s Elementen. iterable kann entweder eine Sequenz, ein Container, der Iteration unterstützt, oder ein Iterator-Objekt sein. Wenn iterable bereits eine Liste ist, wird eine Kopie erstellt und zurückgegeben, ähnlich wie bei iterable[:]. Zum Beispiel gibt list('abc') ['a', 'b', 'c'] zurück und list( (1, 2, 3) ) gibt [1, 2, 3] zurück. Wenn kein Argument angegeben wird, erstellt der Konstruktor eine neue leere Liste, [].

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

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 an Ort und Stelle, indem sie nur <-Vergleiche zwischen Elementen verwendet. Ausnahmen werden nicht unterdrückt - wenn irgendeine Vergleichsoperation fehlschlägt, schlägt die gesamte Sortieroperation fehl (und die Liste bleibt wahrscheinlich teilweise modifiziert).

sort() akzeptiert zwei Argumente, die nur als Schlüsselwortargumente übergeben werden können (Keyword-only arguments)

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

Das Hilfsmittel functools.cmp_to_key() ist verfügbar, um eine 2.x-Stil-cmp-Funktion in eine key-Funktion zu konvertieren.

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

Diese Methode modifiziert die Sequenz an Ort und Stelle, um Speicherplatz zu sparen, wenn eine große Sequenz sortiert wird. Um Benutzer daran zu erinnern, dass sie per Nebeneffekt arbeitet, gibt sie nicht die sortierte Sequenz zurück (verwenden Sie sorted(), um explizit eine neue sortierte Listeninstanz anzufordern).

Die Methode sort() ist garantiert stabil. Eine Sortierung ist stabil, wenn sie garantiert, die relative Reihenfolge von Elementen, die gleich verglichen werden, nicht zu ändern — dies ist hilfreich für das Sortieren in mehreren Durchläufen (z. B. sortieren nach Abteilung, dann nach Gehaltsstufe).

Für Sortierbeispiele und eine kurze Sortieranleitung siehe Sortiertechniken.

CPython-Implementierungsdetail: Während eine Liste sortiert wird, ist die Auswirkung des Versuchs, die Liste zu verändern oder sogar zu inspizieren, undefiniert. Die C-Implementierung von Python lässt die Liste währenddessen leer erscheinen und löst einen ValueError aus, wenn sie erkennen kann, dass die Liste während einer Sortierung verändert wurde.

Tupel

Tupel sind unveränderliche Sequenzen, die typischerweise zum Speichern von Sammlungen heterogener Daten verwendet werden (wie z. B. die 2-Tupel, die von der eingebauten Funktion enumerate() erzeugt werden). Tupel werden auch für Fälle verwendet, in denen eine unveränderliche Sequenz homogener Daten benötigt wird (wie z. B. die Speicherung in einer set- oder dict-Instanz).

class tuple(iterable=(), /)

Tupel können auf verschiedene Arten konstruiert werden

• Verwendung eines Paares von Klammern, um das leere Tupel zu bezeichnen: ()

• Verwendung eines abschließenden Kommas für ein Singleton-Tupel: a, oder (a,)

• Elemente durch Kommas getrennt: a, b, c oder (a, b, c)

• Verwendung der eingebauten Funktion tuple(): tuple() oder tuple(iterable)

Der Konstruktor erstellt ein Tupel, dessen Elemente die gleichen sind und in der gleichen Reihenfolge wie die von iterable’s Elementen. iterable kann entweder eine Sequenz, ein Container, der Iteration unterstützt, oder ein Iterator-Objekt sein. Wenn iterable bereits ein Tupel ist, wird es unverändert zurückgegeben. Zum Beispiel gibt tuple('abc') ('a', 'b', 'c') zurück und tuple( [1, 2, 3] ) gibt (1, 2, 3) zurück. Wenn kein Argument angegeben wird, erstellt der Konstruktor ein neues leeres Tupel, ().

Beachten Sie, dass tatsächlich das Komma ein Tupel erzeugt, nicht die 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.

Für heterogene Sammlungen von Daten, bei denen der Zugriff nach Namen klarer ist als der Zugriff nach Index, kann collections.namedtuple() eine geeignetere Wahl sein als ein einfaches Tupel-Objekt.

Bereiche

Der range-Typ repräsentiert eine unveränderliche Zahlenmenge und wird häufig für Schleifen einer bestimmten Anzahl von Wiederholungen in for-Schleifen verwendet.

class range(stop, /)

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

Die Argumente für den Range-Konstruktor müssen ganze Zahlen sein (entweder 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 eines Bereichs r durch die Formel r[i] = start + step*i bestimmt, wobei i >= 0 und r[i] < stop.

Für ein negatives step werden die Inhalte des Bereichs immer noch durch die Formel r[i] = start + step*i bestimmt, aber die Einschränkungen sind i >= 0 und r[i] > stop.

Ein Range-Objekt ist leer, wenn r[0] die Wertbeschränkung nicht erfüllt. Bereiche unterstützen negative Indizes, aber diese werden als Indizierung vom Ende der Sequenz interpretiert, die durch die positiven Indizes bestimmt wird.

Bereiche, die absolute Werte größer als sys.maxsize enthalten, sind zulässig, aber einige Funktionen (wie z. B. len()) können 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))
[]

Bereiche implementieren alle gemeinsamen Sequenzoperationen mit Ausnahme von Verkettung und Wiederholung (da Range-Objekte nur Sequenzen darstellen können, die einem strengen Muster folgen, und Wiederholung und Verkettung dieses Muster normalerweise verletzen).

start

Der Wert des Parameters start (oder 0, wenn der Parameter nicht angegeben wurde)

stop

Der Wert des Parameters stop

step

Der Wert des Parameters step (oder 1, wenn der Parameter nicht angegeben wurde)

Der Vorteil des range-Typs gegenüber einer regulären list oder tuple besteht darin, dass ein range-Objekt immer die gleiche (geringe) Menge an Speicherplatz benötigt, unabhängig von der Größe des von ihm dargestellten Bereichs (da es nur die Werte start, stop und step speichert und einzelne Elemente und Unterbereiche bei Bedarf berechnet).

Range-Objekte implementieren die collections.abc.Sequence ABC und bieten Funktionen wie Containment-Tests, Elementindex-Lookups, 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 Testen von Range-Objekten auf Gleichheit mit == und != vergleicht sie als Sequenzen. Das bedeutet, zwei Range-Objekte gelten als gleich, wenn sie die gleiche Sequenz von Werten darstellen. (Beachten Sie, dass zwei Range-Objekte, die gleich sind, unterschiedliche start-, stop- und step-Attribute haben können, z. B. 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 für Slicing und negative Indizes. Testen von int-Objekten auf Mitgliedschaft in konstanter Zeit anstatt durch Iteration aller Elemente.

Geändert in Version 3.3: Definition von „==“ und „!=“ zum Vergleichen von Range-Objekten basierend auf der von ihnen definierten Wertesequenz (anstatt des Vergleichens basierend auf der Objektidentität).

Hinzugefügt wurden die Attribute start, stop und step.

Siehe auch

• Das linspace-Rezept zeigt, wie eine Lazy-Version von range für Gleitkommaanwendungen implementiert wird.

Zusammenfassung der Methoden für Text- und Binärsequenztypen

Die folgende Tabelle fasst die Methoden für Text- und Binärsequenztypen nach Kategorien zusammen.

Kategorie	Methoden für str				Methoden für bytes und bytearray
Formatierung	str.format()
	str.format_map()
	f-Strings
	printf-Formatierung von Strings				printf-Formatierung von Bytes
Suchen und Ersetzen	str.find()	str.rfind()			bytes.find()	bytes.rfind()
	str.index()	str.rindex()			bytes.index()	bytes.rindex()
	str.startswith()				bytes.startswith()
	str.endswith()				bytes.endswith()
	str.count()				bytes.count()
	str.replace()				bytes.replace()
Teilen und Zusammenfügen	str.split()		str.rsplit()		bytes.split()		bytes.rsplit()
	str.splitlines()				bytes.splitlines()
	str.partition()				bytes.partition()
	str.rpartition()				bytes.rpartition()
	str.join()				bytes.join()
String-Klassifizierung	str.isalpha()				bytes.isalpha()
	str.isdecimal()
	str.isdigit()				bytes.isdigit()
	str.isnumeric()
	str.isalnum()				bytes.isalnum()
	str.isidentifier()
	str.islower()				bytes.islower()
	str.isupper()				bytes.isupper()
	str.istitle()				bytes.istitle()
	str.isspace()				bytes.isspace()
	str.isprintable()
Groß-/Kleinschreibung ändern	str.lower()				bytes.lower()
	str.upper()				bytes.upper()
	str.casefold()
	str.capitalize()				bytes.capitalize()
	str.title()				bytes.title()
	str.swapcase()				bytes.swapcase()
Auffüllen und Abschneiden	str.ljust()		str.rjust()		bytes.ljust()		bytes.rjust()
	str.center()				bytes.center()
	str.expandtabs()				bytes.expandtabs()
	str.strip()				bytes.strip()
	str.lstrip()			str.rstrip()	bytes.lstrip()			bytes.rstrip()
Übersetzung und Kodierung	str.translate()				bytes.translate()
	str.maketrans()				bytes.maketrans()
	str.encode()
					bytes.decode()

Textsequenztyp — str

Textuelle Daten in Python werden mit str-Objekten, oder auch Strings genannt, verarbeitet. Strings sind unveränderliche Sequenzen von Unicode-Codepunkten. String-Literale werden auf verschiedene Arten geschrieben

• Einfache Anführungszeichen: 'ermöglicht eingebettete "doppelte" Anführungszeichen'

• Doppelte Anführungszeichen: "ermöglicht eingebettete 'einfache' Anführungszeichen"

• Dreifach Anführungszeichen: '''Drei einfache Anführungszeichen''', """Drei doppelte Anführungszeichen"""

Dreifach Anführungszeichen können sich über mehrere Zeilen erstrecken – alle zugehörigen Leerzeichen werden in das String-Literal einbezogen.

String-Literale, die Teil eines einzigen Ausdrucks sind und nur Leerzeichen dazwischen haben, werden implizit in ein einziges String-Literal umgewandelt. Das heißt, ("spam " "eggs") == "spam eggs".

Siehe String- und Byte-Literale für mehr über die verschiedenen Formen von String-Literalen, einschließlich unterstützter Escape-Sequenzen und des Präfixes r („raw“), das die meisten Escape-Sequenzverarbeitungen deaktiviert.

Strings können auch aus anderen Objekten mit dem str-Konstruktor erstellt werden.

Da es keinen separaten „Zeichen“-Typ gibt, liefert das Indizieren 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 effizient Strings aus mehreren Fragmenten zu konstruieren.

Geändert in Version 3.3: Zur Rückwärtskompatibilität mit der Python 2-Serie ist das Präfix u auf String-Literalen wieder erlaubt. Es hat keinen Einfluss 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 ein leerer String zurückgegeben. Andernfalls hängt das Verhalten von str() davon ab, ob encoding oder errors angegeben sind, wie folgt.

Wenn weder encoding noch errors angegeben sind, gibt str(object) type(object).__str__(object) zurück, was die „informelle“ oder gut druckbare String-Darstellung von object ist. Für String-Objekte ist dies der String selbst. Wenn object keine __str__()-Methode hat, dann greift str() auf die Rückgabe von repr(object) zurück.

Wenn mindestens einer der Parameter encoding oder errors angegeben ist, sollte object ein bytes-ähnliches Objekt sein (z. B. bytes oder bytearray). In diesem Fall ist, wenn object ein bytes- (oder bytearray-) Objekt ist, str(bytes, encoding, errors) äquivalent zu bytes.decode(encoding, errors). Andernfalls wird das der Pufferobjekt zugrundeliegende Bytes-Objekt abgerufen, bevor bytes.decode() aufgerufen wird. Informationen zu Pufferobjekten finden Sie in Binäre Sequenztypen — bytes, bytearray, memoryview und Pufferprotokoll.

Das Übergeben eines bytes-Objekts an str() ohne die Argumente encoding oder errors fällt unter den ersten Fall, die informelle String-Darstellung zurückzugeben (siehe auch die Kommandozeilenoption -b für Python). Zum Beispiel

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

Weitere Informationen über die str-Klasse und ihre Methoden finden Sie in Textsequenztyp — str und im Abschnitt String-Methoden unten. Zum Ausgeben formatierter Strings siehe die Abschnitte f-Strings und Formatierungs-Syntax für Strings. Außerdem siehe den Abschnitt Textverarbeitungsdienste.

String-Methoden

Strings implementieren alle gemeinsamen Sequenzoperationen sowie die unten beschriebenen zusätzlichen Methoden.

Strings unterstützen auch zwei Stile der String-Formatierung, wobei einer ein hohes Maß an Flexibilität und Anpassbarkeit bietet (siehe str.format(), Formatierungs-Syntax für Strings und Benutzerdefinierte String-Formatierung) und der andere auf der C printf-Stil-Formatierung basiert, die einen engeren Bereich von Typen behandelt und etwas schwieriger richtig zu verwenden ist, aber oft schneller für die Fälle ist, die sie behandeln kann (printf-Formatierung von Strings).

Der Abschnitt Textverarbeitungsdienste der Standardbibliothek behandelt eine Reihe weiterer Module, die verschiedene textbezogene Dienstprogramme bereitstellen (einschließlich Unterstützung für reguläre 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 Großbuchstaben (Titlecase) anstatt in Großbuchstaben (Uppercase) gesetzt. Das bedeutet, dass Zeichen wie Digraphen nur ihren ersten Buchstaben großgeschrieben bekommen, anstatt des gesamten Zeichens.

str.casefold()

Gibt eine casefolded Kopie des Strings zurück. Casefolded Strings können für den fallunabhängigen Abgleich verwendet werden.

Casefolding ist ähnlich wie Kleinschreibung, aber aggressiver, da es dazu bestimmt ist, alle Fallunterschiede in einem String zu entfernen. Zum Beispiel ist der deutsche Kleinbuchstabe 'ß' äquivalent zu "ss". Da er bereits klein geschrieben ist, würde lower() mit 'ß' nichts tun; casefold() wandelt es in "ss" um.

Der Casefolding-Algorithmus ist in Abschnitt 3.13 „Default Case Folding“ des Unicode-Standards beschrieben.

Hinzugefügt in Version 3.3.

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

Gibt zentriert in einem String der Länge width zurück. Die Auffüllung erfolgt mit dem angegebenen fillchar (Standard ist ein Leerzeichen im ASCII-Format). 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. Optionale 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 String kodiert in bytes zurück.

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

errors steuert, wie Kodierungsfehler behandelt werden. Wenn 'strict' (Standard), wird eine Ausnahme vom Typ UnicodeError ausgelöst. Andere mögliche Werte sind 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' und jeder andere Name, der über codecs.register_error() registriert ist. Siehe Fehlerbehandlungsroutinen 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 aktiviert ist oder ein Debug-Build verwendet wird. 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üsselwortargumente 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 Suffixen sein, nach denen gesucht werden soll. Mit optionalem start wird ab dieser Position getestet. Mit optionalem end wird der Vergleich an dieser Position beendet. Die Verwendung von start und end ist äquivalent zu 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 durch ein oder mehrere Leerzeichen ersetzt werden, abhängig von der aktuellen Spalte und der angegebenen Tabulatorgröße. Tabulatorpositionen treten alle tabsize Zeichen auf (Standard ist 8, was Tabulatorpositionen in den Spalten 0, 8, 16 usw. ergibt). Um den String zu erweitern, wird die aktuelle Spalte auf Null gesetzt und der String Zeichen für Zeichen untersucht. Wenn das Zeichen ein Tabulator ist (\t), werden im Ergebnis ein oder mehrere Leerzeichen eingefügt, bis die aktuelle Spalte mit der nächsten Tabulatorposition übereinstimmt. (Das Tabulatorzeichen selbst wird nicht kopiert.) Wenn das Zeichen ein Zeilenumbruch ist (\n) oder ein Wagenrücklauf (\r), wird es kopiert und die aktuelle Spalte auf Null zurückgesetzt. Jedes andere Zeichen wird unverändert kopiert und die aktuelle Spalte wird unabhängig davon, wie das Zeichen beim Drucken dargestellt wird, um eins erhöht. 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. Optionale 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().

Hinweis

Die Methode find() sollte nur verwendet werden, wenn Sie die Position von sub wissen müssen. Um zu prüfen, ob sub ein Teilstring ist oder nicht, verwenden Sie den Operator in

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

Führt eine String-Formatierungsoperation durch. Der String, auf dem diese Methode aufgerufen wird, kann literalen Text oder Ersetzungsfelder enthalten, die von geschweiften Klammern {} begrenzt sind. Jedes Ersetzungsfeld enthält entweder den numerischen Index eines positionsgebundenen Arguments oder den Namen eines schlüsselwortgebundenen Arguments. Gibt eine Kopie des Strings zurück, bei der jedes Ersetzungsfeld durch den String-Wert des entsprechenden Arguments ersetzt wurde.

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

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

Hinweis

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

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

str.format_map(mapping, /)

Ähnlich wie str.format(**mapping), mit dem Unterschied, 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'

Hinzugefügt in Version 3.2.

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

Wie find(), löst aber einen ValueError aus, wenn die Teilzeichenkette nicht gefunden wird.

str.isalnum()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette alphanumerisch sind und mindestens ein Zeichen vorhanden ist, andernfalls False. Ein Zeichen c ist alphanumerisch, wenn eine der folgenden Bedingungen True zurückgibt: c.isalpha(), c.isdecimal(), c.isdigit() oder c.isnumeric().

str.isalpha()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette alphabetisch sind und mindestens ein Zeichen vorhanden ist, andernfalls False. Alphabetische Zeichen sind alle Zeichen, die in der Unicode-Zeichendatenbank als „Buchstabe“ definiert sind, d. h. solche mit der allgemeinen Kategorie „Lm“, „Lt“, „Lu“, „Ll“ oder „Lo“. Beachten Sie, dass dies von der in Abschnitt 4.10 „Letters, Alphabetic, and Ideographic“ des Unicode-Standards definierten Alphabetic-Eigenschaft abweicht.

str.isascii()

Gibt True zurück, wenn die Zeichenkette leer ist oder alle Zeichen in der Zeichenkette ASCII sind, andernfalls False. ASCII-Zeichen haben Codepunkte im Bereich U+0000-U+007F.

Hinzugefügt in Version 3.7.

str.isdecimal()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette Dezimalzeichen sind und mindestens ein Zeichen vorhanden ist, andernfalls False. Dezimalzeichen sind solche, die zur Bildung von Zahlen in Basis 10 verwendet werden können, z. B. U+0660, ARABIC-INDIC DIGIT ZERO. Formell ist ein Dezimalzeichen ein Zeichen in der Unicode-Allgemeinkategorie „Nd“.

str.isdigit()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette Ziffern sind und mindestens ein Zeichen vorhanden ist, andernfalls False. Ziffern umfassen Dezimalzeichen und Ziffern, die eine spezielle Behandlung erfordern, wie z. B. die Kompatibilitäts-Hochstellziffern. Dies umfasst Ziffern, die nicht zur Bildung von Zahlen in Basis 10 verwendet werden können, wie die Kharosthi-Zahlen. Formell ist eine Ziffer ein Zeichen mit dem Eigenschaftswert Numeric_Type=Digit oder Numeric_Type=Decimal.

str.isidentifier()

Gibt True zurück, wenn die Zeichenkette gemäß der Sprachdefinition ein gültiger Bezeichner ist, siehe Abschnitt Namen (Bezeichner und Schlüsselwörter).

keyword.iskeyword() kann verwendet werden, um zu prüfen, ob die Zeichenkette s ein reservierter Bezeichner ist, wie z. B. def und class.

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 Groß-/Kleinschreibungs-fähigen Zeichen [4] in der Zeichenkette Kleinbuchstaben sind und mindestens ein Groß-/Kleinschreibungs-fähiges Zeichen vorhanden ist, andernfalls False.

str.isnumeric()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette numerische Zeichen sind und mindestens ein Zeichen vorhanden ist, andernfalls False. Numerische Zeichen umfassen Ziffernzeichen und alle Zeichen, die die Unicode-Eigenschaft für den numerischen Wert haben, z. B. U+2155, VULGAR FRACTION ONE FIFTH. Formell sind numerische Zeichen solche mit dem Eigenschaftswert Numeric_Type=Digit, Numeric_Type=Decimal oder Numeric_Type=Numeric.

str.isprintable()

Gibt True zurück, wenn alle Zeichen in der Zeichenkette druckbar sind, andernfalls False, wenn sie mindestens ein nicht druckbares Zeichen enthält.

Hier bedeutet „druckbar“, dass das Zeichen für die Verwendung in der Ausgabe von repr() geeignet ist; „nicht druckbar“ bedeutet, dass repr() bei eingebauten Typen das Zeichen hexadezimal maskieren wird. Dies hat keine Auswirkungen auf die Behandlung von Zeichenketten, die nach sys.stdout oder sys.stderr geschrieben werden.

Druckbare Zeichen sind solche, die in der Unicode-Zeichendatenbank (siehe unicodedata) eine allgemeine Kategorie in den Gruppen Letter, Mark, Number, Punctuation oder Symbol (L, M, N, P oder S) haben; plus das ASCII-Leerzeichen 0x20. Nicht druckbare Zeichen sind solche in den Gruppen Separator oder Other (Z oder C), außer dem ASCII-Leerzeichen.

str.isspace()

Gibt True zurück, wenn nur Leerzeichen in der Zeichenkette vorhanden sind und mindestens ein Zeichen vorhanden ist, andernfalls False.

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

str.istitle()

Gibt True zurück, wenn die Zeichenkette titelgeschrieben ist und mindestens ein Zeichen vorhanden ist, z. B. Großbuchstaben dürfen nur auf nicht-cased Zeichen und Kleinbuchstaben nur auf cased Zeichen folgen. Andernfalls wird False zurückgegeben.

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 Groß-/Kleinschreibungs-fähigen Zeichen [4] in der Zeichenkette Großbuchstaben sind und mindestens ein Groß-/Kleinschreibungs-fähiges Zeichen vorhanden ist, andernfalls False.

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

str.join(iterable, /)

Gibt eine Zeichenkette zurück, die die Verkettung der Zeichenketten im iterable ist. Ein TypeError wird ausgelöst, wenn nicht-Zeichenkettenwerte im iterable vorhanden sind, einschließlich bytes-Objekten. Der Trenner zwischen den Elementen ist die Zeichenkette, die diese Methode bereitstellt.

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

Gibt die Zeichenkette linksbündig in einer Zeichenkette der Länge width zurück. Die Auffüllung erfolgt mit dem angegebenen fillchar (Standard ist ein ASCII-Leerzeichen). Die ursprüngliche Zeichenkette wird zurückgegeben, wenn width kleiner oder gleich len(s) ist.

str.lower()

Gibt eine Kopie der Zeichenkette zurück, bei der alle Groß-/Kleinschreibungs-fähigen Zeichen [4] in Kleinbuchstaben umgewandelt wurden.

Der verwendete Algorithmus zur Umwandlung in Kleinbuchstaben ist in Abschnitt 3.13 „Default Case Folding“ des Unicode-Standards beschrieben.

str.lstrip(chars=None, /)

Gibt eine Kopie der Zeichenkette zurück, bei der führende Zeichen entfernt wurden. Das Argument chars ist eine Zeichenkette, die die zu entfernenden Zeichen angibt. Wenn es weggelassen wird oder None ist, werden standardmäßig Leerzeichen entfernt. Das Argument chars ist kein Präfix, sondern es werden alle Kombinationen seiner Werte gestrippt.

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

Siehe str.removeprefix() für eine Methode, die eine einzelne Präfix-Zeichenkette entfernt, anstatt alle Zeichen eines Satzes. 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() verwendbar ist.

Wenn nur ein Argument vorhanden ist, muss es ein Wörterbuch sein, das Unicode-Ordinale (Ganzzahlen) oder Zeichen (Zeichenketten der Länge 1) auf Unicode-Ordinale, Zeichenketten (beliebiger Länge) oder None abbildet. Zeichenschlüssel werden dann in Ordnale umgewandelt.

Wenn zwei Argumente vorhanden sind, müssen diese Zeichenketten gleicher Länge sein, und im resultierenden Wörterbuch wird jedes Zeichen in from auf das Zeichen an derselben Position in to abgebildet. Wenn ein drittes Argument vorhanden ist, muss es eine Zeichenkette sein, deren Zeichen auf None im Ergebnis abgebildet werden.

str.partition(sep, /)

Teilt die Zeichenkette 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 die Zeichenkette selbst gefolgt von zwei leeren Zeichenketten enthält.

str.removeprefix(prefix, /)

Wenn die Zeichenkette mit der Zeichenkette prefix beginnt, wird string[len(prefix):] zurückgegeben. Andernfalls wird eine Kopie der ursprünglichen Zeichenkette zurückgegeben.

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

Hinzugefügt in Version 3.9.

str.removesuffix(suffix, /)

Wenn die Zeichenkette mit der Zeichenkette suffix endet und dieses suffix nicht leer ist, wird string[:-len(suffix)] zurückgegeben. Andernfalls wird eine Kopie der ursprünglichen Zeichenkette zurückgegeben.

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

Hinzugefügt in Version 3.9.

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

Gibt eine Kopie der Zeichenkette zurück, bei der alle Vorkommen der Teilzeichenkette old durch new ersetzt wurden. Wenn count angegeben ist, werden nur die ersten count Vorkommen ersetzt. Wenn count nicht angegeben ist oder -1 ist, werden alle Vorkommen ersetzt.

Geändert in Version 3.13: count wird jetzt als Schlüsselwortargument unterstützt.

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

Gibt den höchsten Index in der Zeichenkette zurück, an dem die Teilzeichenkette sub gefunden wurde, so dass sub innerhalb von s[start:end] enthalten ist. Optionale Argumente start und end werden wie in der Slice-Notation interpretiert. Gibt bei Fehlschlag -1 zurück.

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

Wie rfind(), löst aber ValueError aus, wenn die Teilzeichenkette sub nicht gefunden wird.

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

Gibt die Zeichenkette rechtsbündig in einer Zeichenkette der Länge width zurück. Die Auffüllung erfolgt mit dem angegebenen fillchar (Standard ist ein ASCII-Leerzeichen). Die ursprüngliche Zeichenkette wird zurückgegeben, wenn width kleiner oder gleich len(s) ist.

str.rpartition(sep, /)

Teilt die Zeichenkette 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 Zeichenketten gefolgt von der Zeichenkette selbst enthält.

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

Gibt eine Liste der Wörter in der Zeichenkette zurück, wobei sep als Trennzeichen-Zeichenkette verwendet wird. Wenn maxsplit angegeben ist, werden höchstens maxsplit Trennungen vorgenommen, die rechtesten. Wenn sep nicht angegeben ist oder None ist, ist jede Leerzeichenkette ein Trennzeichen. Abgesehen vom Aufteilen von rechts verhält sich rsplit() wie split(), das unten im Detail beschrieben wird.

str.rstrip(chars=None, /)

Gibt eine Kopie der Zeichenkette zurück, bei der nachgestellte Zeichen entfernt wurden. Das Argument chars ist eine Zeichenkette, die die zu entfernenden Zeichen angibt. Wenn es weggelassen wird oder None ist, werden standardmäßig Leerzeichen entfernt. Das Argument chars ist kein Suffix, sondern es werden alle Kombinationen seiner Werte gestrippt.

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

Siehe str.removesuffix() für eine Methode, die eine einzelne Suffix-Zeichenkette anstelle aller Zeichen eines Satzes entfernt. Zum Beispiel

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

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

Gibt eine Liste der Wörter in der Zeichenkette zurück, wobei sep als Trennzeichen-Zeichenkette verwendet wird. Wenn maxsplit angegeben ist, werden höchstens maxsplit Trennungen vorgenommen (dadurch enthält die Liste höchstens maxsplit+1 Elemente). Wenn maxsplit nicht angegeben ist 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 gelten als Trennzeichen für leere Zeichenketten (z. B. gibt '1,,2'.split(',') die Liste ['1', '', '2'] zurück). Das Argument sep kann mehrere Zeichen als einzelnes Trennzeichen enthalten (um mit mehreren Trennzeichen aufzuteilen, verwenden Sie re.split()). Das Aufteilen einer leeren Zeichenkette 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']

Wenn sep nicht angegeben ist oder None ist, wird ein anderer Aufteilungsalgorithmus angewendet: aufeinanderfolgende Leerzeichen werden als einzelnes Trennzeichen betrachtet, und das Ergebnis enthält keine leeren Zeichen am Anfang oder Ende, wenn die Zeichenkette führende oder nachgestellte Leerzeichen aufweist. Folglich gibt das Aufteilen einer leeren Zeichenkette oder einer Zeichenkette, die nur aus Leerzeichen besteht, mit einem None-Separator [] 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 ist und maxsplit den Wert 0 hat, werden nur führende Gruppen von aufeinanderfolgenden Leerzeichen berücksichtigt.

Zum Beispiel

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

str.splitlines(keepends=False)

Gibt eine Liste der Zeilen in der Zeichenkette zurück, die an Zeilengrenzen aufgeteilt werden. Zeilenumbrüche sind nicht in der resultierenden Liste enthalten, es sei denn, keepends ist angegeben und wahr.

Diese Methode teilt an den folgenden Zeilengrenzen auf. Insbesondere sind die Grenzen eine Obermenge der universellen Zeilenumbrüche.

Darstellung	Beschreibung
\n	Zeilenvorschub
\r	Wagenrücklauf
\r\n	Wagenrücklauf + Zeilenvorschub
\v oder \x0b	Vertikaler Tabulator
\f oder \x0c	Seitenvorschub
\x1c	Dateitrennzeichen
\x1d	Gruppentrennzeichen
\x1e	Datensatz-Trennzeichen
\x85	Nächste Zeile (C1-Steuercode)
\u2028	Zeilentrennzeichen
\u2029	Absatztrennzeichen

Geändert in Version 3.2: \v und \f wurden der Liste der Zeilengrenzen 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 eine Trennzeichen-Zeichenkette sep angegeben ist, gibt diese Methode für die leere Zeichenkette 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 gibt split('\n') Folgendes zurück:

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

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

Gibt True zurück, wenn die Zeichenkette mit prefix beginnt, andernfalls wird False zurückgegeben. prefix kann auch ein Tupel von Präfixen sein, nach denen gesucht werden soll. Mit dem optionalen start wird der Anfang der Zeichenkette an dieser Position geprüft. Mit dem optionalen end wird der Vergleich der Zeichenkette an dieser Position gestoppt.

str.strip(chars=None, /)

Gibt eine Kopie des Strings zurück, bei der führende und nachfolgende Zeichen entfernt wurden. Das Argument chars ist ein String, der die zu entfernende Zeichensatz angibt. Wenn es weggelassen wird oder None ist, werden standardmäßig Leerzeichen entfernt. Das Argument chars ist kein Präfix oder Suffix; vielmehr werden alle Kombinationen seiner Werte gestrippt.

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

Die äußersten führenden und nachfolgenden Werte des Arguments chars werden aus dem String gestrippt. Zeichen werden vom führenden Ende entfernt, bis ein String-Zeichen erreicht wird, das nicht im Zeichensatz von chars enthalten ist. Eine ähnliche Aktion findet am nachfolgenden Ende statt. Zum Beispiel:

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

str.swapcase()

Gibt eine Kopie des Strings zurück, bei der Großbuchstaben in Kleinbuchstaben und umgekehrt umgewandelt wurden. Beachten Sie, dass es nicht unbedingt wahr ist, dass s.swapcase().swapcase() == s.

str.title()

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

Zum Beispiel

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

Der Algorithmus verwendet eine einfache, sprachunabhängige Definition eines Wortes als Gruppen aufeinanderfolgender Buchstaben. Die Definition funktioniert in vielen Kontexten, aber sie bedeutet, dass Apostrophe in Kontraktionen und Possessiven 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 nur nach Leerzeichen aufteilt.

Alternativ kann ein Workaround für Apostrophe mit regulären Ausdrücken 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, bei der jedes Zeichen über die gegebene Übersetzungstabelle abgebildet wurde. Die Tabelle muss ein Objekt sein, das Indizierung über __getitem__() implementiert, typischerweise eine Zuordnung oder Sequenz. Wenn durch eine Unicode-Ordnung (eine Ganzzahl) indiziert, kann das Tabellenobjekt eines der folgenden tun: eine Unicode-Ordnung oder einen String zurückgeben, um das Zeichen auf ein oder mehrere andere Zeichen abzubilden; None zurückgeben, um das Zeichen aus dem Rückgabe-String zu löschen; oder eine LookupError Ausnahme auslösen, um das Zeichen auf sich selbst abzubilden.

Sie können str.maketrans() verwenden, um eine Übersetzungstabelle aus Zeichen-zu-Zeichen-Zuordnungen in verschiedenen Formaten zu erstellen.

Siehe auch das Modul codecs für einen flexibleren Ansatz für benutzerdefinierte Zeichenzuordnungen.

str.upper()

Gibt eine Kopie des Strings zurück, bei der alle umwandelbaren Zeichen [4] in Großbuchstaben umgewandelt wurden. Beachten Sie, dass s.upper().isupper() False sein kann, wenn s nicht umwandelbare Zeichen enthält oder wenn die Unicode-Kategorie des/der resultierenden Zeichen(s) nicht „Lu“ (Letter, uppercase) ist, sondern z. B. „Lt“ (Letter, titlecase).

Der verwendete Algorithmus zur Umwandlung in Großbuchstaben ist in Abschnitt 3.13 „Default Case Folding“ des Unicode-Standards beschrieben.

str.zfill(width, /)

Gibt eine Kopie des Strings zurück, die links mit ASCII-Ziffern '0' aufgefüllt wird, um einen String der Länge width zu erzeugen. Ein führendes Vorzeichen ('+'/'-') wird behandelt, indem die Auffüllung nach dem Vorzeichen eingefügt wird, anstatt davor. 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'

Formatierte Zeichenketten-Literale (f-Strings)

Hinzugefügt in Version 3.6.

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

Geändert in Version 3.8: Hinzugefügt wurde der Debugging-Operator (=).

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

Ein f-String (formal ein formatiertes String-Literal) ist ein String-Literal, dem ein f oder F vorangestellt ist. Dieser Typ von String-Literal ermöglicht das Einbetten beliebiger Python-Ausdrücke in Ersetzungsfelder, die durch geschweifte Klammern ({}) begrenzt sind. Diese Ausdrücke werden zur Laufzeit ausgewertet, ähnlich wie bei str.format(), und in reguläre str-Objekte konvertiert. Zum Beispiel:

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

Es ist auch möglich, einen mehrzeiligen f-String zu verwenden.

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

Eine einzelne öffnende geschweifte Klammer, '{', markiert ein Ersetzungsfeld, das jeden beliebigen Python-Ausdruck enthalten kann.

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

Um eine literale { oder } einzufügen, verwenden Sie eine doppelte Klammer.

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

Funktionen können ebenfalls verwendet werden, und Formatierungsoptionen.

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

Jeder Nicht-String-Ausdruck wird standardmäßig mit str() konvertiert.

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

Um eine explizite Konvertierung zu verwenden, verwenden Sie den ! (Ausrufezeichen)-Operator, gefolgt von einem der gültigen Formate, welche sind:

Konvertierung	Bedeutung
!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?'

Beim Debugging kann es hilfreich sein, sowohl den Ausdruck als auch seinen Wert anzuzeigen, indem das Gleichheitszeichen (=) nach dem Ausdruck verwendet wird. Dies bewahrt Leerzeichen innerhalb der Klammern und kann mit einem Konverter verwendet werden. Standardmäßig verwendet der Debugging-Operator die repr()- (!r) Konvertierung. Zum Beispiel:

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

Nachdem die Ausgabe ausgewertet wurde, kann sie mit einer Formatierungsoption nach einem Doppelpunkt (':') formatiert werden. Nachdem der Ausdruck ausgewertet und möglicherweise in einen String konvertiert wurde, wird die __format__()-Methode des Ergebnisses mit der Formatierungsoption oder dem leeren String aufgerufen, wenn keine Formatierungsoption angegeben ist. Das formatierte Ergebnis wird dann als endgültiger Wert für das Ersetzungsfeld verwendet. Zum Beispiel:

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

printf-Stil String-Formatierung

Hinweis

Die hier beschriebenen Formatierungsoperationen weisen eine Vielzahl von Eigenheiten auf, die zu einer Reihe von häufigen Fehlern führen (wie z. B. dem fehlerhaften Anzeigen von Tupeln und Dictionaries).

Die Verwendung von formatierten String-Literalen, der str.format()-Schnittstelle oder string.Template kann helfen, diese Fehler zu vermeiden. Jede dieser Alternativen bietet ihre eigenen Kompromisse und Vorteile in Bezug auf Einfachheit, Flexibilität und/oder Erweiterbarkeit.

String-Objekte haben eine einzige einzigartige eingebaute Operation: den %-Operator (Modulo). Dies ist auch als String-Formatierungs- oder Interpolations-Operator bekannt. Gegeben format % values (wobei format ein String ist), werden %-Konvertierungsspezifikationen in format durch null oder mehr Elemente von values ersetzt. Der Effekt ist ähnlich wie die Verwendung der sprintf()-Funktion in der C-Sprache. Zum Beispiel:

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

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

Ein Konvertierungsspezifizierer enthält 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 geklammerten Sequenz von Zeichen (z. B. (somename)).

3. Konvertierungsflags (optional), die das Ergebnis einiger Konvertierungstypen beeinflussen.

4. Mindestfeldbreite (optional). Wenn als '*' (Sternchen) angegeben, wird die tatsächliche Breite aus dem nächsten Element des Tupels in values gelesen, und das zu konvertierende Objekt kommt nach der Mindestfeldbreite und der optionalen Präzision.

5. Präzision (optional), gegeben als ein '.' (Punkt) gefolgt von der Präzision. Wenn als '*' (ein Sternchen) angegeben, wird die tatsächliche Präzision aus dem nächsten Element des Tupels in values gelesen, und der zu konvertierende Wert kommt nach der Präzision.

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 geklammerten Mapping-Schlüssel in dieses Dictionary enthalten, der unmittelbar nach dem Zeichen '%' eingefügt wird. Der Mapping-Schlüssel wählt den Wert aus, der aus dem Mapping formatiert werden soll. 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 sie eine sequentielle Parameterliste erfordern).

Die Konvertierungsflag-Zeichen sind:

Flag	Bedeutung
'#'	Der Wert wird die „alternative Form“ verwenden (wo unten definiert).
'0'	Die Konvertierung wird für numerische Werte mit Nullen aufgefüllt.
'-'	Der konvertierte Wert ist linksbündig (überschreibt das '0'-Konvertierungsflag, wenn beide angegeben sind).
' '	(ein Leerzeichen) Ein Leerzeichen sollte vor einer positiven Zahl (oder einem leeren String) stehen, die durch eine vorzeichenbehaftete Konvertierung erzeugt wird.
'+'	Ein Vorzeichen ('+' oder '-') wird der Konvertierung vorangestellt (überschreibt ein „Leerzeichen“-Flag).

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

Die Konvertierungstypen sind:

Konvertierung	Bedeutung	Hinweise
'd'	Vorzeichenbehaftete Ganzzahl dezimal.
'i'	Vorzeichenbehaftete Ganzzahl dezimal.
'o'	Vorzeichenbehafteter Oktalwert.	(1)
'u'	Veralteter Typ – identisch mit 'd'.	(6)
'x'	Vorzeichenbehaftete Hexadezimalzahl (Kleinbuchstaben).	(2)
'X'	Vorzeichenbehaftete Hexadezimalzahl (Großbuchstaben).	(2)
'e'	Gleitkomma-Exponentiendarstellung (Kleinbuchstaben).	(3)
'E'	Gleitkomma-Exponentiendarstellung (Großbuchstaben).	(3)
'f'	Gleitkomma-Dezimaldarstellung.	(3)
'F'	Gleitkomma-Dezimaldarstellung.	(3)
'g'	Gleitkommadarstellung. Verwendet Kleinbuchstaben-Exponentiendarstellung, wenn der Exponent kleiner als -4 oder nicht kleiner als die Präzision ist, andernfalls Dezimaldarstellung.	(4)
'G'	Gleitkommadarstellung. Verwendet Großbuchstaben-Exponentiendarstellung, wenn der Exponent kleiner als -4 oder nicht kleiner als die Präzision ist, andernfalls Dezimaldarstellung.	(4)
'c'	Einzelnes Zeichen (akzeptiert Ganzzahl oder einzelnes Zeichen als String).
'r'	String (konvertiert jedes Python-Objekt mit repr()).	(5)
's'	String (konvertiert jedes Python-Objekt mit str()).	(5)
'a'	String (konvertiert jedes Python-Objekt mit ascii()).	(5)
'%'	Es wird kein Argument konvertiert, das Ergebnis ist ein '%'-Zeichen im Ergebnis.

Hinweise

1. Die alternative Form bewirkt, dass ein führender Oktalspezifizierer ('0o') vor der ersten Ziffer eingefügt wird.

2. Die alternative Form bewirkt, dass ein führendes '0x' oder '0X' (abhängig davon, ob das 'x'- oder 'X'-Format verwendet wurde) vor der ersten Ziffer eingefügt wird.

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

   Die Präzision bestimmt die Anzahl der Ziffern nach dem Dezimalpunkt und ist standardmäßig 6.

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

   Die Präzision bestimmt die Anzahl der signifikanten Ziffern vor und nach dem Dezimalpunkt und ist standardmäßig 6.

5. Wenn die Präzision N ist, 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 ist.

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 zentralen eingebauten Typen für die Manipulation binärer Daten sind bytes und bytearray. Sie werden von memoryview unterstützt, das das Buffer-Protokoll verwendet, um auf den Speicher anderer binärer Objekte zuzugreifen, ohne eine Kopie erstellen zu müssen.

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

Bytes-Objekte

Bytes-Objekte sind unveränderliche Sequenzen von einzelnen 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 in vielerlei anderer Hinsicht eng mit String-Objekten verwandt sind.

class bytes(source=b'')

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

Erstens ist die Syntax für Bytes-Literale weitgehend dieselbe wie für String-Literale, mit der Ausnahme, dass ein b-Präfix hinzugefügt wird.

• Einzelne Anführungszeichen: b'still allows embedded "double" quotes'

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

• Dreifach Anführungszeichen: b'''3 single quotes''', b"""3 double quotes"""

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

Wie bei String-Literalen können Bytes-Literale auch ein r-Präfix verwenden, um die Verarbeitung von Escape-Sequenzen zu deaktivieren. Siehe String- und Bytes-Literale für mehr über die verschiedenen Formen von Bytes-Literalen, einschließlich unterstützter Escape-Sequenzen.

Während Bytes-Literale und 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 ist (Versuche, diese Einschränkung zu verletzen, lösen einen ValueError aus). Dies geschieht bewusst, um hervorzuheben, dass, obwohl viele Binärformate ASCII-basierte Elemente enthalten und nützlich mit textorientierten Algorithmen manipuliert werden können, dies im Allgemeinen nicht für beliebige Binärdaten gilt (die blinde Anwendung von Textverarbeitungsalgorithmen auf Binärdatenformate, die nicht ASCII-kompatibel sind, führt normalerweise zu Datenbeschädigung).

Zusätzlich zu den literalen Formen können Bytes-Objekte auf verschiedene andere Arten erstellt werden:

• Ein mit Nullen gefülltes Bytes-Objekt einer bestimmten Länge: bytes(10)

• Aus einem Iterable von Ganzzahlen: bytes(range(20))

• Kopieren vorhandener Binärdaten über das Buffer-Protokoll: bytes(obj)

Siehe auch die eingebaute Funktion bytes.

Da 2 Hexadezimalziffern genau einem Byte entsprechen, ist die Hexadezimalzahl ein gängiges Format für die Beschreibung binärer Daten. Daher verfügt der Bytes-Typ über eine zusätzliche Klassenmethode zum Lesen von Daten in diesem Format.

classmethod fromhex(string, /)

Diese bytes-Klassenmethode gibt ein Bytes-Objekt zurück, das den angegebenen String dekodiert. Der String muss zwei Hexadezimalziffern pro Byte enthalten, wobei ASCII-Leerzeichen ignoriert werden.

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

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

Geändert in Version 3.14: bytes.fromhex() akzeptiert jetzt ASCII bytes und bytes-ähnliche Objekte als Eingabe.

Eine umgekehrte Konvertierungsfunktion existiert, um ein Bytes-Objekt in seine Hexadezimaldarstellung 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 Sie den Hex-String leichter lesbar machen möchten, können Sie einen einzelnen Trennzeichen-Parameter sep angeben, der in die Ausgabe aufgenommen werden soll. Standardmäßig wird dieses Trennzeichen zwischen jedem Byte eingefügt. Ein zweiter optionaler Parameter bytes_per_sep steuert die Abstände. 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'

Hinzugefügt in Version 3.5.

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

Da Bytes-Objekte Sequenzen von Ganzzahlen sind (ähnlich einem Tupel), wird für ein Bytes-Objekt b b[0] eine Ganzzahl sein, während b[0:1] ein Bytes-Objekt der Länge 1 sein wird. (Dies steht im Gegensatz zu Text-Strings, bei denen sowohl die Indizierung als auch das Slicing einen String der Länge 1 ergeben).

Die Darstellung von Bytes-Objekten verwendet das literale Format (b'...'), da dies oft nützlicher ist als z. B. bytes([46, 46, 46]). Sie können ein Bytes-Objekt jederzeit mit list(b) in eine Liste von Ganzzahlen umwandeln.

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 dedizierte literale Syntax für Bytearray-Objekte, stattdessen werden sie immer durch Aufruf des Konstruktors erstellt:

• Erstellen einer leeren Instanz: bytearray()

• Erstellen einer mit Nullen gefüllten Instanz mit einer gegebenen Länge: bytearray(10)

• Aus einem Iterable von Ganzzahlen: bytearray(range(20))

• Kopieren vorhandener Binärdaten über das Buffer-Protokoll: bytearray(b'Hi!')

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

Siehe auch die eingebaute Funktion bytearray.

Da 2 Hexadezimalziffern genau einem Byte entsprechen, ist die Hexadezimalzahl ein gängiges Format für die Beschreibung binärer Daten. Daher verfügt der Bytearray-Typ über eine zusätzliche Klassenmethode zum Lesen von Daten in diesem Format.

classmethod fromhex(string, /)

Diese bytearray-Klassenmethode gibt ein Bytearray-Objekt zurück, das den angegebenen String dekodiert. Der String muss zwei Hexadezimalziffern pro Byte enthalten, wobei ASCII-Leerzeichen ignoriert werden.

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

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

Geändert in Version 3.14: bytearray.fromhex() akzeptiert jetzt ASCII bytes und bytes-ähnliche Objekte als Eingabe.

Eine umgekehrte Konvertierungsfunktion existiert, um ein Bytearray-Objekt in seine Hexadezimaldarstellung 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'

Hinzugefügt in Version 3.5.

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

resize(size, /)

Ändert die Größe des bytearray, sodass er size Bytes enthält. size muss größer oder gleich 0 sein.

Wenn das bytearray kleiner werden muss, werden Bytes jenseits von size abgeschnitten.

Wenn das bytearray wachsen muss, werden alle neuen Bytes, die jenseits von size liegen, auf Null-Bytes gesetzt.

Dies ist äquivalent zu

>>> def resize(ba, size):
...     if len(ba) > size:
...         del ba[size:]
...     else:
...         ba += b'\0' * (size - len(ba))

Beispiele

>>> shrink = bytearray(b'abc')
>>> shrink.resize(1)
>>> (shrink, len(shrink))
(bytearray(b'a'), 1)
>>> grow = bytearray(b'abc')
>>> grow.resize(5)
>>> (grow, len(grow))
(bytearray(b'abc\x00\x00'), 5)

Hinzugefügt in Version 3.14.

Da Bytearray-Objekte Sequenzen von Ganzzahlen sind (ähnlich einer 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 Textzeichenfolgen, bei denen sowohl Indexierung als auch Slicing eine Zeichenfolge der Länge 1 ergeben)

Die Darstellung von Bytearray-Objekten verwendet das Byte-Literal-Format (bytearray(b'...')), da dies oft nützlicher ist als z. B. bytearray([46, 46, 46]). Sie können ein Bytearray-Objekt immer mit list(b) in eine Liste von Ganzzahlen konvertieren.

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.

Hinweis

Die Methoden für Bytes- und Bytearray-Objekte akzeptieren keine Zeichenfolgen als Argumente, genauso wie die Methoden für Zeichenfolgen keine Bytes als Argumente akzeptieren. Sie müssen zum Beispiel schreiben

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

und

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

Einige Bytes- und Bytearray-Operationen gehen von der Verwendung ASCII-kompatibler Binärformate aus und sollten daher bei der Arbeit mit beliebigen Binärdaten vermieden werden. Diese Einschränkungen werden im Folgenden erläutert.

Hinweis

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

Die folgenden Methoden für Bytes- und Bytearray-Objekte 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. Optionale Argumente start und end werden wie in der Slice-Notation interpretiert.

Die zu suchende Teilsequenz kann ein beliebiges byte-ähnliches 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 auch eine Ganzzahl im Bereich von 0 bis 255 als Teilsequenz.

bytes.removeprefix(prefix, /)

bytearray.removeprefix(prefix, /)

Wenn die Binärdaten mit der Zeichenfolge 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 ein beliebiges byte-ähnliches Objekt sein.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

Hinzugefügt in Version 3.9.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

Wenn die Binärdaten mit der Zeichenfolge suffix enden und dieser 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 zu suchende suffix kann ein beliebiges byte-ähnliches Objekt sein.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

Hinzugefügt in Version 3.9.

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

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

Gibt die Bytes dekodiert als str zurück.

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

errors steuert, wie Dekodierungsfehler behandelt werden. Wenn 'strict' (Standard) gesetzt ist, wird eine UnicodeError-Ausnahme ausgelöst. Andere mögliche Werte sind 'ignore', 'replace' und jeder andere Name, der über codecs.register_error() registriert wurde. Details finden Sie unter Fehlerhandler.

Aus Leistungsgründen wird der Wert von errors erst auf Gültigkeit geprüft, wenn tatsächlich ein Dekodierungsfehler auftritt, der Python Development Mode aktiviert ist oder ein Debug-Build verwendet wird.

Hinweis

Das Übergeben des Arguments encoding an str ermöglicht die direkte Dekodierung jedes byte-ähnlichen Objekts, ohne dass ein temporäres bytes- oder bytearray-Objekt erstellt werden muss.

Geändert in Version 3.1: Unterstützung für Schlüsselwortargumente 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 dem optionalen start wird ab dieser Position getestet. Mit dem optionalen end wird der Vergleich an dieser Position beendet.

Das/die zu suchende(n) Suffix(e) kann/können ein beliebiges byte-ähnliches 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. Optionale 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 ein beliebiges byte-ähnliches Objekt oder eine Ganzzahl im Bereich von 0 bis 255 sein.

Hinweis

Die Methode find() sollte nur verwendet werden, wenn Sie die Position von sub wissen müssen. Um zu prüfen, ob sub eine Teilzeichenfolge ist oder nicht, verwenden Sie den Operator in

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

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

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

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

Ähnlich wie find(), aber löst ValueError aus, wenn die Teilsequenz nicht gefunden wird.

Die zu suchende Teilsequenz kann ein beliebiges byte-ähnliches Objekt oder eine Ganzzahl im Bereich von 0 bis 255 sein.

Geändert in Version 3.3: Akzeptiert 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ärdaten-Sequenzen in iterable darstellt. Ein TypeError wird ausgelöst, wenn sich Werte in iterable 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 Übersetzungstabelle zurück, die für bytes.translate() verwendbar ist und jedes Zeichen in from in das Zeichen an derselben Position in to abbildet. from und to müssen beide byte-ähnliche Objekte sein und die gleiche Länge haben.

Hinzugefügt in Version 3.1.

bytes.partition(sep, /)

bytearray.partition(sep, /)

Teilt die Sequenz beim ersten Vorkommen von sep und gibt ein 3er-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen selbst oder seine Bytearray-Kopie und den Teil nach dem Trennzeichen enthält. Wenn das Trennzeichen nicht gefunden wird, wird ein 3er-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 ein beliebiges byte-ähnliches 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 ihre Ersetzung können ein beliebiges byte-ähnliches Objekt sein.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch 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 in s[start:end] enthalten ist. Optionale Argumente start und end werden wie in der Slice-Notation interpretiert. Gibt -1 bei Fehler zurück.

Die zu suchende Teilsequenz kann ein beliebiges byte-ähnliches Objekt oder eine Ganzzahl im Bereich von 0 bis 255 sein.

Geändert in Version 3.3: Akzeptiert 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 aber ValueError aus, wenn die Teilsequenz sub nicht gefunden wird.

Die zu suchende Teilsequenz kann ein beliebiges byte-ähnliches Objekt oder eine Ganzzahl im Bereich von 0 bis 255 sein.

Geändert in Version 3.3: Akzeptiert 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 3er-Tupel zurück, das den Teil vor dem Trennzeichen, das Trennzeichen selbst oder seine Bytearray-Kopie und den Teil nach dem Trennzeichen enthält. Wenn das Trennzeichen nicht gefunden wird, wird ein 3er-Tupel zurückgegeben, das zwei leere Bytes- oder Bytearray-Objekte gefolgt von einer Kopie der ursprünglichen Sequenz enthält.

Das zu suchende Trennzeichen kann ein beliebiges byte-ähnliches 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 Präfixen sein, nach denen gesucht werden soll. Mit dem optionalen start wird ab dieser Position getestet. Mit dem optionalen end wird der Vergleich an dieser Position beendet.

Das/die zu suchende(n) Präfix(e) kann/können ein beliebiges byte-ähnliches 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.

Sie können die Methode bytes.maketrans() verwenden, um eine Übersetzungstabelle zu erstellen.

Setzen Sie das Argument table auf None für Übersetzungen, die nur 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 jetzt als Schlüsselwortargument unterstützt.

Die folgenden Methoden für Bytes- und Bytearray-Objekte haben Standardverhalten, die die Verwendung von ASCII-kompatiblen Binärformaten annehmen, aber dennoch mit beliebigen Binärdaten verwendet werden können, indem entsprechende Argumente übergeben werden. Beachten Sie, dass alle Bytearray-Methoden in diesem Abschnitt *nicht* direkt ausgeführt werden, sondern neue Objekte erzeugen.

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

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

Gibt eine Kopie des Objekts zurück, zentriert in einer Sequenz der Länge width. Die Auffüllung 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.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

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

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

Gibt eine Kopie des Objekts zurück, linksbündig in einer Sequenz der Länge width. Die Auffüllung 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.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.lstrip(bytes=None, /)

bytearray.lstrip(bytes=None, /)

Gibt eine Kopie der Sequenz zurück, bei der angegebene führende Bytes entfernt wurden. Das Argument bytes ist eine Binärsequenz, die die zu entfernenden Byte-Werte angibt. Wenn es weggelassen oder auf None gesetzt wird, entfernt das Argument bytes standardmäßig ASCII-Leerzeichen. Das Argument bytes ist kein Präfix; stattdessen werden alle Kombinationen seiner Werte gestrippt

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

Die Binärsequenz der zu entfernenden Byte-Werte kann ein beliebiges byte-ähnliches Objekt sein. Siehe removeprefix() für eine Methode, die eine einzelne Präfixzeichenfolge anstelle aller Zeichen eines Satzes entfernt. Zum Beispiel

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.rjust(breite, füllbyte=b' ', /)

bytearray.rjust(breite, füllbyte=b' ', /)

Gibt eine Kopie des Objekts mit einer rechtsbündigen Ausrichtung auf eine Sequenz der Länge breite zurück. Die Auffüllung erfolgt mit dem angegebenen füllbyte (Standard ist ein ASCII-Leerzeichen). Für bytes-Objekte wird die ursprüngliche Sequenz zurückgegeben, wenn breite kleiner oder gleich len(s) ist.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

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

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

Teilt die Binärsequenz in Untersequenzen desselben Typs, wobei sep als Trennzeichen verwendet wird. Wenn maxsplit angegeben ist, werden höchstens maxsplit Trennungen durchgeführt, die rechtesten. Wenn sep nicht angegeben ist oder None ist, ist jede reine ASCII-Leerzeichen enthaltende Untersequenz ein Trennzeichen. Abgesehen vom Aufteilen von rechts verhält sich rsplit() wie split(), was unten im Detail beschrieben wird.

bytes.rstrip(bytes=None, /)

bytearray.rstrip(bytes=None, /)

Gibt eine Kopie der Sequenz mit entfernten angegebenen nachfolgenden Bytes zurück. Das Argument bytes ist eine Binärsequenz, die die zu entfernenden Byte-Werte angibt. Wenn es weggelassen wird oder None ist, werden standardmäßig ASCII-Leerzeichen entfernt. Das Argument bytes ist kein Suffix; stattdessen werden alle Kombinationen seiner Werte gestrippt.

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

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

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

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

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

Teilt die Binärsequenz in Untersequenzen desselben Typs, wobei sep als Trennzeichen verwendet wird. Wenn maxsplit angegeben und nicht negativ ist, werden höchstens maxsplit Trennungen durchgeführt (daher hat die Liste höchstens maxsplit+1 Elemente). Wenn maxsplit nicht angegeben ist oder -1 ist, gibt es keine Begrenzung für die Anzahl der Trennungen (alle möglichen Trennungen werden durchgeführt).

Wenn sep angegeben ist, werden aufeinanderfolgende Trennzeichen nicht gruppiert und gelten als Trennzeichen für leere Untersequenzen (z. B. gibt b'1,,2'.split(b',') [b'1', b'', b'2'] zurück). Das Argument sep kann eine Multibyte-Sequenz als einzelnes Trennzeichen sein. Das Aufteilen einer leeren Sequenz mit einem angegebenen Trennzeichen gibt [b''] oder [bytearray(b'')] zurück, abhängig vom Typ des aufgeteilten Objekts. Das Argument sep kann jedes bytes-ä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']

Wenn sep nicht angegeben ist oder None ist, wird ein anderer Aufteilungsalgorithmus angewendet: Läufe von aufeinanderfolgenden ASCII-Leerzeichen werden als einzelnes Trennzeichen betrachtet, und das Ergebnis enthält keine leeren Zeichen am Anfang oder Ende, wenn die Sequenz führende oder nachfolgende Leerzeichen hat. Folglich gibt das Aufteilen einer leeren Sequenz oder einer Sequenz, die ausschließlich aus ASCII-Leerzeichen besteht, ohne ein 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 mit entfernten angegebenen führenden und nachfolgenden Bytes zurück. Das Argument bytes ist eine Binärsequenz, die die zu entfernenden Byte-Werte angibt. Wenn es weggelassen wird oder None ist, werden standardmäßig ASCII-Leerzeichen entfernt. Das Argument bytes ist kein Präfix oder Suffix; stattdessen werden alle Kombinationen seiner Werte gestrippt.

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

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

Die folgenden Methoden für Bytes- und Bytearray-Objekte setzen die Verwendung von ASCII-kompatiblen Binärformaten voraus und sollten nicht auf beliebige Binärdaten angewendet werden. Beachten Sie, dass alle Bytearray-Methoden in diesem Abschnitt nicht inplace arbeiten, sondern neue Objekte erzeugen.

bytes.capitalize()

bytearray.capitalize()

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

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

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.isalnum()

bytearray.isalnum()

Gibt True zurück, wenn alle Bytes in der Sequenz alphabetische ASCII-Zeichen oder ASCII-Ziffern sind und die Sequenz nicht leer ist, andernfalls False. Alphabetische ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. ASCII-Ziffern sind die Byte-Werte 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 die Byte-Werte 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.

Hinzugefügt in Version 3.7.

bytes.isdigit()

bytearray.isdigit()

Gibt True zurück, wenn alle Bytes in der Sequenz ASCII-Ziffern sind und die Sequenz nicht leer ist, andernfalls False. ASCII-Ziffern sind die Byte-Werte 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 Kleinbuchstaben-ASCII-Zeichen in der Sequenz vorhanden ist und keine Großbuchstaben-ASCII-Zeichen, andernfalls False.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.isspace()

bytearray.isspace()

Gibt True zurück, wenn alle Bytes in der Sequenz ASCII-Leerzeichen sind und die Sequenz nicht leer ist, andernfalls False. ASCII-Leerzeichen sind die Byte-Werte 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 ASCII-Titelcase ist und die Sequenz nicht leer ist, andernfalls False. Siehe bytes.title() für weitere Details zur Definition von „Titelcase“.

Zum Beispiel

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

bytes.isupper()

bytearray.isupper()

Gibt True zurück, wenn mindestens ein Großbuchstaben-ASCII-Buchstabe in der Sequenz vorhanden ist und keine Kleinbuchstaben-ASCII-Zeichen, andernfalls False.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.lower()

bytearray.lower()

Gibt eine Kopie der Sequenz zurück, bei der alle Großbuchstaben-ASCII-Zeichen in ihre entsprechenden Kleinbuchstaben umgewandelt werden.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

Gibt eine Liste der Zeilen in der Binärsequenz zurück, die an ASCII-Zeilenumbrüchen getrennt werden. Diese Methode verwendet den universellen Zeilenumbruch-Ansatz zum Aufteilen von Zeilen. Zeilenumbrüche sind in der resultierenden Liste nicht 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() bei Angabe eines Trennzeichens sep gibt diese Methode eine leere Liste für die leere Zeichenkette 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 Kleinbuchstaben-ASCII-Zeichen in ihre entsprechenden Großbuchstaben und umgekehrt umgewandelt werden.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.title()

bytearray.title()

Gibt eine Titel-Version der Binärsequenz zurück, bei der Wörter mit einem Großbuchstaben-ASCII-Zeichen beginnen und die restlichen Zeichen kleingeschrieben sind. Nicht-Buchstaben-Byte-Werte bleiben unverändert.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Alle anderen Byte-Werte sind nicht alphabetisch.

Der Algorithmus verwendet eine einfache, sprachunabhängige Definition eines Wortes als Gruppen aufeinanderfolgender Buchstaben. Die Definition funktioniert in vielen Kontexten, aber sie bedeutet, dass Apostrophe in Kontraktionen und Possessiven 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"

Eine Umgehungslösung für Apostrophe kann mit regulären Ausdrücken 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."

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.upper()

bytearray.upper()

Gibt eine Kopie der Sequenz zurück, bei der alle Kleinbuchstaben-ASCII-Zeichen in ihre entsprechenden Großbuchstaben umgewandelt werden.

Zum Beispiel

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

Kleinbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'abcdefghijklmnopqrstuvwxyz'. Großbuchstaben-ASCII-Zeichen sind die Byte-Werte in der Sequenz b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

bytes.zfill(breite, /)

bytearray.zfill(breite, /)

Gibt eine Kopie der Sequenz zurück, die links mit ASCII b'0'-Ziffern aufgefüllt wird, um eine Sequenz der Länge breite zu erstellen. Ein führendes Vorzeichen (b'+'/b'-') wird behandelt, indem die Auffüllung nach dem Vorzeichen und nicht davor eingefügt wird. Für bytes-Objekte wird die ursprüngliche Sequenz zurückgegeben, wenn breite kleiner oder gleich len(seq) ist.

Zum Beispiel

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

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

printf-Style Bytes-Formatierung

Hinweis

Die hier beschriebenen Formatierungsoperationen weisen eine Vielzahl von Eigenheiten auf, die zu einer Reihe häufiger Fehler führen (wie z. B. das fehlerhafte Anzeigen von Tupeln und Dictionaries). Wenn der auszugebende Wert ein Tupel oder ein Dictionary sein kann, umschließen Sie ihn in ein Tupel.

Bytes-Objekte (bytes/bytearray) haben eine einzigartige integrierte Operation: den %-Operator (Modulo). Dies ist auch als Bytes-Formatierungs- oder Interpolations-Operator bekannt. Gegeben format % values (wobei format ein Bytes-Objekt ist), werden %-Konvertierungsspezifikationen in format durch null oder mehr Elemente von values ersetzt. Die Wirkung ähnelt der Verwendung von sprintf() in der C-Sprache.

Wenn das rechte Argument ein Tupel ist, muss es genau die Anzahl der Elemente haben, die durch das Format-Bytes-Objekt angegeben sind. Wenn die zu formatierende Einzelwert ein Nicht-Tupel ist, muss er direkt angegeben werden. [5] Andernfalls muss values ein Tupel mit genau der Anzahl der durch das Format-Bytes-Objekt angegebenen Elemente sein, oder ein einzelnes Mapping-Objekt (z. B. ein Dictionary).

Ein Konvertierungsspezifizierer enthält 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 geklammerten Sequenz von Zeichen (z. B. (somename)).

3. Konvertierungsflags (optional), die das Ergebnis einiger Konvertierungstypen beeinflussen.

4. Mindestfeldbreite (optional). Wenn als '*' (Sternchen) angegeben, wird die tatsächliche Breite aus dem nächsten Element des Tupels in values gelesen, und das zu konvertierende Objekt kommt nach der Mindestfeldbreite und der optionalen Präzision.

5. Präzision (optional), gegeben als ein '.' (Punkt) gefolgt von der Präzision. Wenn als '*' (ein Sternchen) angegeben, wird die tatsächliche Präzision aus dem nächsten Element des Tupels in values gelesen, und der zu konvertierende Wert kommt nach der Präzision.

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 in Klammern gesetzten Mapping-Schlüssel zu diesem 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 sie eine sequentielle Parameterliste erfordern).

Die Konvertierungsflag-Zeichen sind:

Flag	Bedeutung
'#'	Der Wert wird die „alternative Form“ verwenden (wo unten definiert).
'0'	Die Konvertierung wird für numerische Werte mit Nullen aufgefüllt.
'-'	Der konvertierte Wert ist linksbündig (überschreibt das '0'-Konvertierungsflag, wenn beide angegeben sind).
' '	(ein Leerzeichen) Ein Leerzeichen sollte vor einer positiven Zahl (oder einem leeren String) stehen, die durch eine vorzeichenbehaftete Konvertierung erzeugt wird.
'+'	Ein Vorzeichen ('+' oder '-') wird der Konvertierung vorangestellt (überschreibt ein „Leerzeichen“-Flag).

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

Die Konvertierungstypen sind:

Konvertierung	Bedeutung	Hinweise
'd'	Vorzeichenbehaftete Ganzzahl dezimal.
'i'	Vorzeichenbehaftete Ganzzahl dezimal.
'o'	Vorzeichenbehafteter Oktalwert.	(1)
'u'	Veralteter Typ – identisch mit 'd'.	(8)
'x'	Vorzeichenbehaftete Hexadezimalzahl (Kleinbuchstaben).	(2)
'X'	Vorzeichenbehaftete Hexadezimalzahl (Großbuchstaben).	(2)
'e'	Gleitkomma-Exponentiendarstellung (Kleinbuchstaben).	(3)
'E'	Gleitkomma-Exponentiendarstellung (Großbuchstaben).	(3)
'f'	Gleitkomma-Dezimaldarstellung.	(3)
'F'	Gleitkomma-Dezimaldarstellung.	(3)
'g'	Gleitkommadarstellung. Verwendet Kleinbuchstaben-Exponentiendarstellung, wenn der Exponent kleiner als -4 oder nicht kleiner als die Präzision ist, andernfalls Dezimaldarstellung.	(4)
'G'	Gleitkommadarstellung. Verwendet Großbuchstaben-Exponentiendarstellung, wenn der Exponent kleiner als -4 oder nicht kleiner als die Präzision ist, andernfalls Dezimaldarstellung.	(4)
'c'	Einzelnes Byte (akzeptiert Integer- oder einzelne Byte-Objekte).
'b'	Bytes (jedes Objekt, das dem Pufferprotokoll folgt oder __bytes__() hat).	(5)
's'	's' ist ein Alias für 'b' und sollte nur für Python2/3-Codebasen verwendet werden.	(6)
'a'	Bytes (konvertiert jedes Python-Objekt unter Verwendung von repr(obj).encode('ascii', 'backslashreplace')).	(5)
'r'	'r' ist ein Alias für 'a' und sollte nur für Python2/3-Codebasen verwendet werden.	(7)
'%'	Es wird kein Argument konvertiert, das Ergebnis ist ein '%'-Zeichen im Ergebnis.

Hinweise

1. Die alternative Form bewirkt, dass ein führender Oktalspezifizierer ('0o') vor der ersten Ziffer eingefügt wird.

2. Die alternative Form bewirkt, dass ein führendes '0x' oder '0X' (abhängig davon, ob das 'x'- oder 'X'-Format verwendet wurde) vor der ersten Ziffer eingefügt wird.

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

   Die Präzision bestimmt die Anzahl der Ziffern nach dem Dezimalpunkt und ist standardmäßig 6.

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

   Die Präzision bestimmt die Anzahl der signifikanten Ziffern vor und nach dem Dezimalpunkt und ist standardmäßig 6.

5. Wenn die Präzision N ist, wird die Ausgabe auf N Zeichen gekürzt.

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

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

8. Siehe PEP 237.

Hinweis

Die Bytearray-Version dieser Methode arbeitet *nicht* direkt, sondern erzeugt immer ein neues Objekt, auch wenn keine Änderungen vorgenommen wurden.

Siehe auch

PEP 461 - Hinzufügen der %-Formatierung zu Bytes und Bytearray

Hinzugefügt in Version 3.5.

Memory Views

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

class memoryview(objekt)

Erstellt eine memoryview, die auf *object* verweist. *object* muss das Pufferprotokoll unterstützen. Eingebaute Objekte, die das Pufferprotokoll unterstützen, sind bytes und bytearray.

Eine memoryview hat die Vorstellung eines *Elements*, das die atomare Speichereinheit ist, die vom ursprünglichen *object* behandelt wird. Für viele einfache Typen wie bytes und bytearray ist ein Element ein einzelnes Byte, aber andere Typen wie array.array können größere Elemente haben.

len(view) ist gleich der Länge von tolist, was die verschachtelte Listenrepräsentation der Ansicht ist. Wenn view.ndim = 1, ist dies gleich der Anzahl der Elemente in der Ansicht.

Geändert in Version 3.12: Wenn view.ndim == 0, löst len(view) jetzt 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, um ihre Daten offenzulegen. Eindimensionale Slices ergeben eine Unteransicht.

>>> 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 Formatbezeichner aus dem struct-Modul 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 Tupel mit einer Ganzzahl indiziert werden. Mehrdimensionale Memoryviews können mit Tupeln von exakt *ndim* Ganzzahlen indiziert werden, wobei *ndim* die Anzahl der Dimensionen ist. Null-dimensionale 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 eindimensionale Slice-Zuweisungen. Größenänderungen sind nicht zulässig.

>>> 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 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 jetzt gesliced werden. Eindimensionale Memoryviews mit Formaten ‚B‘, ‚b‘ oder ‚c‘ sind jetzt hashbar.

Geändert in Version 3.4: Memoryview wird jetzt automatisch bei collections.abc.Sequence registriert.

Geändert in Version 3.5: Memoryviews können jetzt mit einem Tupel von Ganzzahlen indiziert werden.

Geändert in Version 3.14: Memoryview ist jetzt ein generischer Typ.

memoryview hat mehrere Methoden

__eq__(exporter)

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

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

>>> 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 eine der Formatzeichenfolgen nicht vom struct-Modul unterstützt wird, dann werden die Objekte immer als ungleich verglichen (selbst wenn die Formatzeichenfolgen und die 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

Beachten Sie, dass, ähnlich wie bei Gleitkommazahlen, v is w für Memoryview-Objekte *nicht* impliziert v == w.

Geändert in Version 3.3: Frühere Versionen verglichen den Rohspeicher unter Missachtung 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 für die Memoryview.

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

Für nicht zusammenhängende Arrays ist das Ergebnis gleich der abgeflachten Listenrepräsentation, wobei alle Elemente in Bytes konvertiert werden. tobytes() unterstützt alle Formatzeichenfolgen, auch solche, die nicht in der struct-Modul-Syntax enthalten sind.

Hinzugefügt 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 Ansichten gibt ‚A‘ eine exakte Kopie des physischen Speichers zurück. Insbesondere wird die Fortran-Reihenfolge im Speicher beibehalten. Für nicht zusammenhängende Ansichten werden die Daten zuerst in C konvertiert. *order=None* ist dasselbe wie *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'

Hinzugefügt in Version 3.5.

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

tolist()

Gibt die Daten im Puffer als 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 jetzt alle einzelnen Zeichen nativen Formate in der struct-Modul-Syntax 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]

Hinzugefügt in Version 3.8.

release()

Gibt den zugrunde liegenden Puffer frei, der von dem Memoryview-Objekt offengelegt wird. Viele Objekte ergreifen besondere Maßnahmen, wenn eine Ansicht auf sie gehalten wird (z. B. würde ein bytearray eine Größenänderung vorübergehend verbieten); daher ist das Aufrufen von release() praktisch, um diese Einschränkungen zu entfernen (und alle hängenden Ressourcen freizugeben), sobald wie möglich.

Nachdem diese Methode aufgerufen wurde, löst jede weitere Operation auf der Ansicht 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 Kontextmanagementprotokoll kann für einen ähnlichen Effekt verwendet werden, indem die with-Anweisung verwendet wird.

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

Hinzugefügt in Version 3.2.

cast(format, /)

cast(format, shape, /)

Konvertiert eine Memoryview in ein neues Format oder eine neue Form. *shape* ist standardmäßig [byte_length//new_itemsize], was bedeutet, dass die Ergebnisansicht eindimensional ist. Der Rückgabewert ist eine neue Memoryview, aber der Puffer selbst wird nicht kopiert. Unterstützte Konvertierungen sind 1D -> C-contiguous und C-contiguous -> 1D.

Das Zielformat ist auf ein einzelnes Element-Format beschränkt, das in der struct-Syntax angegeben ist. Eines der Formate muss ein Byte-Format sein (‚B‘, ‚b‘ oder ‚c‘). Die Byte-Länge des Ergebnisses muss mit der ursprünglichen Länge übereinstimmen. Beachten Sie, dass alle Byte-Längen vom Betriebssystem abhängen können.

Konvertiere 1D/lang 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

Konvertiere 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')

Konvertiere 1D/bytes in 3D/ints zu 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

Konvertiere 1D/unsigned long zu 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]]

Hinzugefügt in Version 3.3.

Geändert in Version 3.5: Das Quellformat ist beim Konvertieren in eine Byte-Ansicht nicht mehr eingeschränkt.

count(value, /)

Zählt die Anzahl der Vorkommen von *value*.

Hinzugefügt in Version 3.14.

index(value, start=0, stop=sys.maxsize, /)

Gibt den Index des ersten Vorkommens von *value* zurück (ab Index *start* und vor Index *stop*).

Löst einen ValueError aus, wenn *value* nicht gefunden werden kann.

Hinzugefügt in Version 3.14.

Es gibt auch mehrere schreibgeschützte Attribute, die verfügbar sind.

obj

Das zugrunde liegende Objekt der Memoryview.

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

Hinzugefügt 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 verwenden würde. Es ist nicht notwendigerweise 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

Hinzugefügt 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 struct-Moduls) für jedes Element in der Ansicht enthält. Eine Memoryview kann aus Exportern mit beliebigen Formatzeichenfolgen erstellt werden, aber einige Methoden (z. B. tolist()) sind auf native Single-Element-Formate beschränkt.

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

itemsize

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

>>> 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 von Ganzzahlen, dessen Länge ndim entspricht und die Form des Speichers als N-dimensionales Array angibt.

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

strides

Ein Tupel von Ganzzahlen, dessen Länge ndim entspricht und die Größe in Bytes angibt, die zum Zugriff auf jedes Element für jede Dimension des Arrays erforderlich ist.

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

suboffsets

Intern für PIL-ähnliche Arrays verwendet. Der Wert dient nur zu Informationszwecken.

c_contiguous

Ein boolescher Wert, der angibt, ob der Speicher C-contiguous ist.

Hinzugefügt in Version 3.3.

f_contiguous

Ein boolescher Wert, der angibt, ob der Speicher Fortran contiguous ist.

Hinzugefügt in Version 3.3.

contiguous

Ein boolescher Wert, der angibt, ob der Speicher contiguous ist.

Hinzugefügt in Version 3.3.

Set-Typen — set, frozenset

Ein *Set*-Objekt ist eine ungeordnete Sammlung von unterschiedlichen hashbaren Objekten. Häufige Verwendungszwecke sind die Mitgliedschaftsprüfung, das Entfernen von Duplikaten aus einer Sequenz und die Durchführung mathematischer Operationen wie Schnittmenge, Vereinigung, Differenz und symmetrische Differenz. (Weitere Container finden Sie in den eingebauten Klassen dict, list und tuple sowie im Modul collections.)

Wie andere Sammlungen unterstützen Sets x in set, len(set) und for x in set. Da sie ungeordnete Sammlungen sind, zeichnen Sets weder die Elementposition noch die Einfügungsreihenfolge auf. Entsprechend unterstützen Sets keine Indizierung, kein Slicing oder andere sequenzähnliche Verhaltensweisen.

Derzeit gibt es zwei eingebaute Set-Typen: set und frozenset. Der Typ set ist veränderbar – der Inhalt kann mit Methoden wie add() und remove() geändert werden. Da er veränderbar ist, hat er keinen Hashwert und kann weder als Dictionary-Schlüssel noch als Element eines anderen Sets verwendet werden. Der Typ frozenset ist unveränderlich und hashbar – sein Inhalt kann nach der Erstellung nicht mehr geändert werden; er kann daher als Dictionary-Schlüssel oder als Element eines anderen Sets verwendet werden.

Nicht leere Sets (keine frozensets) können durch Platzieren einer kommaseparierten Liste von Elementen in geschweiften Klammern erstellt werden, z. B.: {'jack', 'sjoerd'}, zusätzlich zum set-Konstruktor.

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 eines Sets müssen hashbar sein. Um Sets von Sets darzustellen, müssen die inneren Sets frozenset-Objekte sein. Wenn *iterable* nicht angegeben ist, wird ein neues leeres Set zurückgegeben.

Sets können auf verschiedene Weise erstellt werden.

• Verwenden Sie eine kommaseparierte Liste von Elementen in geschweiften Klammern: {'jack', 'sjoerd'}

• Verwenden Sie eine Set-Comprehension: {c for c in 'abracadabra' if c not in 'abc'}

• Verwenden Sie den Typkonstruktor: set(), set('foobar'), set(['a', 'b', 'foo'])

Instanzen von set und frozenset unterstützen die folgenden Operationen.

len(s)

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

x in s

Prüft, ob *x* in *s* enthalten ist.

x not in s

Prüft, ob *x* nicht in *s* enthalten ist.

isdisjoint(other, /)

Gibt True zurück, wenn das Set keine gemeinsamen Elemente mit *other* hat. Sets sind genau dann disjunkt, wenn ihre Schnittmenge das leere Set ist.

issubset(other, /)

set <= other

Prüft, ob jedes Element im Set in *other* enthalten ist.

set < other

Prüft, ob das Set ein echtes Subset von *other* ist, d. h. set <= other and set != other.

issuperset(other, /)

set >= other

Prüft, ob jedes Element in *other* im Set enthalten ist.

set > other

Prüft, ob das Set ein echtes Superset von *other* ist, d. h. set >= other and set != other.

union(*others)

set | other | ...

Gibt ein neues Set mit Elementen aus dem Set und allen anderen zurück.

intersection(*others)

set & other & ...

Gibt ein neues Set mit Elementen zurück, die im Set und in allen anderen vorhanden sind.

difference(*others)

set - other - ...

Gibt ein neues Set mit Elementen zurück, die im Set, aber nicht in den anderen vorhanden sind.

symmetric_difference(other, /)

set ^ other

Gibt ein neues Set mit Elementen zurück, die entweder im Set oder in *other* vorhanden sind, aber nicht in beiden.

copy()

Gibt eine flache Kopie des Sets zurück.

Beachten Sie, dass die Nicht-Operator-Versionen von union(), intersection(), difference(), symmetric_difference(), issubset() und issuperset() jede beliebige Iterable als Argument akzeptieren. Im Gegensatz dazu erfordern ihre auf Operatoren basierenden Gegenstücke, dass ihre Argumente Sets sind. Dies schließt fehleranfällige Konstruktionen wie set('abc') & 'cbs' zugunsten des besser lesbaren set('abc').intersection('cbs') aus.

Sowohl set als auch frozenset unterstützen Mengenvergleiche. Zwei Mengen sind genau dann gleich, wenn jedes Element jeder Menge im anderen enthalten ist (jede ist ein Subset des anderen). Eine Menge ist kleiner als eine andere Menge, wenn und nur wenn die erste Menge ein echtes Subset der zweiten Menge ist (ist ein Subset, ist aber nicht gleich). Eine Menge ist größer als eine andere Menge, wenn und nur wenn die erste Menge ein echtes Superset der zweiten Menge ist (ist ein Superset, ist aber nicht gleich).

Instanzen von set werden anhand ihrer Elemente mit Instanzen von frozenset verglichen. Zum Beispiel gibt set('abc') == frozenset('abc') True zurück, und das gilt auch für set('abc') in set([frozenset('abc')]).

Die Teilmengen- und Gleichheitsvergleiche verallgemeinern sich nicht zu einer totalen Ordnungsfunktion. Zum Beispiel sind zwei beliebige nichtleere disjunkte Mengen nicht gleich und auch keine Teilmengen voneinander, daher geben *alle* der folgenden Ausdrücke False zurück: a<b, a==b oder a>b.

Da Mengen nur eine partielle Ordnung (Teilmengenbeziehungen) definieren, ist die Ausgabe der Methode list.sort() für Listen von Mengen undefiniert.

Mengen-Elemente müssen, wie Dictionary-Schlüssel, hashbar sein.

Binäre Operationen, die set-Instanzen mit frozenset-Instanzen 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 und die nicht für unveränderliche Instanzen von frozenset gelten.

update(...others)

set |= other | ...

Aktualisiert die Menge, indem Elemente aus allen anderen Mengen hinzugefügt werden.

intersection_update(...others)

set &= other & ...

Aktualisiert die Menge, indem nur Elemente beibehalten werden, die in ihr und in allen anderen Mengen vorhanden sind.

difference_update(...others)

set -= other | ...

Aktualisiert die Menge, indem Elemente entfernt werden, die in anderen Mengen vorhanden sind.

symmetric_difference_update(other, /)

set ^= other

Aktualisiert die Menge, indem nur Elemente beibehalten werden, die in einer der Mengen, aber nicht in beiden vorhanden sind.

add(elem, /)

Fügt das Element elem zur Menge hinzu.

remove(elem, /)

Entfernt das Element elem aus der Menge. Löst eine KeyError aus, wenn elem nicht in der Menge enthalten ist.

discard(elem, /)

Entfernt das Element elem aus der Menge, falls es vorhanden ist.

pop()

Entfernt und gibt ein beliebiges Element aus der Menge zurück. Löst eine KeyError aus, wenn die Menge leer ist.

clear()

Entfernt alle Elemente aus der Menge.

Beachten Sie, dass die nicht-Operator-Versionen der Methoden update(), intersection_update(), difference_update() und symmetric_difference_update() jedes Iterable als Argument akzeptieren.

Beachten Sie, dass das elem-Argument 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 temporär eines erstellt.

Mapping-Typen — dict

Ein Mapping-Objekt ordnet hashbare Werte beliebigen Objekten zu. Mappings sind veränderliche Objekte. Derzeit gibt es nur einen Standard-Mapping-Typ, das *Wörterbuch* (Dictionary). (Für andere Container siehe die integrierten Klassen list, set und tuple und das Modul collections.)

Die Schlüssel eines Wörterbuchs sind *fast* beliebige Werte. Werte, die nicht hashbar sind, d.h. Werte, die Listen, Wörterbücher oder andere veränderliche Typen enthalten (die nach Wert und nicht nach Objektidentität verglichen werden), dürfen nicht als Schlüssel verwendet werden. Werte, die gleich verglichen werden (wie 1, 1.0 und True), können austauschbar verwendet werden, um auf denselben Dictionary-Eintrag zuzugreifen.

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Gibt ein neues Wörterbuch zurück, das aus einem optionalen Positionsargument und einer möglicherweise leeren Menge von Schlüsselwortargumenten initialisiert wird.

Wörterbücher können auf verschiedene Arten erstellt werden.

• Verwenden Sie eine durch Kommas getrennte Liste von Schlüssel: Wert-Paaren in geschweiften Klammern: {'jack': 4098, 'sjoerd': 4127} oder {4098: 'jack', 4127: 'sjoerd'}

• Verwenden Sie eine Dictionary-Comprehension: {}, {x: x ** 2 for x in range(10)}

• Verwenden Sie den Typkonstruktor: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

Wenn kein Positionsargument angegeben wird, wird ein leeres Wörterbuch erstellt. Wenn ein Positionsargument gegeben ist und es eine keys()-Methode definiert, wird ein Wörterbuch erstellt, indem __getitem__() mit jedem von der Methode zurückgegebenen Schlüssel auf das Argument aufgerufen wird. Andernfalls muss das Positionsargument ein Iterable sein. Jedes Element im Iterable muss selbst ein Iterable mit genau zwei Elementen sein. Das erste Element jedes Elements wird zu einem Schlüssel im neuen Wörterbuch, und das zweite Element wird zum entsprechenden Wert. Wenn ein Schlüssel mehrmals vorkommt, wird der letzte Wert für diesen Schlüssel zum entsprechenden Wert im neuen Wörterbuch.

Wenn Schlüsselwortargumente gegeben sind, werden die Schlüsselwortargumente und ihre Werte zum aus dem Positionsargument erstellten Wörterbuch hinzugefügt. Wenn ein hinzuzufügender Schlüssel bereits vorhanden ist, ersetzt der Wert aus dem Schlüsselwortargument den Wert aus dem Positionsargument.

Die Angabe von Schlüsselwortargumenten wie im ersten Beispiel funktioniert nur für Schlüssel, die gültige Python-Bezeichner sind. Andernfalls können beliebige gültige Schlüssel verwendet werden.

Wörterbücher sind gleich, wenn und nur wenn sie dieselben (Schlüssel, Wert)-Paare haben (unabhängig von der Reihenfolge). Ordnungsvergleiche („<“, „<=“, „>=“, „>“) lösen eine TypeError aus. Um die Erstellung und Gleichheit von Wörterbüchern zu veranschaulichen, geben alle folgenden Beispiele ein Wörterbuch 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 Angabe von Schlüsselwortargumenten wie im ersten Beispiel funktioniert nur für Schlüssel, die gültige Python-Bezeichner sind. Andernfalls können beliebige gültige Schlüssel verwendet werden.

Wörterbücher behalten die Einfügungsreihenfolge bei. Beachten Sie, dass die Aktualisierung eines Schlüssels die Reihenfolge nicht beeinflusst. Schlüssel, die nach der Löschung 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 Reihenfolge der Wörterbücher ist garantiert die Einfügungsreihenfolge. Dieses Verhalten war ein Implementierungsdetail von CPython ab 3.6.

Dies sind die Operationen, die Wörterbücher unterstützen (und daher sollten benutzerdefinierte Mapping-Typen sie auch unterstützen)

list(d)

Gibt eine Liste aller Schlüssel zurück, die im Wörterbuch d verwendet werden.

len(d)

Gibt die Anzahl der Elemente im Wörterbuch d zurück.

d[key]

Gibt das Element von d mit dem Schlüssel key zurück. Löst eine KeyError aus, wenn key nicht im Mapping enthalten ist.

Wenn eine Unterklasse von dict die 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 von dem Aufruf __missing__(key) zurückgegeben oder ausgelöst wird. Keine anderen Operationen oder Methoden rufen __missing__() auf. Wenn __missing__() nicht definiert ist, wird eine 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 value für d[key].

del d[key]

Entfernt d[key] aus d. Löst eine KeyError aus, wenn key nicht im Mapping enthalten ist.

key in d

Gibt True zurück, wenn d einen Schlüssel key hat, andernfalls False.

key not in d

Entspricht not key in d.

iter(d)

Gibt einen Iterator über die Schlüssel des Wörterbuchs zurück. Dies ist eine Abkürzung für iter(d.keys()).

clear()

Entfernt alle Elemente aus dem Wörterbuch.

copy()

Gibt eine flache Kopie des Wörterbuchs zurück.

classmethod fromkeys(iterable, value=None, /)

Erstellt ein neues Wörterbuch mit Schlüsseln aus iterable und Werten, die auf value gesetzt sind.

fromkeys() ist eine Klassenmethode, die ein neues Wörterbuch zurückgibt. value ist standardmäßig None. Alle Werte verweisen auf nur eine einzige Instanz, daher ist es im Allgemeinen nicht sinnvoll, dass value ein veränderliches Objekt wie eine leere Liste ist. Um unterschiedliche Werte zu erhalten, verwenden Sie stattdessen eine Dictionary-Comprehension.

get(key, default=None, /)

Gibt den Wert für key zurück, wenn key im Wörterbuch vorhanden ist, andernfalls default. Wenn default nicht angegeben ist, ist es standardmäßig None, so dass diese Methode niemals eine KeyError auslöst.

items()

Gibt eine neue Ansicht der Elemente des Wörterbuchs zurück ((Schlüssel, Wert)-Paare). Siehe die Dokumentation der Ansichtsobjekte.

keys()

Gibt eine neue Ansicht der Schlüssel des Wörterbuchs zurück. Siehe die Dokumentation der Ansichtsobjekte.

pop(key, /)

pop(key, default, /)

Wenn key im Wörterbuch vorhanden ist, wird es entfernt und sein Wert zurückgegeben, andernfalls wird default zurückgegeben. Wenn default nicht angegeben ist und key nicht im Wörterbuch vorhanden ist, wird eine KeyError ausgelöst.

popitem()

Entfernt und gibt ein (Schlüssel, Wert)-Paar aus dem Wörterbuch zurück. Paare werden in LIFO-Reihenfolge zurückgegeben.

popitem() ist nützlich, um destruktiv über ein Wörterbuch zu iterieren, wie es oft in Mengenalgorithmen verwendet wird. Wenn das Wörterbuch leer ist, löst der Aufruf von popitem() eine KeyError aus.

Geändert in Version 3.7: Die LIFO-Reihenfolge ist jetzt 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 Wörterbuchs zurück. Dies ist eine Abkürzung für reversed(d.keys()).

Hinzugefügt in Version 3.8.

setdefault(key, default=None, /)

Wenn key im Wörterbuch vorhanden ist, wird sein Wert zurückgegeben. Wenn nicht, wird key mit dem Wert default eingefügt und default zurückgegeben. default ist standardmäßig None.

update(**kwargs)

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

Aktualisiert das Wörterbuch mit den Schlüssel/Wert-Paaren aus mapping oder iterable und kwargs, wobei vorhandene 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üsselwortargumente angegeben sind, wird das Wörterbuch dann mit diesen Schlüssel/Wert-Paaren aktualisiert: d.update(red=1, blue=2).

values()

Gibt eine neue Ansicht der Werte des Wörterbuchs zurück. Siehe die Dokumentation der Ansichtsobjekte.

Ein Gleichheitsvergleich zwischen einer dict.values()-Ansicht und einer anderen gibt immer False zurück. Dies gilt auch beim Vergleichen von dict.values() mit sich selbst.

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other

Erstellt ein neues Wörterbuch mit den zusammengeführten Schlüsseln und Werten von d und other, die beide Wörterbücher sein müssen. Die Werte von other haben Vorrang, wenn d und other gemeinsame Schlüssel haben.

Hinzugefügt in Version 3.9.

d |= other

Aktualisiert das Wörterbuch d mit Schlüsseln und Werten aus other, das entweder ein Mapping oder ein Iterable von Schlüssel/Wert-Paaren sein kann. Die Werte von other haben Vorrang, wenn d und other gemeinsame Schlüssel haben.

Hinzugefügt in Version 3.9.

Wörterbücher und Dictionary-Ansichten sind umkehrbar.

>>> 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: Wörterbücher sind jetzt umkehrbar.

Siehe auch

types.MappingProxyType kann verwendet werden, um eine schreibgeschützte Ansicht eines dict zu erstellen.

Dictionary-Ansichtsobjekte

Die von dict.keys(), dict.values() und dict.items() zurückgegebenen Objekte sind *Ansichtsobjekte*. Sie bieten eine dynamische Ansicht der Dictionary-Einträge, was bedeutet, dass die Ansicht Änderungen widerspiegelt, wenn sich das Wörterbuch ändert.

Dictionary-Ansichten können iteriert werden, um ihre jeweiligen Daten zu liefern, und unterstützen Mitgliedschaftstests.

len(dictview)

Gibt die Anzahl der Einträge im Wörterbuch zurück.

iter(dictview)

Gibt einen Iterator über die Schlüssel, Werte oder Elemente (repräsentiert als Tupel von (Schlüssel, Wert)) im Wörterbuch zurück.

Schlüssel und Werte werden in Einfügungsreihenfolge durchlaufen. Dies ermöglicht die Erstellung von (Wert, Schlüssel)-Paaren mit 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 Ansichten beim Hinzufügen oder Löschen von Einträgen im Wörterbuch kann eine RuntimeError auslösen oder nicht alle Einträge durchlaufen.

Geändert in Version 3.7: Die Reihenfolge der Wörterbücher ist garantiert die Einfügungsreihenfolge.

x in dictview

Gibt True zurück, wenn x in den Schlüsseln, Werten oder Elementen des zugrunde liegenden Wörterbuchs enthalten ist (im letzteren Fall sollte x ein (Schlüssel, Wert)-Tupel sein).

reversed(dictview)

Gibt einen umgekehrten Iterator über die Schlüssel, Werte oder Elemente des Wörterbuchs zurück. Die Ansicht wird in umgekehrter Einfügungsreihenfolge durchlaufen.

Geändert in Version 3.8: Wörterbuchansichten sind jetzt umkehrbar.

dictview.mapping

Gibt einen types.MappingProxyType zurück, der das ursprüngliche Wörterbuch kapselt, auf das sich die Ansicht bezieht.

Hinzugefügt in Version 3.10.

Schlüsselansichten verhalten sich mengenartig, da ihre Einträge eindeutig und hashbar sind. Elementansichten haben ebenfalls mengenartige Operationen, da die (Schlüssel, Wert)-Paare eindeutig und die Schlüssel hashbar sind. Wenn alle Werte in einer Elementansicht ebenfalls hashbar sind, kann die Elementansicht mit anderen Mengen interoperieren. (Wertansichten werden nicht als mengenartig behandelt, da die Einträge im Allgemeinen nicht eindeutig sind.) Für mengenartige Ansichten sind alle für die abstrakte Basisklasse collections.abc.Set definierten Operationen verfügbar (z. B. ==, < oder ^). Bei der Verwendung von Mengenoperatoren akzeptieren mengenartige Ansichten jedes iterierbare Objekt als anderes Operand, im Gegensatz zu Mengen, die nur Mengen als Eingabe akzeptieren.

Ein Beispiel für die Verwendung von Wörterbuchansichten

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

Kontextmanager-Typen

Pythons with-Anweisung unterstützt das Konzept eines Laufzeitkontexts, der durch einen Kontextmanager definiert wird. Dies wird mithilfe eines Paares von Methoden implementiert, die es benutzerdefinierten Klassen ermöglichen, einen Laufzeitkontext zu definieren, der vor der Ausführung des Anweisungsblocks betreten und beendet wird, wenn die Anweisung endet

contextmanager.__enter__()

Betritt den Laufzeitkontext und gibt entweder dieses Objekt oder ein anderes Objekt zurück, das mit dem Laufzeitkontext verbunden ist. Der von dieser Methode zurückgegebene Wert wird an den Bezeichner in der as-Klausel von with-Anweisungen gebunden, die diesen Kontextmanager verwenden.

Ein Beispiel für einen Kontextmanager, der sich selbst zurückgibt, ist ein Datei-Objekt. Datei-Objekte geben sich selbst von \_\_enter__() zurück, um open() als Kontextausdruck in einer with-Anweisung verwenden zu können.

Ein Beispiel für einen Kontextmanager, der ein verwandtes Objekt zurückgibt, ist der von decimal.localcontext() zurückgegebene. Diese Manager setzen den aktiven Dezimalkontext auf eine Kopie des ursprünglichen Dezimalkontextes und geben dann die Kopie zurück. Dies ermöglicht es, Änderungen am aktuellen Dezimalkontext im Rumpf der with-Anweisung vorzunehmen, ohne den Code außerhalb der with-Anweisung zu beeinträchtigen.

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 Rumpfes der with-Anweisung eine Ausnahme aufgetreten ist, enthalten die Argumente den Ausnahmetyp, den Wert und die Traceback-Informationen. Andernfalls sind alle drei Argumente None.

Die Rückgabe eines wahren Wertes aus dieser Methode führt dazu, dass die with-Anweisung die Ausnahme unterdrückt und die Ausführung mit der Anweisung unmittelbar nach der with-Anweisung fortsetzt. Andernfalls verbreitet sich die Ausnahme, nachdem diese Methode ihre Ausführung beendet hat. Ausnahmen, die während der Ausführung dieser Methode auftreten, ersetzen jede Ausnahme, die im Rumpf der with-Anweisung aufgetreten ist.

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 Kontextmanager zur Unterstützung der einfachen Thread-Synchronisation, des sofortigen Schließens von Dateien oder anderen Objekten und der einfacheren Manipulation des aktiven Dezimal-Arithmetik-Kontextes. Die spezifischen Typen werden über ihre Implementierung des Kontextmanagement-Protokolls hinaus nicht speziell behandelt. Beispiele finden Sie im Modul contextlib.

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 wird, gibt sie einen Kontextmanager zurück, der die notwendigen \_\_enter__() und \_\_exit__() Methoden implementiert, anstatt den Iterator, der von einer undekorierten Generatorfunktion erzeugt wird.

Beachten Sie, dass es in der Python/C-API keine spezielle Zelle für diese Methoden in der Typenstruktur von Python-Objekten gibt. Erweiterungstypen, die diese Methoden definieren möchten, müssen sie als normale, von Python zugängliche Methode bereitstellen. Im Vergleich zum Aufwand für die Einrichtung des Laufzeitkontextes ist der Aufwand für eine einzelne Klassen-Dictionary-Suche vernachlässigbar.

Typ-Annotation-Typen — Generischer Alias, Union

Die Kern-eingebauten Typen für Typ-Annotationen sind Generischer Alias und Union.

Generischer 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. Zum Beispiel ist list[int] ein GenericAlias-Objekt, das durch Subskription der Klasse list mit dem Argument int erstellt wird. GenericAlias-Objekte sind primär für die Verwendung mit Typ-Annotationen bestimmt.

Hinweis

Es ist im Allgemeinen nur möglich, eine Klasse zu subskribieren, wenn die Klasse die spezielle Methode __class_getitem__() implementiert.

Ein GenericAlias-Objekt fungiert als Proxy für einen generischen Typ und implementiert *parametrisierte Generika*.

Für eine Container-Klasse können die an eine Subskription der Klasse übergebenen Argumente die Art(en) der Elemente angeben, die ein Objekt enthält. Zum Beispiel kann set[bytes] in Typ-Annotationen verwendet werden, um eine set zu bezeichnen, in der alle Elemente vom Typ bytes sind.

Für eine Klasse, die __class_getitem__() definiert, aber kein Container ist, geben die an eine Subskription der Klasse übergebenen Argumente oft den Rückgabetyp (die Rückgabetypen) einer oder mehrerer auf einem Objekt definierten Methoden an. Zum Beispiel können reguläre Ausdrücke sowohl für den Datentyp str als auch für den Datentyp bytes verwendet werden

• Wenn x = re.search('foo', 'foo'), 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') (beachten Sie das b für bytes), ist y ebenfalls eine Instanz von re.Match, aber die Rückgabewerte von y.group(0) und y[0] sind 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, die auch verwendet werden kann, um GenericAlias-Objekte direkt zu erstellen.

T[X, Y, ...]

Erstellt einen GenericAlias, der einen Typ T darstellt, der durch die Typen X, Y und weitere, je nach verwendetem T, parametrisiert ist. Zum Beispiel eine Funktion, die eine list erwartet, die float-Elemente enthält

def average(values: list[float]) -> float:
    return sum(values) / len(values)

Ein weiteres Beispiel für Mapping-Objekte, unter Verwendung eines dict, das ein generischer Typ ist und zwei Typ-Parameter erwartet, die den Schlüsseltyp und den Werttyp darstellen. 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 integrierten Funktionen isinstance() und issubclass() akzeptieren keine GenericAlias-Typen für ihr 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-Laufzeit erzwingt keine Typ-Annotationen. Dies gilt auch für generische Typen und ihre Typ-Parameter. Beim Erstellen eines Container-Objekts aus einem GenericAlias werden die Elemente im Container nicht gegen ihren Typ überprüft. Zum Beispiel ist der folgende Code nicht empfohlen, läuft aber ohne Fehler durch

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

Darüber hinaus löschen parametrisierte Generika Typ-Parameter während der Objekterstellung

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

Das Aufrufen von repr() oder str() auf einem Generikum zeigt den parametrisierten Typ

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

Die Methode __getitem__() von generischen Containern 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 Typ-Variablen verwendet werden. Der Index muss so viele Elemente haben, wie es Typ-Variablen-Elemente im \_\_args__-Attribut des GenericAlias-Objekts gibt.

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

Standardmäßige generische Klassen

Die folgenden Standardbibliotheksklassen unterstützen parametrisierte Generika. Diese Liste ist nicht erschöpfend.

• tuple

• Liste

• dict

• Satz

• 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 Generika 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 Tupel (möglicherweise der Länge 1) von generischen Typen, die an die 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 berechnetes Tupel (möglicherweise leer) eindeutiger Typvariablen, die in \_\_args__ gefunden wurden.

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

Hinweis

Ein GenericAlias-Objekt mit typing.ParamSpec-Parametern hat möglicherweise keine korrekten __parameters__ nach der Substitution, da typing.ParamSpec hauptsächlich für die statische Typprüfung gedacht ist.

genericalias.__unpacked__

Ein boolescher Wert, der wahr ist, wenn der Alias mit dem Operator * entpackt wurde (siehe TypeVarTuple).

Hinzugefügt in Version 3.11.

Siehe auch

PEP 484 - Type Hints

Einführung des Frameworks von Python für Typ-Annotationen.

PEP 585 - Type Hinting Generics In Standard Collections

Einführung der Möglichkeit, Standardbibliotheksklassen nativ zu parametrisieren, vorausgesetzt, sie implementieren die spezielle Klassenmethode __class_getitem__().

Generika, benutzerdefinierte Generika und typing.Generic

Dokumentation zur Implementierung generischer Klassen, die zur Laufzeit parametrisiert und von statischen Typprüfern verstanden werden können.

Hinzugefügt in Version 3.9.

Union-Typ

Ein Union-Objekt enthält den Wert der bitweisen OR-Operation (|) auf mehreren Typ-Objekten. Diese Typen sind primär für Typ-Annotationen bestimmt. Der Union-Typ-Ausdruck ermöglicht eine sauberere Syntax für Typ-Hints im Vergleich zur Subskription von typing.Union.

X | Y | ...

Definiert ein Union-Objekt, das die Typen X, Y und so weiter 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

Hinweis

Der |-Operand kann zur Laufzeit nicht verwendet werden, um Unions zu definieren, bei denen ein oder mehrere Mitglieder eine Vorwärtsreferenz sind. Zum Beispiel schlägt int | "Foo", wobei "Foo" eine Referenz auf eine noch nicht definierte Klasse ist, zur Laufzeit fehl. Für Unions, die Vorwärtsreferenzen enthalten, stellen Sie den gesamten Ausdruck als Zeichenkette dar, z. B. "int | Foo".

union_object == other

Union-Objekte können auf Gleichheit mit anderen Union-Objekten getestet werden. Details

• Unionen von Unionen werden abgeflacht

  (int | str) | float == int | str | float
  

• Redundante Typen werden entfernt

  int | str | int == int | str
  

• Beim Vergleichen von Unionen wird die Reihenfolge ignoriert

  int | str == str | int
  

• Es erstellt Instanzen von typing.Union

  int | str == typing.Union[int, str]
  type(int | str) is typing.Union
  

• 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

Jedoch können parametrisierte Generika in Union-Objekten nicht überprü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

Der vom Benutzer exponierte Typ für das Union-Objekt kann von typing.Union abgerufen und für \_\_instance__-Prüfungen verwendet werden

>>> import typing
>>> isinstance(int | str, typing.Union)
True
>>> typing.Union()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'typing.Union' instances

Hinweis

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 sie ü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, der die Syntax X | Y und den Union-Typ vorschlägt.

Hinzugefügt in Version 3.10.

Geändert in Version 3.14: Union-Objekte sind jetzt Instanzen von typing.Union. Zuvor waren sie Instanzen von types.UnionType, das eine Alias für typing.Union bleibt.

Andere eingebaute Typen

Der Interpreter unterstützt mehrere andere Arten von Objekten. Die meisten davon 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 Namen zugreift, der in der Symboltabelle von m definiert ist. Modulattribute können zugewiesen werden. (Beachten Sie, dass die import-Anweisung streng genommen keine Operation auf einem Modulobjekt ist; import foo erfordert kein existierendes Modulobjekt namens foo, sondern erfordert eine (externe) *Definition* für ein Modul namens foo irgendwo.)

Ein spezielles Attribut jedes Moduls ist __dict__. Dies ist das Dictionary, das die Symboltabelle des Moduls enthält. Die Änderung dieses Dictionaries ändert tatsächlich die Symboltabelle des Moduls, aber die direkte Zuweisung zum \_\_dict__-Attribut ist nicht möglich (Sie können m.__dict__['a'] = 1 schreiben, was m.a zu 1 definiert, aber Sie können nicht m.__dict__ = {} schreiben). Die direkte Änderung 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 Instanzen von Klassen

Siehe Objekte, Werte und Typen und Klassendefinitionen hierzu.

Funktionen

Funktionsobjekte werden durch Funktionsdefinitionen erstellt. Die einzige Operation auf einem Funktionsobjekt ist dessen Aufruf: func(argument-list).

Es gibt eigentlich zwei Arten von Funktionsobjekten: eingebaute Funktionen und benutzerdefinierte Funktionen. Beide unterstützen dieselbe Operation (das Aufrufen der Funktion), aber die Implementierung ist unterschiedlich, daher die unterschiedlichen Objekttypen.

Weitere Informationen finden Sie unter Funktionsdefinitionen.

Methoden

Methoden sind Funktionen, die über die Attributnotation aufgerufen werden. Es gibt zwei Arten: eingebaute Methoden (wie z. B. append() bei Listen) und Instanzmethoden von Klassen. Eingebaute Methoden werden mit den Typen beschrieben, die sie unterstützen.

Wenn Sie auf eine Methode (eine in einem Klassen-Namespace definierte Funktion) über eine Instanz zugreifen, erhalten Sie ein spezielles Objekt: ein gebundenes Methode (auch Instanzmethode genannt) Objekt. Beim Aufruf fügt es das Argument self zur Argumentenliste hinzu. Gebundene Methoden haben 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 vollständig ä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 jedoch Methodenattribute 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 zum Auslösen eines AttributeError. Um ein Methodenattribut zu setzen, müssen Sie es explizit auf dem zugrunde liegenden Funktionsobjekt setzen.

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

Weitere Informationen finden Sie unter Instanzmethoden.

Code-Objekte

Code-Objekte werden von der Implementierung verwendet, um "pseudo-kompilierte" ausführbare Python-Codes wie einen Funktionsrumpf darzustellen. Sie unterscheiden sich von Funktionsobjekten, da sie keine Referenz auf ihre globale Ausführungsumgebung enthalten. Code-Objekte werden von der eingebauten Funktion compile() zurückgegeben und können aus Funktionsobjekten über deren Attribut __code__ extrahiert werden. Siehe auch das Modul code.

Der Zugriff auf __code__ löst ein Audit-Ereignis object.__getattr__ mit den Argumenten obj und "__code__" aus.

Ein Code-Objekt kann ausgeführt oder ausgewertet werden, indem es (anstelle einer Quellzeichenkette) an die eingebauten Funktionen exec() oder eval() übergeben wird.

Weitere Informationen finden Sie unter Die Standard-Typhierarchie.

Typ-Objekte

Typ-Objekte repräsentieren die verschiedenen Objekttypen. Der Typ eines Objekts wird über die eingebaute Funktion type() abgerufen. Für Typen gibt es keine speziellen Operationen. Das Standardmodul types definiert Namen für alle Standard-eingebauten Typen.

Typen werden so geschrieben: <class 'int'>.

Das Null-Objekt

Dieses Objekt wird von Funktionen zurückgegeben, die explizit keinen Wert zurückgeben. Es unterstützt keine speziellen Operationen. Es gibt genau ein Null-Objekt, das den Namen None (ein eingebauter Name) trägt. type(None)() erzeugt dasselbe Singleton.

Es wird als None geschrieben.

Das Ellipsis-Objekt

Dieses Objekt wird häufig verwendet, um anzuzeigen, dass etwas weggelassen wurde. Es unterstützt keine speziellen Operationen. Es gibt genau ein Ellipsis-Objekt, das den Namen Ellipsis (ein eingebauter Name) trägt. type(Ellipsis)() erzeugt dasselbe Ellipsis Singleton.

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. für aufrufbare Argumente oder Tuple-Elemente.

• Als Rumpf einer Funktion anstelle einer pass-Anweisung.

• In Drittanbieterbibliotheken, wie z. B. NumPy's Slicing und Striding.

Python verwendet auch drei Punkte auf Arten, die keine Ellipsis-Objekte sind, zum Beispiel

• Doctest's ELLIPSIS, als Muster für fehlenden Inhalt.

• Die Standard-Python-Eingabeaufforderung der interaktiven Shell, wenn eine partielle Eingabe unvollständig ist.

Schließlich verwendet die Python-Dokumentation oft drei Punkte in konventionellem englischem Sprachgebrauch, um weggelassenen Inhalt zu bedeuten, selbst in Codebeispielen, die sie auch als Ellipsis verwenden.

Das NotImplemented-Objekt

Dieses Objekt wird von Vergleichen und binären Operationen zurückgegeben, wenn diese aufgefordert werden, auf Typen zu operieren, die sie nicht unterstützen. Weitere Informationen finden Sie unter Vergleiche. Es gibt genau ein NotImplemented Objekt. type(NotImplemented)() erzeugt die Singleton-Instanz.

Es wird als NotImplemented geschrieben.

Interne Objekte

Informationen hierzu finden Sie unter Die Standard-Typhierarchie. Dort werden Stack-Frame-Objekte, Traceback-Objekte und Slice-Objekte beschrieben.

Spezielle Attribute

Die Implementierung fügt mehreren 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 Generator-Instanz.

definition.__qualname__

Der qualifizierte Name der Klasse, Funktion, Methode, des Deskriptors oder der Generator-Instanz.

Hinzugefügt in Version 3.3.

definition.__module__

Der Name des Moduls, in dem eine Klasse oder Funktion definiert wurde.

definition.__doc__

Die Dokumentationszeichenkette einer Klasse oder Funktion oder None, wenn sie undefiniert ist.

definition.__type_params__

Die Typ-Parameter von generischen Klassen, Funktionen und Typ-Aliassen. Für Klassen und Funktionen, die nicht generisch sind, ist dies ein leeres Tupel.

Hinzugefügt in Version 3.12.

Begrenzung der Integer-String-Konvertierungslänge

CPython hat eine globale Grenze für die Konvertierung zwischen int und str, um Denial-of-Service-Angriffe zu mildern. Diese Grenze gilt *nur* für Dezimal- oder andere nicht-Zweierpotenz-Zahlbasen. Hexadezimal-, Oktal- und Binärkonvertierungen sind unbegrenzt. Die Grenze kann konfiguriert werden.

Der Typ int in CPython ist eine beliebig lange Zahl, die in binärer Form gespeichert wird (bekannt als "bignum"). Es existiert kein Algorithmus, der eine Zeichenkette in eine binäre Ganzzahl oder eine binäre Ganzzahl in eine Zeichenkette in linearer Zeit umwandeln kann, *es sei denn*, die Basis ist eine Zweierpotenz. Selbst die besten bekannten Algorithmen für die Basis 10 haben eine sub-quadratische Komplexität. 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.

Die Grenze gilt für die Anzahl der Ziffernzeichen in der Eingabe- oder Ausgabesequenz, wenn ein nicht-linealer Konvertierungsalgorithmus beteiligt wäre. Unterstriche und das Vorzeichen zählen nicht zur Grenze.

Wenn eine Operation die Grenze ü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.

Die Standardgrenze beträgt 4300 Ziffern, wie in sys.int_info.default_max_str_digits angegeben. Die niedrigste konfigurierbare Grenze 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')
...

Hinzugefügt 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 in Basis 10, z. B. f"{integer}", "{}".format(integer) oder b"%d" % integer.

Die Einschränkungen gelten nicht für Funktionen mit linearem Algorithmus

• int(string, base) mit Basis 2, 4, 8, 16 oder 32.

• int.from_bytes() und int.to_bytes().

• hex(), oct(), bin().

• Format Specification Mini-Language für hexadezimale, oktale und binäre Zahlen.

• str zu float.

• str zu decimal.Decimal.

Konfiguration der Grenze

Vor dem Start von Python können Sie eine Umgebungsvariable oder ein Befehlszeilenflag des Interpreters verwenden, um die Grenze zu konfigurieren

• PYTHONINTMAXSTRDIGITS, z. B. PYTHONINTMAXSTRDIGITS=640 python3, um die Grenze auf 640 zu setzen, oder PYTHONINTMAXSTRDIGITS=0 python3, um die Einschrä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 bedeutet, dass beide nicht gesetzt waren, d. h. bei der Initialisierung wurde ein Wert von sys.int_info.default_max_str_digits verwendet.

Aus Code heraus können Sie die aktuelle Grenze abfragen und eine neue setzen, indem Sie diese sys-APIs verwenden

• sys.get_int_max_str_digits() und sys.set_int_max_str_digits() sind ein Getter und Setter für die interpretatorweite Grenze. Unterinterpreten haben ihre eigene Grenze.

Informationen über den Standardwert und das Minimum finden Sie in sys.int_info

• sys.int_info.default_max_str_digits ist die einkompilierte Standardgrenze.

• sys.int_info.str_digits_check_threshold ist der niedrigste akzeptierte Wert für die Grenze (außer 0, was sie deaktiviert).

Hinzugefügt in Version 3.11.

Vorsicht

Das Setzen einer niedrigen Grenze *kann* zu Problemen führen. Obwohl selten, gibt es Code, der Integer-Konstanten in Dezimalform in seinem Quelltext enthält, die den Mindestschwellenwert überschreiten. Eine Folge des Setzens der Grenze ist, dass Python-Quellcode, der Dezimal-Integer-Literale enthält, die länger als die Grenze sind, beim Parsen einen Fehler verursacht, normalerweise beim Start, beim Import oder sogar bei der Installation - jederzeit, wenn keine aktuelle .pyc-Datei für den Code vorhanden ist. Eine Problemumgehung für Quellcode, der solche großen Konstanten enthält, ist die Umwandlung in die 0x-Hexadezimalform, da diese keine Grenze hat.

Testen Sie Ihre Anwendung gründlich, wenn Sie eine niedrige Grenze verwenden. Stellen Sie sicher, dass Ihre Tests mit der frühzeitig gesetzten Grenze über die Umgebung oder das Flag ausgeführt werden, damit sie beim Start und sogar während jedes Installationsschritts angewendet wird, der Python aufrufen könnte, um .py-Quellen in .pyc-Dateien vorzukompilieren.

Empfohlene Konfiguration

Der Standardwert sys.int_info.default_max_str_digits ist für die meisten Anwendungen angemessen. Wenn Ihre Anwendung eine andere Grenze erfordert, setzen Sie sie von Ihrem Haupteinstiegspunkt aus mit Python-versionsunabhängigem Code, da diese APIs in Sicherheits-Patch-Releases vor Version 3.12 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 Sie sie vollständig deaktivieren müssen, setzen Sie sie auf 0.

Fußnoten

[1]

Zusätzliche Informationen zu diesen speziellen Methoden finden Sie im Python Reference Manual (Grundlegende Anpassung).

[2]

Infolgedessen wird die Liste [1, 2] als gleich [1.0, 2.0] betrachtet, und ähnlich für Tupel.

[3]

Sie müssen dies tun, da der Parser den Typ der Operanden nicht ermitteln kann.

[4] (1,2,3,4)

Zeichen mit Groß-/Kleinschreibung sind solche, deren allgemeine Kategorien-Eigenschaft eine der folgenden ist: "Lu" (Buchstabe, großgeschrieben), "Ll" (Buchstabe, kleingeschrieben) oder "Lt" (Buchstabe, Titelform).

[5] (1,2)

Um nur ein Tupel zu formatieren, sollten Sie daher ein Singleton-Tupel bereitstellen, dessen einziges Element das zu formatierende Tupel ist.