Eingebaute Typen¶

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

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

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

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

Wahrheitswert-Prüfung¶

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

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

Konstanten, die als falsch definiert sind: None und False
Null eines beliebigen numerischen Typs: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
leere Sequenzen und Collections: '', (), [], {}, set(), range(0)

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

Boolesche Operationen — `and`, `or`, `not`¶

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

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

Hinweise:

Dies ist ein Kurzschlussoperator, daher wird das zweite Argument nur ausgewertet, wenn das erste falsch ist.
Dies ist ein Kurzschlussoperator, daher wird das zweite Argument nur ausgewertet, wenn das erste wahr ist.
not hat eine niedrigere Priorität als nicht-boolesche Operatoren, daher wird not a == b als not (a == b) interpretiert, und a == not b ist ein Syntaxfehler.

Vergleiche¶

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

Diese Tabelle fasst die Vergleichsoperationen zusammen:

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

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

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

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

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

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

Numerische Typen — `int`, `float`, `complex`¶

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

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

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

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

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

Operation	Ergebnis	Hinweise	Vollständige Dokumentation
`x + y`	Summe von x und y
`x - y`	Differenz von x und y
`x * y`	Produkt von x und y
`x / y`	Quotient von x und y
`x // y`	abgerundeter Quotient von x und 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 umgewandelt in eine Ganzzahl	(3)(6)	`int()`
`float(x)`	x umgewandelt in eine 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()`	Konjugiert komplexe Zahl zu c
`divmod(x, y)`	Das Paar `(x // y, x % y)`	(2)	`divmod()`
`pow(x, y)`	x hoch y	(5)	`pow()`
`x ** y`	x hoch y	(5)

Hinweise:

Wird auch als Ganzzahldivision bezeichnet. Für Operanden vom Typ int hat das Ergebnis den Typ int. Für Operanden vom Typ float hat das Ergebnis den Typ float. Im Allgemeinen ist das Ergebnis eine ganze Zahl, obwohl der Typ des Ergebnisses nicht zwingend int ist. Das Ergebnis wird immer in Richtung minus unendlich gerundet: 1//2 ist 0, (-1)//2 ist -1, 1//(-2) ist -1 und (-1)//(-2) ist 0.
Nicht für komplexe Zahlen. Verwende stattdessen gegebenenfalls abs() zur Umwandlung in Fließkommazahlen.
Die Umwandlung von float in int schneidet den Nachkommateil ab. Siehe die Funktionen math.floor() und math.ceil() für alternative Umwandlungen.
float akzeptiert auch die Zeichenketten „nan“ und „inf“ mit einem optionalen Präfix „+“ oder „-“ für Not a Number (NaN) sowie positive oder negative Unendlichkeit.
Python definiert pow(0, 0) und 0 ** 0 als 1, wie es für Programmiersprachen üblich ist.
Zu den akzeptierten numerischen Literalen gehören die Ziffern 0 bis 9 oder jedes Unicode-Äquivalent (Codepunkte mit der Eigenschaft Nd).

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

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

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

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

Bitweise Operationen auf Ganzzahl-Typen¶

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

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

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

Operation	Ergebnis	Hinweise
`x \| y`	bitweises oder von x und y	(4)
`x ^ y`	bitweises exklusives oder von x und y	(4)
`x & y`	bitweises 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:

Negative Shift-Werte sind unzulässig und führen dazu, dass ein ValueError ausgelöst wird.
Ein Linksshift um n Bits ist äquivalent zur Multiplikation mit pow(2, n).
Ein Rechtsshift um n Bits ist äquivalent zur Abrundungsdivision (Floor Division) durch pow(2, n).
Die Durchführung dieser Berechnungen mit mindestens einem zusätzlichen Vorzeichen-Erweiterungsbit in einer endlichen Zweierkomplement-Darstellung (einer Arbeitsbitbreite von 1 + max(x.bit_length(), y.bit_length()) oder mehr) reicht aus, um das gleiche Ergebnis zu erhalten, als gäbe es eine unendliche Anzahl von Vorzeichenbits.

Zusätzliche Methoden zu Ganzzahl-Typen¶

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

int.bit_length()¶

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

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

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

Äquivalent zu:

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

Added in version 3.1.

int.bit_count()¶

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

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

Äquivalent zu:

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

Added in version 3.10.

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

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

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

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

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

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

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

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

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

Äquivalent zu:

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

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

Added in version 3.2.

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

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

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

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

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

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

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

Äquivalent zu:

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

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

    return n

Added in version 3.2.

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

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

Added in version 3.8.

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

Added in version 3.12.

Zusätzliche Methoden zu Float¶

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

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

float.is_integer()¶

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

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

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

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

classmethod float.fromhex(s)¶: Klassenmethode, die den durch einen Hexadezimal-String s dargestellten Float zurückgibt. Der String s darf führende und nachgestellte Leerzeichen enthalten.

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

Ein Hexadezimal-String hat die Form:

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

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

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

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

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

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

Hashing von numerischen Typen¶

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

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

Hier sind die Regeln im Detail:

Wenn x = m / n eine nicht-negative rationale Zahl ist und n nicht durch P teilbar ist, definiere hash(x) als m * invmod(n, P) % P, wobei invmod(n, P) das Inverse von n modulo P liefert.
Wenn x = m / n eine nicht-negative rationale Zahl ist und n durch P teilbar ist (m jedoch nicht), dann hat n kein Inverses modulo P und die obige Regel greift nicht; in diesem Fall definiere hash(x) als den konstanten Wert sys.hash_info.inf.
Wenn x = m / n eine negative rationale Zahl ist, definiere hash(x) als -hash(-x). Wenn der resultierende Hash -1 ist, ersetze ihn durch -2.
Die speziellen Werte sys.hash_info.inf und -sys.hash_info.inf werden als Hash-Werte für positive bzw. negative Unendlichkeit verwendet.
Für eine complex-Zahl z werden die Hash-Werte des Real- und Imaginärteils kombiniert, indem hash(z.real) + sys.hash_info.imag * hash(z.imag) berechnet wird, reduziert modulo 2**sys.hash_info.width, sodass das Ergebnis in range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) liegt. Wenn das Ergebnis wiederum -1 ist, wird es durch -2 ersetzt.

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

import sys, math

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

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

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

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

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

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

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

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

Boolescher Typ – `bool`¶

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

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

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

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

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

Iterator-Typen¶

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

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

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

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

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

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

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

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

Generator-Typen¶

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

Sequenztypen – `list`, `tuple`, `range`¶

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

Gemeinsame Sequenzoperationen¶

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

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

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

Operation	Ergebnis	Hinweise
`x in s`	`True`, wenn ein Element von s gleich x ist, andernfalls `False`	(1)
`x not in s`	`False`, wenn ein Element von s gleich x ist, andernfalls `True`	(1)
`s + t`	die Verkettung von s und t	(6)(7)
`s * n` oder `n * s`	äquivalent dazu, s n-mal zu sich selbst zu addieren	(2)(7)
`s[i]`	i-tes Element von s, beginnend bei 0	(3)(8)
`s[i:j]`	Ausschnitt (Slice) von s von i bis j	(3)(4)
`s[i:j:k]`	Ausschnitt (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 werden Tupel und Listen lexikografisch verglichen, indem entsprechende Elemente verglichen werden. Das bedeutet, dass für Gleichheit jedes Element gleich sein muss und die beiden Sequenzen denselben Typ sowie dieselbe Länge haben müssen. (Vollständige Details finden sich unter Vergleiche in der Sprachreferenz.)

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

Hinweise:

Während die Operationen in und not in im allgemeinen Fall nur für einfache Enthaltenseinsprüfungen verwendet werden, nutzen einige spezialisierte Sequenzen (wie str, bytes und bytearray) diese auch für Teilsequenz-Prüfungen:
```
>>> "gg" in "eggs"
True
```
Werte von n kleiner als 0 werden als 0 behandelt (was eine leere Sequenz desselben Typs wie s ergibt). Beachte, dass Elemente in der Sequenz s nicht kopiert werden; sie werden mehrfach referenziert. Dies führt bei Python-Einsteigern häufig zu Missverständnissen; betrachte:
```
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
```
Hierbei ist [[]] eine ein-elementige Liste, die eine leere Liste enthält, sodass alle drei Elemente von [[]] * 3 Referenzen auf diese eine leere Liste sind. Die Änderung eines beliebigen Elements von lists ändert diese einzelne Liste. Auf folgende Weise lässt sich eine Liste aus verschiedenen Listen erstellen:
```
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
```
Weitere Erklärungen finden sich im FAQ-Eintrag How do I create a multidimensional list?.
Wenn i oder j negativ ist, ist der Index relativ zum Ende der Sequenz s: len(s) + i oder len(s) + j wird eingesetzt. Beachte jedoch, dass -0 weiterhin 0 ist.
Der Slice von s von i bis j ist definiert als die Folge der Elemente mit Index k, für die i <= k < j gilt.
- Wird i weggelassen oder ist None, wird 0 verwendet.
- Wird j weggelassen oder ist None, wird len(s) verwendet.
- Ist i oder j kleiner als -len(s), wird 0 verwendet.
- Ist i oder j größer als len(s), wird len(s) verwendet.
- Ist i größer oder gleich j, ist der Slice leer.
Der Ausschnitt von s von i bis j mit Schrittweite k ist definiert als die Sequenz von Elementen mit dem Index x = i + n*k, sodass 0 <= n < (j-i)/k gilt. Mit anderen Worten: Die Indizes sind i, i+k, i+2*k, i+3*k usw., und enden, wenn j erreicht wird (jedoch ohne j einzuschließen). Wenn k positiv ist, werden i und j auf len(s) reduziert, falls sie größer sind. Wenn k negativ ist, werden i und j auf len(s) - 1 reduziert, falls sie größer sind. Wenn i oder j weggelassen werden oder None sind, werden sie zu „End“-Werten (welches Ende hängt vom Vorzeichen von k ab). Beachte: k darf nicht null sein. Wenn k None ist, wird es wie 1 behandelt.
Das Verketten unveränderlicher Sequenzen führt immer zu einem neuen Objekt. Das bedeutet, dass der Aufbau einer Sequenz durch wiederholte Verkettung quadratische Laufzeitkosten bezogen auf die Gesamtlänge der Sequenz verursacht. Um lineare Laufzeitkosten zu erzielen, sollte auf eine der folgenden Alternativen ausgewichen werden:
- beim Verketten von str-Objekten kann eine Liste aufgebaut und am Ende str.join() verwendet werden, oder es wird in eine io.StringIO-Instanz geschrieben und deren Wert nach Abschluss abgerufen
- beim Verketten von bytes-Objekten kann ähnlich bytes.join() oder io.BytesIO verwendet werden, oder es kann eine In-Place-Verkettung mit einem bytearray-Objekt durchgeführt werden. bytearray-Objekte sind veränderlich und besitzen einen effizienten Speicherüberallokations-Mechanismus
- beim Verketten von tuple-Objekten stattdessen eine list erweitern
- für andere Typen die entsprechende Klassendokumentation konsultieren
Einige Sequenztypen (wie range) unterstützen nur Elementsequenzen, die bestimmten Mustern folgen, und unterstützen daher weder Sequenzverkettung noch Wiederholung.
Ein IndexError wird ausgelöst, wenn i außerhalb des Sequenzbereichs liegt.

Sequenzmethoden

Sequenztypen unterstützen außerdem die folgenden Methoden:

sequence.count(value, /)¶: Gibt die Gesamtzahl der Vorkommen von value in sequence zurück.

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

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

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

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

Vorsicht

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

Unveränderliche Sequenztypen¶

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

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

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

Veränderliche Sequenztypen¶

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

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

Operation	Ergebnis	Hinweise
`s[i] = x`	Element i von s wird durch x ersetzt
`del s[i]`	entfernt Element i von s
`s[i:j] = t`	Ausschnitt von s von i bis j wird durch den Inhalt des Iterables t ersetzt
`del s[i:j]`	entfernt die Elemente von `s[i:j]` aus der Liste (entspricht `s[i:j] = []`)
`s[i:j:k] = t`	die Elemente von `s[i:j:k]` werden durch diejenigen 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 identisch mit `s[len(s):len(s)] = t`)
`s *= n`	aktualisiert s mit dem n-mal wiederholten Inhalt	(2)

Hinweise:

Wenn k ungleich 1 ist, muss t dieselbe Länge haben wie der Ausschnitt, den es ersetzt.
Der Wert n ist eine Ganzzahl oder ein Objekt, das __index__() implementiert. Null und negative Werte von n leeren die Sequenz. Elemente in der Sequenz werden nicht kopiert; sie werden mehrfach referenziert, wie für s * n unter Gemeinsame Sequenzoperationen erläutert.

Methoden veränderlicher Sequenzen

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

sequence.append(value, /)¶: Hängt value an das Ende der Sequenz an. Dies entspricht seq[len(seq):len(seq)] = [value].

sequence.clear()¶: Added in version 3.3.

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

sequence.copy()¶: Added in version 3.3.

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

Hinweis

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

sequence.extend(iterable, /)¶: Erweitert sequence um den Inhalt von iterable. Dies entspricht weitgehend seq[len(seq):len(seq)] = iterable.

sequence.insert(index, value, /)¶: Fügt value am angegebenen index in sequence ein. Dies entspricht sequence[index:index] = [value].

sequence.pop(index=-1, /)¶: Ruft das Element am index ab und entfernt es gleichzeitig aus sequence. Standardmäßig wird das letzte Element in sequence entfernt und zurückgegeben.

sequence.remove(value, /)¶

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

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

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

Listen¶

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

class list(iterable=(), /)¶

Listen können auf verschiedene Arten konstruiert werden:

Verwendung eines Paars eckiger Klammern für die leere Liste: []
Verwendung eckiger Klammern mit kommagetrennten Elementen: [a], [a, b, c]
Verwendung einer List-Comprehension: [x for x in iterable]
Verwendung des Typ-Konstruktors: list() oder list(iterable)

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

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

Listen sind hinsichtlich des Typs ihrer Elemente generisch.

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

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

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

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

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

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

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

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

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

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

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

Tupel¶

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

class tuple(iterable=(), /)¶

Tupel können auf verschiedene Arten konstruiert werden:

Verwendung eines Paars runder Klammern für das leere Tupel: ()
Verwendung eines nachgestellten Kommas für ein Tupel mit einem Element(Singleton-Tupel): a, oder (a,)
Trennen von Elementen durch Kommas: a, b, c oder (a, b, c)
Verwendung der eingebauten Funktion tuple(): tuple() oder tuple(iterable)

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

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

Tupel implementieren alle gemeinsamen Sequenzoperationen.

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

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

Ranges¶

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

class range(stop, /)¶

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

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

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

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

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

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

Range-Beispiele:

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

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

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

stop¶: Der Wert des Parameters stop

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

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

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

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

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

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

Geändert in Version 3.3: Definition von ‚==‘ und ‚!=‘, um Range-Objekte basierend auf der von ihnen definierten Wertesequenz zu vergleichen (anstatt auf Basis der Objektidentität).

Die Attribute start, stop und step hinzugefügt.

Siehe auch

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

Textsequenztyp – `str`¶

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

Einfache Anführungszeichen: 'allows embedded "double" quotes'
Doppelte Anführungszeichen: "allows embedded 'single' quotes"
Dreifache Anführungszeichen: '''Three single quotes''', """Three double quotes"""

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

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

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

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

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

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

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

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

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

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

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

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

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

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

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

String-Methoden¶

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

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

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

str.capitalize()¶: Gibt eine Kopie des Strings zurück, bei der das erste Zeichen großgeschrieben und der Rest kleingeschrieben ist.

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

str.casefold()¶

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

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

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

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

Added in version 3.3.

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

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

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

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

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

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

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

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

Gibt den als bytes kodierten String zurück.

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

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

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

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

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

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

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

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

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

Siehe auch startswith() und removesuffix().

str.expandtabs(tabsize=8)¶

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

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

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

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

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

Siehe auch rfind() und index().

Bemerkung

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

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)¶

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

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

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

Bemerkung

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

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

str.format_map(mapping, /)¶

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

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

Added in version 3.2.

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

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

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

Siehe auch rindex().

str.isalnum()¶

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

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

str.isalpha()¶

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

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

Siehe Unicode Properties.

str.isascii()¶

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

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

Added in version 3.7.

str.isdecimal()¶

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

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

str.isdigit()¶

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

Zum Beispiel:

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

Siehe auch isdecimal() und isnumeric().

str.isidentifier()¶

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

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

Beispiel:

>>> from keyword import iskeyword

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

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

str.isnumeric()¶

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

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

Siehe auch isdecimal() und isdigit().

str.isprintable()¶

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

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

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

Zum Beispiel:

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

Siehe auch isspace().

str.isspace()¶

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

Zum Beispiel:

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

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

Siehe auch isprintable().

str.istitle()¶

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

Zum Beispiel:

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

Siehe auch title().

str.isupper()¶

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

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

str.join(iterable, /)¶

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

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

Siehe auch split().

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

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

Zum Beispiel:

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

Siehe auch rjust().

str.lower()¶

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

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

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

str.lstrip(chars=None, /)¶

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

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

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

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

static str.maketrans(dict, /)¶

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

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

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

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

str.partition(sep, /)¶

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

Zum Beispiel:

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

Siehe auch rpartition().

str.removeprefix(prefix, /)¶

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

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

Added in version 3.9.

Siehe auch removesuffix() und startswith().

str.removesuffix(suffix, /)¶

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

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

Added in version 3.9.

Siehe auch removeprefix() und endswith().

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

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

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

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

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

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

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

Siehe auch find() und rindex().

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

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

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

Siehe auch index() und find().

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

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

Zum Beispiel:

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

Siehe auch ljust() und zfill().

str.rpartition(sep, /)¶

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

Zum Beispiel:

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

Siehe auch partition().

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

str.rstrip(chars=None, /)¶

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

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

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

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

Siehe auch strip().

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

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

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

Zum Beispiel:

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

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

Zum Beispiel:

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

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

Zum Beispiel:

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

Formatierte String-Literale (f-Strings)¶

Added in version 3.6.

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

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

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

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

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

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

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

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

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

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

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

Functions can also be used, and format specifiers:

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

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

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

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

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

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

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

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

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

String-Formatierung im `printf`-Stil¶

Bemerkung

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

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

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

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

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

Das Zeichen '%', das den Beginn des Spezifizierers markiert.
Mapping-Schlüssel (optional), bestehend aus einer eingeklammerten Zeichenfolge (zum Beispiel (somename)).
Konvertierungs-Flags (optional), die das Ergebnis bestimmter Konvertierungstypen beeinflussen.
Minimale Feldbreite (optional). Wenn sie als '*' (Sternchen) angegeben ist, wird die tatsächliche Breite aus dem nächsten Element des Tupels in values gelesen, und das zu konvertierende Objekt folgt nach der minimalen Feldbreite und der optionalen Genauigkeit.
Genauigkeit (optional), angegeben als '.' (Punkt) gefolgt von der Genauigkeit. Wenn sie als '*' (Sternchen) angegeben ist, wird die tatsächliche Genauigkeit aus dem nächsten Element des Tupels in values gelesen, und der zu konvertierende Wert folgt nach der Genauigkeit.
Längenmodifikator (optional).
Konvertierungstyp.

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

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

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

Die Konvertierungs-Flag-Zeichen sind:

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

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

Die Konvertierungstypen sind:

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

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

Hinweise:

Die alternative Form bewirkt, dass vor der ersten Ziffer eine führende Oktal-Kennzeichnung ('0o') eingefügt wird.
Die alternative Form bewirkt, dass vor der ersten Ziffer ein führendes '0x' oder '0X' eingefügt wird (je nachdem, ob das Format 'x' oder 'X' verwendet wurde).
Die alternative Form bewirkt, dass das Ergebnis immer einen Dezimalpunkt enthält, selbst wenn keine Ziffern folgen.

Die Genauigkeit bestimmt die Anzahl der Nachkommastellen und ist standardmäßig 6.
Die alternative Form bewirkt, dass das Ergebnis immer einen Dezimalpunkt enthält und nachgestellte Nullen nicht entfernt werden, wie es sonst der Fall wäre.

Die Genauigkeit bestimmt die Anzahl der signifikanten Stellen vor und nach dem Dezimalpunkt und ist standardmäßig 6.
Wenn die Genauigkeit N beträgt, wird die Ausgabe auf N Zeichen gekürzt.
Siehe PEP 237.

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

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

Binäre Sequenztypen – `bytes`, `bytearray`, `memoryview`¶

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

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

Bytes-Objekte¶

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

class bytes(source=b'')¶

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

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

Einfache Anführungszeichen: b'still allows embedded "double" quotes'
Doppelte Anführungszeichen: b"still allows embedded 'single' quotes"
Dreifache Anführungszeichen: b'''3 single quotes''', b"""3 double quotes"""

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

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

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

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

Ein mit Nullen gefülltes Bytes-Objekt einer angegebenen Länge: bytes(10)
Aus einem Iterable von Ganzzahlen: bytes(range(20))
Kopieren vorhandener Binärdaten über das Pufferprotokoll: bytes(obj)

Siehe auch die eingebaute Funktion bytes.

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

classmethod fromhex(string, /)¶

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

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

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

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

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

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

Added in version 3.5.

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

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

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

Bytearray-Objekte¶

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

class bytearray(source=b'')¶

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

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

Erstellen einer leeren Instanz: bytearray()
Erstellen einer mit Nullen gefüllten Instanz mit angegebener Länge: bytearray(10)
Aus einem Iterable von Ganzzahlen: bytearray(range(20))
Kopieren vorhandener Binärdaten über das Pufferprotokoll: bytearray(b'Hi!')

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

Siehe auch die eingebaute Funktion bytearray.

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

classmethod fromhex(string, /)¶

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

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

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

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Added in version 3.5.

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

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

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

Bytes- und Bytearray-Operationen¶

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

Bemerkung

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

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

and:

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

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

Bemerkung

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

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

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

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

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

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

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

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

bytes.removeprefix(prefix, /)¶

bytearray.removeprefix(prefix, /)¶

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

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

Das prefix kann jedes Byte-ähnliche Objekt sein.

Bemerkung

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

Added in version 3.9.

bytes.removesuffix(suffix, /)¶

bytearray.removesuffix(suffix, /)¶

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

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

Das suffix kann jedes Byte-ähnliche Objekt sein.

Bemerkung

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

Added in version 3.9.

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

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

Gibt die als str dekodierten Bytes zurück.

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

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

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

Bemerkung

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

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

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

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

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

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

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

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

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

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

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

Bemerkung

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

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

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

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

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

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

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

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

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

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

Added in version 3.1.

bytes.partition(sep, /)¶

bytearray.partition(sep, /)¶

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

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

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

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

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

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

Bemerkung

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

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

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

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

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

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

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

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

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

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

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

bytes.rpartition(sep, /)¶

bytearray.rpartition(sep, /)¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bemerkung

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

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

Bemerkung

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

bytes.lstrip(bytes=None, /)¶

bytearray.lstrip(bytes=None, /)¶

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

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

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

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

Bemerkung

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

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

Bemerkung

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

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

bytes.rstrip(bytes=None, /)¶

bytearray.rstrip(bytes=None, /)¶

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

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

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

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

Bemerkung

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

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

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

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

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

Zum Beispiel:

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

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

Zum Beispiel:

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

bytes.strip(bytes=None, /)¶

bytearray.strip(bytes=None, /)¶

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

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

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

Bemerkung

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

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

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

Bemerkung

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

bytes.expandtabs(tabsize=8)¶

bytearray.expandtabs(tabsize=8)¶

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

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

Bemerkung

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

bytes.isalnum()¶

bytearray.isalnum()¶

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

Zum Beispiel:

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

bytes.isalpha()¶

bytearray.isalpha()¶

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

Zum Beispiel:

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

bytes.isascii()¶
bytearray.isascii()¶: Gibt True zurück, wenn die Sequenz leer ist oder alle Bytes in der Sequenz ASCII sind, andernfalls False. ASCII-Bytes liegen im Bereich 0–0x7F.

Added in version 3.7.

bytes.isdigit()¶

bytearray.isdigit()¶

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

Zum Beispiel:

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

bytes.islower()¶

bytearray.islower()¶

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

Zum Beispiel:

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

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

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

bytes.istitle()¶

bytearray.istitle()¶

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

Zum Beispiel:

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

bytes.isupper()¶

bytearray.isupper()¶

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

Zum Beispiel:

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

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

bytes.lower()¶

bytearray.lower()¶

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

Zum Beispiel:

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

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

Bemerkung

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

bytes.splitlines(keepends=False)¶

bytearray.splitlines(keepends=False)¶

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

Zum Beispiel:

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

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

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

bytes.swapcase()¶

bytearray.swapcase()¶

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

Zum Beispiel:

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

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

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

Bemerkung

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

bytes.title()¶

bytearray.title()¶

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

Zum Beispiel:

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

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

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

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

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

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

Bemerkung

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

bytes.upper()¶

bytearray.upper()¶

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

Zum Beispiel:

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

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

Bemerkung

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

bytes.zfill(width, /)¶

bytearray.zfill(width, /)¶

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

Zum Beispiel:

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

Bemerkung

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

Bytes-Formatierung im `printf`-Stil¶

Bemerkung

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

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

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

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

Das Zeichen '%', das den Beginn des Spezifizierers markiert.
Mapping-Schlüssel (optional), bestehend aus einer eingeklammerten Zeichenfolge (zum Beispiel (somename)).
Konvertierungs-Flags (optional), die das Ergebnis bestimmter Konvertierungstypen beeinflussen.
Minimale Feldbreite (optional). Wenn sie als '*' (Sternchen) angegeben ist, wird die tatsächliche Breite aus dem nächsten Element des Tupels in values gelesen, und das zu konvertierende Objekt folgt nach der minimalen Feldbreite und der optionalen Genauigkeit.
Genauigkeit (optional), angegeben als '.' (Punkt) gefolgt von der Genauigkeit. Wenn sie als '*' (Sternchen) angegeben ist, wird die tatsächliche Genauigkeit aus dem nächsten Element des Tupels in values gelesen, und der zu konvertierende Wert folgt nach der Genauigkeit.
Längenmodifikator (optional).
Konvertierungstyp.

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

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

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

Die Konvertierungs-Flag-Zeichen sind:

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

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

Die Konvertierungstypen sind:

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

Hinweise:

Die alternative Form bewirkt, dass vor der ersten Ziffer eine führende Oktal-Kennzeichnung ('0o') eingefügt wird.
Die alternative Form bewirkt, dass vor der ersten Ziffer ein führendes '0x' oder '0X' eingefügt wird (je nachdem, ob das Format 'x' oder 'X' verwendet wurde).
Die alternative Form bewirkt, dass das Ergebnis immer einen Dezimalpunkt enthält, selbst wenn keine Ziffern folgen.

Die Genauigkeit bestimmt die Anzahl der Nachkommastellen und ist standardmäßig 6.
Die alternative Form bewirkt, dass das Ergebnis immer einen Dezimalpunkt enthält und nachgestellte Nullen nicht entfernt werden, wie es sonst der Fall wäre.

Die Genauigkeit bestimmt die Anzahl der signifikanten Stellen vor und nach dem Dezimalpunkt und ist standardmäßig 6.
Wenn die Genauigkeit N beträgt, wird die Ausgabe auf N Zeichen gekürzt.
b'%s' ist veraltet, wird jedoch während der 3.x-Reihe nicht entfernt.
b'%r' ist veraltet, wird jedoch während der 3.x-Reihe nicht entfernt.
Siehe PEP 237.

Bemerkung

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

Siehe auch

PEP 461 - Adding % formatting to bytes and bytearray

Added in version 3.5.

Memory-Views¶

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

class memoryview(object)¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

memoryview besitzt mehrere Methoden:

__eq__(exporter)¶

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

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

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

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

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

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

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

tobytes(order='C')¶

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

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

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

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Added in version 3.5.

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

tolist()¶

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

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

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

toreadonly()¶

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

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

Added in version 3.8.

release()¶

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

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

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

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

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

Added in version 3.2.

cast(format, /)¶

cast(format, shape, /)

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

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

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

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

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

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

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

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

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

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

Added in version 3.3.

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

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

obj¶

Das zugrunde liegende Objekt der Memoryview:

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

Added in version 3.3.

nbytes¶

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

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

Mehrdimensionale Arrays:

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

Added in version 3.3.

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

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

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

itemsize¶

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

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

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

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

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

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

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

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

c_contiguous¶: Ein boolescher Wert, der angibt, ob der Speicher C-zusammenhängend ist.

Added in version 3.3.

f_contiguous¶: Ein boolescher Wert, der angibt, ob der Speicher Fortran-zusammenhängend ist.

Added in version 3.3.

contiguous¶: Ein boolescher Wert, der angibt, ob der Speicher zusammenhängend ist.

Added in version 3.3.

Mengen-Typen – `set`, `frozenset`¶

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

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

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

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

Die Konstruktoren für beide Klassen funktionieren gleich:

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

Mengen können auf verschiedene Arten erstellt werden:

Verwendung einer kommagetrennten Liste von Elementen in geschweiften Klammern: {'jack', 'sjoerd'}
Verwendung einer Set-Comprehension: {c for c in 'abracadabra' if c not in 'abc'}
Verwendung des Typ-Konstruktors: set(), set('foobar'), set(['a', 'b', 'foo'])

Instanzen von set und frozenset bieten die folgenden Operationen:

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

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

x not in s: Prüft x auf Nicht-Mitgliedschaft in s.

frozenset.isdisjoint(other, /)¶
set.isdisjoint(other, /)¶: Gibt True zurück, wenn die Menge keine gemeinsamen Elemente mit other hat. Mengen sind genau dann disjunkt, wenn ihre Schnittmenge die leere Menge ist.

frozenset.issubset(other, /)¶
set.issubset(other, /)¶

set <= other: Prüft, ob jedes Element der Menge in other enthalten ist.

set < other: Prüft, ob die Menge eine echte Teilmenge von other ist, das heißt set <= other and set != other.

frozenset.issuperset(other, /)¶
set.issuperset(other, /)¶

set >= other: Prüft, ob jedes Element in other in der Menge enthalten ist.

set > other: Prüft, ob die Menge eine echte Obermenge von other ist, das heißt set >= other and set != other.

frozenset.union(*others)¶
set.union(*others)¶

set | other | ...: Gibt eine neue Menge mit Elementen aus der Menge und allen anderen zurück.

frozenset.intersection(*others)¶
set.intersection(*others)¶

set & other & ...: Gibt eine neue Menge mit Elementen zurück, die der Menge und allen anderen gemeinsam sind.

frozenset.difference(*others)¶
set.difference(*others)¶

set - other - ...: Gibt eine neue Menge mit Elementen der Menge zurück, die nicht in den anderen enthalten sind.

frozenset.symmetric_difference(other, /)¶
set.symmetric_difference(other, /)¶

set ^ other: Gibt eine neue Menge mit Elementen zurück, die entweder in der Menge oder in other, aber nicht in beiden enthalten sind.

frozenset.copy()¶
set.copy()¶: Gibt eine flache Kopie (Shallow Copy) der Menge zurück.

Beachte, dass die Nicht-Operator-Versionen der Methoden union(), intersection(), difference(), symmetric_difference(), issubset() und issuperset() jedes Iterable als Argument akzeptieren. Im Gegensatz dazu erfordern deren operatorbasierte Gegenstücke, dass ihre Argumente Mengen sind. Dies schließt fehleranfällige Konstruktionen wie set('abc') & 'cbs' zugunsten des lesbareren set('abc').intersection('cbs') aus.

Sowohl set als auch frozenset unterstützen Menge-zu-Menge-Vergleiche. Zwei Mengen sind genau dann gleich, wenn jedes Element jeder Menge in der jeweils anderen enthalten ist (jede eine Teilmenge der anderen ist). Eine Menge ist kleiner als eine andere Menge genau dann, wenn die erste Menge eine echte Teilmenge der zweiten Menge ist (eine Teilmenge ist, aber nicht gleich ist). Eine Menge ist größer als eine andere Menge genau dann, wenn die erste Menge eine echte Obermenge der zweiten Menge ist (eine Obermenge ist, aber nicht gleich ist).

Instanzen von set werden basierend auf ihren Elementen mit Instanzen von frozenset verglichen. Zum Beispiel gibt set('abc') == frozenset('abc') True zurück, ebenso wie set('abc') in set([frozenset('abc')]).

Die Teilmengen- und Gleichheitsvergleiche lassen sich nicht zu einer totalen Ordnungsfunktion verallgemeinern. Beispielsweise sind zwei beliebige nicht-leere, disjunkte Mengen weder gleich noch Teilmengen voneinander, sodass alle der folgenden Vergleiche False zurückgeben: a<b, a==b oder a>b.

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

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

Binäre Operationen, die set-Instanzen mit frozenset mischen, geben den Typ des ersten Operanden zurück. Zum Beispiel gibt frozenset('ab') | set('bc') eine Instanz von frozenset zurück.

Die folgende Tabelle listet Operationen auf, die für set verfügbar sind, jedoch nicht für unveränderliche Instanzen von frozenset gelten:

set.update(*others)¶

set |= other | ...: Aktualisiert die Menge und fügt Elemente aus allen anderen hinzu.

set.intersection_update(*others)¶

set &= other & ...: Aktualisiert die Menge und behält nur Elemente bei, die sowohl in ihr als auch in allen anderen vorkommen.

set.difference_update(*others)¶

set -= other | ...: Aktualisiert die Menge und entfernt Elemente, die in den anderen vorkommen.

set.symmetric_difference_update(other, /)¶

set ^= other: Aktualisiert die Menge und behält nur Elemente bei, die in einer der beiden Mengen vorkommen, jedoch nicht in beiden.

set.add(elem, /)¶: Fügt das Element elem zur Menge hinzu.

set.remove(elem, /)¶: Entfernt das Element elem aus der Menge. Löst einen KeyError aus, wenn elem nicht in der Menge enthalten ist.

set.discard(elem, /)¶: Entfernt das Element elem aus der Menge, falls es vorhanden ist.

set.pop()¶: Entfernt ein beliebiges Element aus der Menge und gibt es zurück. Löst einen KeyError aus, wenn die Menge leer ist.

set.clear()¶: Entfernt alle Elemente aus der Menge.

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

Beachte, dass das Argument elem für die Methoden __contains__(), remove() und discard() eine Menge sein kann. Um die Suche nach einem äquivalenten Frozenset zu unterstützen, wird aus elem vorübergehend ein solches erstellt.

Sets und Frozensets sind über einen Typparameter generisch, der den Typ ihrer Elemente angibt.

Mapping-Typen – `dict`¶

A mapping object maps hashable values to arbitrary objects. Mappings are mutable objects. There is currently only one standard mapping type, the dictionary. (For other containers see the built-in list, set, and tuple classes, and the collections module.)

Die Schlüssel eines Dictionaries sind fast beliebige Werte. Werte, die nicht hashbar sind – also Werte, die Listen, Dictionaries oder andere veränderliche Typen enthalten (die nach Wert statt nach Objektidentität verglichen werden) –, dürfen nicht als Schlüssel verwendet werden. Werte, die als gleich gelten (wie 1, 1.0 und True), können austauschbar verwendet werden, um denselben Dictionary-Eintrag zu indizieren.

class dict(**kwargs)¶

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Gibt ein neues Dictionary zurück, initialisiert aus einem optionalen Positionsargument und einer möglicherweise leeren Menge von Schlüsselwort-Argumenten.

Dictionaries können auf verschiedene Arten erstellt werden:

Verwendung einer kommagetrennten Liste von key: value-Paaren in geschweiften Klammern: {'jack': 4098, 'sjoerd': 4127} oder {4098: 'jack', 4127: 'sjoerd'}
Verwendung einer Dict-Comprehension: {}, {x: x ** 2 for x in range(10)}
Verwendung des Typ-Konstruktors: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

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

Wenn Schlüsselwort-Argumente angegeben sind, werden diese und ihre Werte zu dem aus dem Positionsargument erstellten Dictionary hinzugefügt. Wenn ein hinzuzufügender Schlüssel bereits vorhanden ist, ersetzt der Wert aus dem Schlüsselwort-Argument den Wert aus dem Positionsargument.

Dictionaries sind genau dann gleich, wenn sie dieselben (key, value)-Paare enthalten (unabhängig von der Reihenfolge). Ordnungsvergleiche (‚<‘, ‚<=‘, ‚>=‘, ‚>‘) lösen einen TypeError aus. Zur Veranschaulichung der Dictionary-Erstellung und -Gleichheit geben die folgenden Beispiele alle ein Dictionary zurück, das gleich {"one": 1, "two": 2, "three": 3} ist:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

Die Übergabe von Schlüsselwort-Argumenten wie im ersten Beispiel funktioniert nur für Schlüssel, die gültige Python-Bezeichner sind. Andernfalls können alle gültigen Schlüssel verwendet werden.

Dictionaries behalten die Einfügereihenfolge bei. Beachte, dass das Aktualisieren eines Schlüssels die Reihenfolge nicht beeinflusst. Schlüssel, die nach dem Löschen hinzugefügt werden, werden am Ende eingefügt.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

Geändert in Version 3.7: Die Dictionary-Reihenfolge ist garantiert die Einfügereihenfolge. Dieses Verhalten war ab 3.6 ein Implementierungsdetail von CPython.

Dictionaries sind über zwei Typparameter generisch, was (jeweils) die Typen der Schlüssel und Werte des Dictionarys angeben.

Dies sind die Operationen, die Dictionaries unterstützen (und die daher auch benutzerdefinierte Mapping-Typen unterstützen sollten):

list(d): Gibt eine Liste aller im Dictionary d verwendeten Schlüssel zurück.

len(d): Gibt die Anzahl der Elemente im Dictionary d zurück.

d[key]

Gibt das Element von d mit dem Schlüssel key zurück. Löst einen KeyError aus, wenn key nicht in der Map vorhanden ist.

Wenn eine Unterklasse von dict eine Methode __missing__() definiert und key nicht vorhanden ist, ruft die Operation d[key] diese Methode mit dem Schlüssel key als Argument auf. Die Operation d[key] gibt dann zurück oder löst aus, was immer der Aufruf __missing__(key) zurückgibt oder auslöst. Keine anderen Operationen oder Methoden rufen __missing__() auf. Wenn __missing__() nicht definiert ist, wird ein KeyError ausgelöst. __missing__() muss eine Methode sein; es kann keine Instanzvariable sein:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
...
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

Das obige Beispiel zeigt einen Teil der Implementierung von collections.Counter. Eine andere __missing__()-Methode wird von collections.defaultdict verwendet.

d[key] = value: Setzt d[key] auf value.

del d[key]: Entfernt d[key] aus d. Löst einen KeyError aus, wenn key nicht in der Map vorhanden ist.

key in d: Gibt True zurück, wenn d einen Schlüssel key besitzt, andernfalls False.

key not in d: Äquivalent zu not key in d.

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

clear()¶: Entfernt alle Elemente aus dem Dictionary.

copy()¶: Gibt eine flache Kopie des Dictionaries zurück.

classmethod fromkeys(iterable, value=None, /)¶

Erstellt ein neues Dictionary mit Schlüsseln aus iterable und auf value gesetzten Werten.

fromkeys() ist eine Klassenmethode, die ein neues Dictionary zurückgibt. value ist standardmäßig None. Alle Werte verweisen auf dieselbe Instanz, daher ist es im Allgemeinen nicht sinnvoll, wenn value ein veränderliches Objekt wie eine leere Liste ist. Um verschiedene Werte zu erhalten, verwende stattdessen eine Dict-Comprehension.

get(key, default=None, /)¶: Gibt den Wert für key zurück, wenn key im Dictionary vorhanden ist, andernfalls default. Wenn default nicht angegeben ist, ist der Standardwert None, sodass diese Methode niemals einen KeyError auslöst.

items()¶: Gibt einen neuen View der Elemente des Dictionaries ((key, value)-Paare) zurück. Siehe die Dokumentation zu View-Objekten.

keys()¶: Gibt einen neuen View der Schlüssel des Dictionaries zurück. Siehe die Dokumentation zu View-Objekten.

pop(key, /)¶
pop(key, default, /): Wenn key im Dictionary vorhanden ist, entferne ihn und gib seinen Wert zurück, andernfalls gib default zurück. Wenn default nicht angegeben ist und key nicht im Dictionary vorhanden ist, wird ein KeyError ausgelöst.

popitem()¶

Entfernt ein (key, value)-Paar aus dem Dictionary und gibt es zurück. Paare werden in LIFO-Reihenfolge zurückgegeben.

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

Geändert in Version 3.7: Die LIFO-Reihenfolge ist nun garantiert. In früheren Versionen gab popitem() ein beliebiges Schlüssel/Wert-Paar zurück.

reversed(d): Gibt einen umgekehrten Iterator über die Schlüssel des Dictionaries zurück. Dies ist eine Abkürzung für reversed(d.keys()).

Added in version 3.8.

setdefault(key, default=None, /)¶: Wenn key im Dictionary vorhanden ist, gib seinen Wert zurück. Wenn nicht, füge key mit einem Wert von default ein und gib default zurück. default ist standardmäßig None.

update(**kwargs)¶

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

Aktualisiert das Dictionary mit den Schlüssel/Wert-Paaren aus mapping oder iterable und kwargs, wobei bestehende Schlüssel überschrieben werden. Gibt None zurück.

update() akzeptiert entweder ein anderes Objekt mit einer keys()-Methode (in diesem Fall wird __getitem__() mit jedem von der Methode zurückgegebenen Schlüssel aufgerufen) oder ein Iterable von Schlüssel/Wert-Paaren (als Tupel oder andere Iterables der Länge zwei). Wenn Schlüsselwort-Argumente angegeben sind, wird das Dictionary mit diesen Schlüssel/Wert-Paaren aktualisiert: d.update(red=1, blue=2).

values()¶

Gibt einen neuen View der Werte des Dictionaries zurück. Siehe die Dokumentation zu View-Objekten.

Ein Gleichheitsvergleich zwischen einem dict.values()-View und einem anderen gibt immer False zurück. Dies gilt auch für den Vergleich von dict.values() mit sich selbst:

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

d | other: Erstellt ein neues Dictionary mit den zusammengeführten Schlüsseln und Werten von d und other, die beide Dictionaries sein müssen. Die Werte von other haben Vorrang, wenn d und other gemeinsame Schlüssel besitzen.

Added in version 3.9.

d |= other: Aktualisiert das Dictionary d mit Schlüsseln und Werten aus other, was entweder ein Mapping oder ein Iterierbares von Schlüssel/Wert-Paaren sein kann. Die Werte von other haben Vorrang, wenn d und other gemeinsame Schlüssel besitzen.

Added in version 3.9.

Dictionaries und Dictionary-Views sind umkehrbar (reversible).

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

Geändert in Version 3.8: Dictionaries sind nun umkehrbar.

Siehe auch

types.MappingProxyType kann verwendet werden, um einen schreibgeschützten View eines dict zu erstellen.

Dictionary-View-Objekte¶

Die von dict.keys(), dict.values() und dict.items() zurückgegebenen Objekte sind View-Objekte. Sie bieten einen dynamischen View auf die Einträge des Dictionaries, was bedeutet, dass der View Änderungen am Dictionary widerspiegelt.

Über Dictionary-Views kann iteriert werden, um ihre jeweiligen Daten abzurufen, und sie unterstützen Mitgliedschaftstests:

len(dictview): Gibt die Anzahl der Einträge im Dictionary zurück.

iter(dictview)

Gibt einen Iterator über die Schlüssel, Werte oder Elemente (dargestellt als Tupel von (key, value)) im Dictionary zurück.

Schlüssel und Werte werden in der Einfügereihenfolge durchlaufen. Dies ermöglicht die Erstellung von (value, key)-Paaren mittels zip(): pairs = zip(d.values(), d.keys()). Eine andere Möglichkeit, dieselbe Liste zu erstellen, ist pairs = [(v, k) for (k, v) in d.items()].

Das Iterieren über Views, während Einträge im Dictionary hinzugefügt oder gelöscht werden, kann einen RuntimeError auslösen oder dazu führen, dass nicht alle Einträge durchlaufen werden.

Geändert in Version 3.7: Die Dictionary-Reihenfolge ist garantiert die Einfügereihenfolge.

x in dictview: Gibt True zurück, wenn x in den Schlüsseln, Werten oder Elementen des zugrunde liegenden Dictionaries enthalten ist (im letzteren Fall sollte x ein (key, value)-Tupel sein).

reversed(dictview): Gibt einen umgekehrten Iterator über die Schlüssel, Werte oder Elemente des Dictionaries zurück. Der View wird in umgekehrter Reihenfolge der Einfügung durchlaufen.

Geändert in Version 3.8: Dictionary-Views sind nun umkehrbar.

dictview.mapping: Gibt einen types.MappingProxyType zurück, der das ursprüngliche Dictionary umhüllt, auf das sich der View bezieht.

Added in version 3.10.

Keys-Views sind mengenartig, da ihre Einträge eindeutig und hashbar sind. Items-Views besitzen ebenfalls mengenartige Operationen, da die (key, value)-Paare eindeutig sind und die Schlüssel hashbar sind. Wenn alle Werte in einem Items-View ebenfalls hashbar sind, kann der Items-View mit anderen Mengen interagieren. (Values-Views werden nicht als mengenartig behandelt, da die Einträge im Allgemeinen nicht eindeutig sind.) Für mengenartige Views sind alle Operationen verfügbar, die für die abstrakte Basisklasse collections.abc.Set definiert sind (zum Beispiel ==, < oder ^). Bei der Verwendung von Mengenoperatoren akzeptieren mengenartige Views jedes Iterable als weiteren Operanden, im Gegensatz zu Mengen, die nur Mengen als Eingabe akzeptieren.

Ein Beispiel für die Verwendung von Dictionary-Views:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
...
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
True
>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
True

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

Kontext-Manager-Typen¶

Pythons with-Anweisung unterstützt das Konzept eines Laufzeitkontexts, der durch einen Kontext-Manager definiert wird. Dies wird mittels eines Methodenpaars implementiert, das es benutzerdefinierten Klassen ermöglicht, einen Laufzeitkontext zu definieren, der vor der Ausführung des Anweisungskörpers betreten und beim Beenden der Anweisung verlassen wird:

contextmanager.__enter__()¶

Betritt den Laufzeitkontext und gibt entweder dieses Objekt oder ein anderes, auf den Laufzeitkontext bezogenes Objekt zurück. Der von dieser Methode zurückgegebene Wert wird an den Bezeichner in der as-Klausel von with-Anweisungen gebunden, die diesen Kontext-Manager verwenden.

Ein Beispiel für einen Kontext-Manager, der sich selbst zurückgibt, ist ein Dateiobjekt. Dateiobjekte geben sich selbst aus __enter__() zurück, damit open() als Kontextausdruck in einer with-Anweisung verwendet werden kann.

Ein Beispiel für einen Kontext-Manager, der ein zugehöriges Objekt zurückgibt, ist der von decimal.localcontext() zurückgegebene. Diese Manager setzen den aktiven Dezimalkontext auf eine Kopie des ursprünglichen Dezimalkontexts und geben dann die Kopie zurück. Dies ermöglicht Änderungen am aktuellen Dezimalkontext im Körper der with-Anweisung, ohne Code außerhalb der with-Anweisung zu beeinflussen.

contextmanager.__exit__(exc_type, exc_val, exc_tb)¶

Verlässt den Laufzeitkontext und gibt ein boolesches Flag zurück, das angibt, ob eine aufgetretene Ausnahme unterdrückt werden soll. Wenn während der Ausführung des Körpers der with-Anweisung eine Ausnahme aufgetreten ist, enthalten die Argumente den Ausnahmetyp, den Wert und Traceback-Informationen. Andernfalls sind alle drei Argumente None.

Die Rückgabe eines wahren Wertes aus dieser Methode bewirkt, dass die with-Anweisung die Ausnahme unterdrückt und die Ausführung mit der Anweisung unmittelbar nach der with-Anweisung fortsetzt. Andernfalls wird die Ausnahme nach Beendigung dieser Methode weiter propagiert.

Wenn diese Methode während der Behandlung einer früheren Ausnahme aus dem with-Block eine Ausnahme auslöst, wird die neue Ausnahme weitergegeben, und die ursprüngliche Ausnahme wird in ihrem Attribut __context__ gespeichert.

Die übergebene Ausnahme sollte niemals explizit erneut ausgelöst werden – stattdessen sollte diese Methode einen falschen Wert zurückgeben, um anzuzeigen, dass die Methode erfolgreich abgeschlossen wurde und die ausgelöste Ausnahme nicht unterdrücken möchte. Dies ermöglicht es dem Kontextmanagement-Code, leicht zu erkennen, ob eine __exit__()-Methode tatsächlich fehlgeschlagen ist oder nicht.

Python definiert mehrere Kontext-Manager, um eine einfache Thread-Synchronisation, das zeitnahe Schließen von Dateien oder anderen Objekten und eine einfachere Manipulation des aktiven Dezimalarithmetik-Kontexts zu unterstützen. Die spezifischen Typen werden über ihre Implementierung des Kontextmanagement-Protokolls hinaus nicht besonders behandelt. Siehe das Modul contextlib für einige Beispiele.

Pythons Generatoren und der Dekorator contextlib.contextmanager bieten eine bequeme Möglichkeit, diese Protokolle zu implementieren. Wenn eine Generatorfunktion mit dem Dekorator contextlib.contextmanager dekoriert ist, gibt sie einen Kontext-Manager zurück, der die notwendigen Methoden __enter__() und __exit__() implementiert, anstelle des Iterators, der von einer undekorierten Generatorfunktion erzeugt wird.

Beachte, dass es in der Typstruktur für Python-Objekte in der Python/C-API keinen speziellen Slot für eine dieser Methoden gibt. Erweiterungstypen, die diese Methoden definieren möchten, müssen sie als normale, über Python zugängliche Methode bereitstellen. Im Vergleich zum Overhead beim Einrichten des Laufzeitkontexts ist der Overhead eines einzelnen Class-Dictionary-Lookups zu vernachlässigen.

Typ-Annotations-Typen – Generic Alias, Union ¶

Die zentralen eingebauten Typen für Typ-Annotationen sind Generic Alias und Union.

Generic-Alias-Typ¶

GenericAlias-Objekte werden im Allgemeinen durch Subskription einer Klasse erstellt. Sie werden am häufigsten mit Container-Klassen wie list oder dict verwendet. Beispielsweise ist list[int] ein GenericAlias-Objekt, das durch Subskription der Klasse list mit dem Argument int erstellt wird. GenericAlias-Objekte sind in erster Linie für die Verwendung mit Typ-Annotationen vorgesehen.

Bemerkung

Das Subskribieren einer Klasse ist im Allgemeinen nur möglich, wenn die Klasse die spezielle Methode __class_getitem__() implementiert.

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

Bei einer Container-Klasse können die Argumente, die einer Subskription der Klasse übergeben werden, den bzw. die Typ(en) der Elemente angeben, die ein Objekt enthält. Beispielsweise kann set[bytes] in Typ-Annotationen verwendet werden, um ein set zu kennzeichnen, in dem alle Elemente vom Typ bytes sind.

Bei einer Klasse, die __class_getitem__() definiert, aber kein Container ist, geben die Argumente einer Subskription der Klasse häufig den bzw. die Rückgabetyp(en) einer oder mehrerer für ein Objekt definierter Methoden an. Beispielsweise können reguläre Ausdrücke sowohl auf den Datentyp str als auch auf den Datentyp bytes angewendet werden:

Wenn x = re.search('foo', 'foo') ist, ist x ein re.Match-Objekt, bei dem die Rückgabewerte von x.group(0) und x[0] beide vom Typ str sind. Wir können diese Art von Objekt in Typ-Annotationen mit dem GenericAlias re.Match[str] darstellen.
Wenn y = re.search(b'bar', b'bar') ist (beachte das b für bytes), ist y ebenfalls eine Instanz von re.Match, die Rückgabewerte von y.group(0) und y[0] sind jedoch beide vom Typ bytes. In Typ-Annotationen würden wir diese Variante von re.Match-Objekten mit re.Match[bytes] darstellen.

GenericAlias-Objekte sind Instanzen der Klasse types.GenericAlias, mit der GenericAlias-Objekte auch direkt erstellt werden können. Spezialisierungen benutzerdefinierter generischer Klassen sind möglicherweise keine Instanzen von types.GenericAlias, bieten aber ähnliche Funktionalität.

T[X, Y, ...]

Erstellt ein GenericAlias, das einen Typ T darstellt, der durch die Typen X, Y und weitere (je nach verwendetem T) parametrisiert ist. Beispielsweise eine Funktion, die eine list mit float-Elementen erwartet:

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

Ein weiteres Beispiel für Mapping-Objekte unter Verwendung eines dict, welches ein generischer Typ ist, der zwei Typparameter für den Schlüsseltyp und den Werttyp erwartet. In diesem Beispiel erwartet die Funktion ein dict mit Schlüsseln vom Typ str und Werten vom Typ int:

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

Die eingebauten Funktionen isinstance() und issubclass() akzeptieren keine GenericAlias-Typen als zweites Argument:

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Die Python-Laufzeitumgebung erzwingt keine Typ-Annotationen. Dies erstreckt sich auch auf generische Typen und deren Typparameter. Beim Erstellen eines Container-Objekts aus einem GenericAlias werden die Elemente im Container nicht auf ihren Typ überprüft. Der folgende Code wird beispielsweise nicht empfohlen, läuft aber fehlerfrei durch:

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

Darüber hinaus löschen parametrisierte Generics Typparameter während der Objekterstellung (Type Erasure):

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

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

Instanzen von GenericAlias sind zur Laufzeit keine Klassen, auch wenn sie sich wie Klassen verhalten (sie können instanziiert und abgeleitet werden):

>>> import inspect
>>> inspect.isclass(list[int])
False

Dies gilt auch für benutzerdefinierte Generics.

Der Aufruf von repr() oder str() auf einem Generic zeigt den parametrisierten Typ:

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

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

Die Methode __getitem__() generischer Container löst eine Ausnahme aus, um Fehler wie dict[str][str] zu verhindern:

>>> dict[str][str]
Traceback (most recent call last):
  ...
TypeError: dict[str] is not a generic class

Solche Ausdrücke sind jedoch gültig, wenn Typvariablen verwendet werden. Der Index muss so viele Elemente haben, wie es Typvariablen-Einträge in __args__ des GenericAlias-Objekts gibt.

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

Standard-Generische Klassen¶

Die folgenden Klassen der Standardbibliothek unterstützen parametrisierte Generics. Diese Liste ist nicht vollständig.

Spezielle Attribute von `GenericAlias`-Objekten¶

Alle parametrisierten Generics implementieren spezielle schreibgeschützte Attribute.

genericalias.__origin__¶

Dieses Attribut verweist auf die nicht-parametrisierte generische Klasse:

>>> list[int].__origin__
<class 'list'>

genericalias.__args__¶

Dieses Attribut ist ein tuple (möglicherweise der Länge 1) von generischen Typen, die an das ursprüngliche __class_getitem__() der generischen Klasse übergeben wurden:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__¶

Dieses Attribut ist ein verzögert ausgewertetes (möglicherweise leeres) Tupel von eindeutigen Typvariablen, die in __args__ gefunden wurden:

>>> from typing import TypeVar

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

Bemerkung

Ein GenericAlias-Objekt mit typing.ParamSpec-Parametern hat nach der Ersetzung möglicherweise keine korrekten __parameters__, da typing.ParamSpec in erster Linie für die statische Typprüfung gedacht ist.

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

Added in version 3.11.

Siehe auch

PEP 484 - Type Hints: Einführung von Pythons Framework für Typ-Annotationen.
PEP 585 - Type Hinting Generics In Standard Collections: Einführung der Möglichkeit zur nativen Parametrisierung von Standardbibliotheksklassen, sofern sie die spezielle Klassenmethode __class_getitem__() implementieren.
Generics, benutzerdefinierte Generics und typing.Generic: Dokumentation zur Implementierung generischer Klassen, die zur Laufzeit parametrisiert und von statischen Typprüfern verstanden werden können.

Added in version 3.9.

Union-Typ¶

A union object holds the value of the | (bitwise or) operation on multiple type objects. These types are intended primarily for type annotations. The union type expression enables cleaner type hinting syntax compared to typing.Union.

X | Y | ...

Definiert ein Union-Objekt, das die Typen X, Y usw. enthält. X | Y bedeutet entweder X oder Y. Es ist äquivalent zu typing.Union[X, Y]. Zum Beispiel erwartet die folgende Funktion ein Argument vom Typ int oder float:

def square(number: int | float) -> int | float:
    return number ** 2

Bemerkung

Der Operator | kann zur Laufzeit nicht verwendet werden, um Unions zu definieren, bei denen ein oder mehrere Elemente Vorwärtsreferenzen (Forward References) sind. Beispielsweise schlägt int | "Foo" zur Laufzeit fehl, wenn "Foo" eine Referenz auf eine noch nicht definierte Klasse ist. Für Unions, die Vorwärtsreferenzen enthalten, sollte der gesamte Ausdruck als String angegeben werden, z. B. "int | Foo".

union_object == other

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

Unions von Unions werden verflacht:

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

Redundante Typen werden entfernt:
```
int | str | int == int | str
```
Beim Vergleich von Unions wird die Reihenfolge ignoriert:
```
int | str == str | int
```
It is compatible with typing.Union:
```
int | str == typing.Union[int, str]
```
Optionale Typen können als Union mit None geschrieben werden:
```
str | None == typing.Optional[str]
```

isinstance(obj, union_object)

issubclass(obj, union_object)

Aufrufe von isinstance() und issubclass() werden ebenfalls mit einem Union-Objekt unterstützt:

>>> isinstance("", int | str)
True

Parametrisierte Generics in Union-Objekten können jedoch nicht geprüft werden:

>>> isinstance(1, int | list[int])  # short-circuit evaluation
True
>>> isinstance([1], int | list[int])
Traceback (most recent call last):
  ...
TypeError: isinstance() argument 2 cannot be a parameterized generic

The user-exposed type for the union object can be accessed from types.UnionType and used for isinstance() checks. An object cannot be instantiated from the type:

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

Bemerkung

Die Methode __or__() für Typobjekte wurde hinzugefügt, um die Syntax X | Y zu unterstützen. Wenn eine Metaklasse __or__() implementiert, kann die Union diese überschreiben:

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
...
>>> class C(metaclass=M):
...     pass
...
>>> C | int
'Hello'
>>> int | C
int | C

Siehe auch

PEP 604 – PEP zum Vorschlag der Syntax X | Y und des Union-Typs.

Added in version 3.10.

Andere eingebaute Typen¶

Der Interpreter unterstützt mehrere andere Arten von Objekten. Die meisten von ihnen unterstützen nur eine oder zwei Operationen.

Module¶

Die einzige spezielle Operation auf einem Modul ist der Attributzugriff: m.name, wobei m ein Modul ist und name auf einen in m*s Symboltabelle definierten Namen zugreift. Modulattributen können Werte zugewiesen werden. (Beachte, dass die Anweisung :keyword:`import` genau genommen keine Operation auf einem Modulobjekt ist; ``import foo`` erfordert nicht, dass ein Modulobjekt namens *foo existiert, sondern eine (externe) Definition für ein Modul namens foo irgendwo vorhanden ist.)

Ein spezielles Attribut jedes Moduls ist __dict__. Dies ist das Dictionary, das die Symboltabelle des Moduls enthält. Das Ändern dieses Dictionaries verändert tatsächlich die Symboltabelle des Moduls, eine direkte Zuweisung an das Attribut __dict__ ist jedoch nicht möglich (man kann m.__dict__['a'] = 1 schreiben, was m.a als 1 definiert, aber nicht m.__dict__ = {}). Die direkte Modifikation von __dict__ wird nicht empfohlen.

In den Interpreter eingebaute Module werden so geschrieben: <module 'sys' (built-in)>. Wenn sie aus einer Datei geladen werden, werden sie als <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'> geschrieben.

Klassen und Klasseninstanzen¶

Siehe Objekte, Werte und Typen und Klassendefinitionen für diese.

Funktionen¶

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

Es gibt im Wesentlichen zwei Arten von Funktionsobjekten: eingebaute Funktionen und benutzerdefinierte Funktionen. Beide unterstützen dieselbe Operation (den Funktionsaufruf), die Implementierung ist jedoch unterschiedlich, daher die verschiedenen Objekttypen.

Siehe Funktionsdefinitionen für weitere Informationen.

Methoden¶

Methoden sind Funktionen, die mittels Attributnotation aufgerufen werden. Es gibt zwei Arten: eingebaute Methoden (wie append() bei Listen) und Klasseninstanzmethoden. Eingebaute Methoden werden bei den Typen beschrieben, die sie unterstützen.

Wenn man über eine Instanz auf eine Methode (eine im Namensraum einer Klasse definierte Funktion) zugreift, erhält man ein spezielles Objekt: ein gebundene Methode <bound method>-Objekt (auch Instanzmethode genannt). Beim Aufruf fügt es das self-Argument zur Argumentliste hinzu. Gebundene Methoden besitzen zwei spezielle schreibgeschützte Attribute: m.__self__ ist das Objekt, auf dem die Methode operiert, und m.__func__ ist die Funktion, die die Methode implementiert. Der Aufruf von m(arg-1, arg-2, ..., arg-n) ist vollkommen äquivalent zum Aufruf von m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Wie Funktionsobjekte unterstützen gebundene Methodenobjekte das Abrufen beliebiger Attribute. Da Methodenattribute jedoch tatsächlich auf dem zugrunde liegenden Funktionsobjekt (method.__func__) gespeichert sind, ist das Setzen von Methodenattributen auf gebundenen Methoden nicht zulässig. Der Versuch, ein Attribut auf einer Methode zu setzen, führt dazu, dass ein AttributeError ausgelöst wird. Um ein Methodenattribut zu setzen, muss es explizit auf dem zugrunde liegenden Funktionsobjekt gesetzt werden:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

Siehe Instanzmethoden für weitere Informationen.

Code-Objekte¶

Code-Objekte werden von der Implementierung verwendet, um „pseudo-kompilierten“ ausführbaren Python-Code wie beispielsweise einen Funktionskörper darzustellen. Sie unterscheiden sich von Funktionsobjekten dadurch, dass sie keine Referenz auf ihre globale Ausführungsumgebung enthalten. Code-Objekte werden von der eingebauten Funktion compile() zurückgegeben und können über ihr Attribut __code__ aus Funktionsobjekten extrahiert werden. Siehe auch das Modul code.

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

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

Siehe Die Standardtyp-Hierarchie für weitere Informationen.

Typ-Objekte¶

Typ-Objekte stellen die verschiedenen Objekttypen dar. Auf den Typ eines Objekts wird über die eingebaute Funktion type() zugegriffen. Es gibt keine speziellen Operationen auf Typen. Das Standardmodul types definiert Namen für alle standardmäßigen eingebauten Typen.

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

Das Null-Objekt¶

Dieses Objekt wird von Funktionen zurückgegeben, die nicht explizit einen Wert zurückgeben. Es unterstützt keine speziellen Operationen. Es gibt genau ein Null-Objekt namens None (ein eingebauter Name). type(None)() erzeugt dasselbe Singleton.

Es wird als None geschrieben.

Das Ellipsis-Objekt¶

Dieses Objekt wird üblicherweise verwendet, um anzuzeigen, dass etwas ausgelassen wurde. Es unterstützt keine speziellen Operationen. Es gibt genau ein Ellipsis-Objekt namens Ellipsis (ein eingebauter Name). type(Ellipsis)() erzeugt das Singleton Ellipsis.

Es wird als Ellipsis oder ... geschrieben.

In typischer Verwendung erscheint ... als das Ellipsis-Objekt an einigen verschiedenen Stellen, zum Beispiel:

In Typ-Annotationen, wie z. B. Callable-Argumente oder Tupel-Elemente.
Als Körper einer Funktion anstelle einer pass-Anweisung.
In Drittanbieter-Bibliotheken, wie etwa Numpys Slicing and Striding.

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

Doctests ELLIPSIS, als Muster für fehlenden Inhalt.
Der Standard-Python-Prompt der interaktiven Shell, wenn eine unvollständige Eingabe vorliegt.

Schließlich verwendet die Python-Dokumentation drei Punkte oft im Sinne des herkömmlichen Sprachgebrauchs, um ausgelassenen Inhalt zu kennzeichnen, selbst in Codebeispielen, die sie auch als Ellipsis verwenden.

Das NotImplemented-Objekt¶

Dieses Objekt wird bei Vergleichen und binären Operationen zurückgegeben, wenn sie auf Typen angewendet werden sollen, die sie nicht unterstützen. Siehe Vergleiche für weitere Informationen. Es gibt genau ein NotImplemented-Objekt. type(NotImplemented)() erzeugt die Singleton-Instanz.

Es wird als NotImplemented geschrieben.

Interne Objekte¶

Siehe Die Standardtyp-Hierarchie für diese Informationen. Dort werden Stack-Frame-Objekte, Traceback-Objekte und Slice-Objekte beschrieben.

Spezielle Attribute¶

Die Implementierung fügt einigen Objekttypen einige spezielle schreibgeschützte Attribute hinzu, wo sie relevant sind. Einige davon werden von der eingebauten Funktion dir() nicht gemeldet.

definition.__name__¶: Der Name der Klasse, Funktion, Methode, des Deskriptors oder der Generatorinstanz.

definition.__qualname__¶: Der voll qualifizierte Name der Klasse, Funktion, Methode, des Deskriptors oder der Generatorinstanz.

Added in version 3.3.

definition.__module__¶: Der Name des Moduls, in dem eine Klasse oder Funktion definiert wurde.

definition.__doc__¶: Der Dokumentations-String (Docstring) einer Klasse oder Funktion oder None, falls nicht definiert.

definition.__type_params__¶: Die Typparameter generischer Klassen, Funktionen und Typaliase. Für Klassen und Funktionen, die nicht generisch sind, ist dies ein leeres Tupel.

Added in version 3.12.

Längenbeschränkung bei der Ganzzahl-String-Konvertierung¶

CPython besitzt ein globales Limit für die Konvertierung zwischen int und str, um Denial-of-Service-Angriffe abzumildern. Dieses Limit gilt nur für dezimale oder andere Zahlenbasen, die keine Zweierpotenz sind. Hexadezimale, oktale und binäre Konvertierungen sind unbegrenzt. Das Limit kann konfiguriert werden.

Der Typ int in CPython ist eine Zahl beliebiger Länge, die in binärer Form gespeichert wird (allgemein bekannt als „Bignum“). Es gibt keinen Algorithmus, der einen String in linearer Zeit in eine binäre Ganzzahl oder eine binäre Ganzzahl in einen String umwandeln kann, es sei denn, die Basis ist eine Zweierpotenz. Selbst die bekanntesten Algorithmen für Basis 10 weisen eine sub-quadratische Komplexität auf. Die Konvertierung eines großen Werts wie int('1' * 500_000) kann auf einer schnellen CPU über eine Sekunde dauern.

Die Begrenzung der Konvertierungsgröße bietet eine praktische Möglichkeit, CVE 2020-10735 zu vermeiden.

Das Limit wird auf die Anzahl der Ziffernzeichen im Eingabe- oder Ausgabe-String angewendet, wenn ein nicht-linearer Konvertierungsalgorithmus beteiligt wäre. Unterstriche und das Vorzeichen zählen nicht zum Limit.

Wenn eine Operation das Limit überschreiten würde, wird ein ValueError ausgelöst:

>>> import sys
>>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

Das Standardlimit beträgt 4300 Ziffern, wie in sys.int_info.default_max_str_digits angegeben. Das niedrigste Limit, das konfiguriert werden kann, beträgt 640 Ziffern, wie in sys.int_info.str_digits_check_threshold angegeben.

Verifizierung:

>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
...           '9252925514383915483333812743580549779436104706260696366600'
...           '571186405732').to_bytes(53, 'big')
...

Added in version 3.11.

Betroffene APIs¶

Die Einschränkung gilt nur für potenziell langsame Konvertierungen zwischen int und str oder bytes:

int(string) mit der Standardbasis 10.
int(string, base) für alle Basen, die keine Zweierpotenz sind.
str(integer).
repr(integer).
jede andere String-Konvertierung zur Basis 10, zum Beispiel f"{integer}", "{}".format(integer) oder b"%d" % integer.

Die Einschränkungen gelten nicht für Funktionen mit einem linearen Algorithmus:

int(string, base) mit Basis 2, 4, 8, 16 oder 32.
int.from_bytes() und int.to_bytes().
hex(), oct(), bin().
Formatspezifikation Mini-Sprache für Hexadezimal-, Oktal- und Binärzahlen.
str zu float.
str zu decimal.Decimal.

Konfigurieren des Limits¶

Vor dem Start von Python kann eine Umgebungsvariable oder ein Kommandozeilen-Flag des Interpreters verwendet werden, um das Limit zu konfigurieren:

PYTHONINTMAXSTRDIGITS, z. B. PYTHONINTMAXSTRDIGITS=640 python3, um das Limit auf 640 zu setzen, oder PYTHONINTMAXSTRDIGITS=0 python3, um die Beschränkung zu deaktivieren.
-X int_max_str_digits, z. B. python3 -X int_max_str_digits=640
sys.flags.int_max_str_digits enthält den Wert von PYTHONINTMAXSTRDIGITS oder -X int_max_str_digits. Wenn sowohl die Umgebungsvariable als auch die Option -X gesetzt sind, hat die Option -X Vorrang. Ein Wert von -1 zeigt an, dass beide nicht gesetzt waren, weshalb bei der Initialisierung ein Wert von sys.int_info.default_max_str_digits verwendet wurde.

Aus dem Code heraus kann das aktuelle Limit eingesehen und über diese sys-APIs ein neues festgelegt werden:

sys.get_int_max_str_digits() und sys.set_int_max_str_digits() sind Getter und Setter für das interpreterweite Limit. Sub-Interpreter haben ihr eigenes Limit.

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

sys.int_info.default_max_str_digits ist das einkompilierte Standardlimit.
sys.int_info.str_digits_check_threshold ist der niedrigste akzeptierte Wert für das Limit (außer 0, was es deaktiviert).

Added in version 3.11.

Vorsicht

Das Festlegen eines niedrigen Limits kann zu Problemen führen. Wenn auch selten, existiert Code, der in seinem Quelltext dezimale Ganzzahlkonstanten enthält, die den Mindestschwellenwert überschreiten. Eine Folge des Festlegens des Limits ist, dass Python-Quellcode, der dezimale Ganzzahlliterale enthält, die länger als das Limit sind, beim Parsen auf einen Fehler stößt – meist beim Start, beim Importieren oder sogar bei der Installation, wann immer noch keine aktuelle .pyc-Datei für den Code existiert. Ein Workaround für Quellcode, der solch große Konstanten enthält, besteht darin, sie in die hexadezimale 0x-Form umzuwandeln, da diese kein Limit besitzt.

Teste deine Anwendung gründlich, wenn du ein niedriges Limit verwendest. Stelle sicher, dass Tests mit frühzeitig über die Umgebung oder das Flag gesetztem Limit ausgeführt werden, sodass es beim Start und sogar bei jedem Installationsschritt greift, der Python aufrufen könnte, um .py-Quellen in .pyc-Dateien vorzukompilieren.

Empfohlene Konfiguration¶

Das Standardlimit sys.int_info.default_max_str_digits ist für die meisten Anwendungen voraussichtlich angemessen. Wenn deine Anwendung ein anderes Limit erfordert, setze es vom Haupteinstiegspunkt aus mit Python-versionsunabhängigem Code, da diese APIs in Versionen vor 3.12 in Sicherheits-Patch-Releases hinzugefügt wurden.

Beispiel:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

Wenn es vollständig deaktiviert werden soll, setze es auf 0.

Fußnoten

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

Eingebaute Typen¶

Wahrheitswert-Prüfung¶

Boolesche Operationen — and, or, not¶

Vergleiche¶

Numerische Typen — int, float, complex¶

Bitweise Operationen auf Ganzzahl-Typen¶

Zusätzliche Methoden zu Ganzzahl-Typen¶

Zusätzliche Methoden zu Float¶

Hashing von numerischen Typen¶

Boolescher Typ – bool¶

Iterator-Typen¶

Generator-Typen¶

Sequenztypen – list, tuple, range¶

Gemeinsame Sequenzoperationen¶

Unveränderliche Sequenztypen¶

Veränderliche Sequenztypen¶

Listen¶

Tupel¶

Ranges¶

Textsequenztyp – str¶

String-Methoden¶

Formatierte String-Literale (f-Strings)¶

String-Formatierung im printf-Stil¶

Binäre Sequenztypen – bytes, bytearray, memoryview¶

Bytes-Objekte¶

Bytearray-Objekte¶

Bytes- und Bytearray-Operationen¶

Bytes-Formatierung im printf-Stil¶

Memory-Views¶

Mengen-Typen – set, frozenset¶

Mapping-Typen – dict¶

Dictionary-View-Objekte¶

Kontext-Manager-Typen¶

Typ-Annotations-Typen – Generic Alias, Union¶

Generic-Alias-Typ¶

Standard-Generische Klassen¶

Spezielle Attribute von GenericAlias-Objekten¶

Union-Typ¶

Andere eingebaute Typen¶

Module¶

Klassen und Klasseninstanzen¶

Funktionen¶

Methoden¶

Code-Objekte¶

Typ-Objekte¶

Das Null-Objekt¶

Das Ellipsis-Objekt¶

Das NotImplemented-Objekt¶

Interne Objekte¶

Spezielle Attribute¶

Längenbeschränkung bei der Ganzzahl-String-Konvertierung¶

Betroffene APIs¶

Konfigurieren des Limits¶

Empfohlene Konfiguration¶

Boolesche Operationen — `and`, `or`, `not`¶

Numerische Typen — `int`, `float`, `complex`¶

Boolescher Typ – `bool`¶

Sequenztypen – `list`, `tuple`, `range`¶

Textsequenztyp – `str`¶

String-Formatierung im `printf`-Stil¶

Binäre Sequenztypen – `bytes`, `bytearray`, `memoryview`¶

Bytes-Formatierung im `printf`-Stil¶

Mengen-Typen – `set`, `frozenset`¶

Mapping-Typen – `dict`¶

Typ-Annotations-Typen – Generic Alias, Union ¶

Spezielle Attribute von `GenericAlias`-Objekten¶