operator — Standardoperatoren als Funktionen

Quellcode: Lib/operator.py

---

Das Modul operator exportiert eine Reihe effizienter Funktionen, die den internen Operatoren von Python entsprechen. Zum Beispiel ist operator.add(x, y) äquivalent zum Ausdruck x+y. Viele Funktionsnamen sind die Namen, die für spezielle Methoden verwendet werden, ohne die doppelten Unterstriche. Aus Gründen der Abwärtskompatibilität haben viele dieser Funktionen eine Variante mit beibehaltenen doppelten Unterstrichen. Die Varianten ohne doppelte Unterstriche werden aus Gründen der Klarheit bevorzugt.

Die Funktionen sind in Kategorien unterteilt, die Objektvergleiche, logische Operationen, mathematische Operationen und Sequenzoperationen durchführen.

Die Objektvergleichsfunktionen sind für alle Objekte nützlich und nach den Rich-Comparison-Operatoren benannt, die sie unterstützen

operator.lt(a, b)

operator.le(a, b)

operator.eq(a, b)

operator.ne(a, b)

operator.ge(a, b)

operator.gt(a, b)

operator.__lt__(a, b)

operator.__le__(a, b)

operator.__eq__(a, b)

operator.__ne__(a, b)

operator.__ge__(a, b)

operator.__gt__(a, b)

Führt „Rich Comparisons“ zwischen a und b durch. Insbesondere ist lt(a, b) äquivalent zu a < b, le(a, b) ist äquivalent zu a <= b, eq(a, b) ist äquivalent zu a == b, ne(a, b) ist äquivalent zu a != b, gt(a, b) ist äquivalent zu a > b und ge(a, b) ist äquivalent zu a >= b. Beachten Sie, dass diese Funktionen jeden Wert zurückgeben können, der möglicherweise als boolescher Wert interpretiert werden kann oder auch nicht. Weitere Informationen zu Rich Comparisons finden Sie unter Vergleiche.

Die logischen Operationen sind ebenfalls allgemein auf alle Objekte anwendbar und unterstützen Wahrheits-, Identitäts- und Boolesche Tests

operator.not_(obj)

operator.__not__(obj)

Gibt das Ergebnis von not obj zurück. (Beachten Sie, dass es keine __not__() Methode für Objektinstanzen gibt; nur der Interpreter-Kern definiert diese Operation. Das Ergebnis wird von den Methoden __bool__() und __len__() beeinflusst.)

operator.truth(obj)

Gibt True zurück, wenn obj wahr ist, und andernfalls False. Dies ist äquivalent zur Verwendung des bool-Konstruktors.

operator.is_(a, b)

Gibt a is b zurück. Testet die Objektidentität.

operator.is_not(a, b)

Gibt a is not b zurück. Testet die Objektidentität.

operator.is_none(a)

Gibt a is None zurück. Testet die Objektidentität.

Hinzugefügt in Version 3.14.

operator.is_not_none(a)

Gibt a is not None zurück. Testet die Objektidentität.

Hinzugefügt in Version 3.14.

Die mathematischen und bitweisen Operationen sind am zahlreichsten

operator.abs(obj)

operator.__abs__(obj)

Gibt den Absolutwert von obj zurück.

operator.add(a, b)

operator.__add__(a, b)

Gibt a + b für a und b als Zahlen zurück.

operator.and_(a, b)

operator.__and__(a, b)

Gibt die bitweise UND-Verknüpfung von a und b zurück.

operator.floordiv(a, b)

operator.__floordiv__(a, b)

Gibt a // b zurück.

operator.index(a)

operator.__index__(a)

Gibt a in einen Integer konvertiert zurück. Äquivalent zu a.__index__().

Geändert in Version 3.10: Das Ergebnis hat immer den exakten Typ int. Zuvor konnte das Ergebnis eine Instanz einer Unterklasse von int sein.

operator.inv(obj)

operator.invert(obj)

operator.__inv__(obj)

operator.__invert__(obj)

Gibt die bitweise Invertierung der Zahl obj zurück. Dies ist äquivalent zu ~obj.

operator.lshift(a, b)

operator.__lshift__(a, b)

Gibt a um b nach links verschoben zurück.

operator.mod(a, b)

operator.__mod__(a, b)

Gibt a % b zurück.

operator.mul(a, b)

operator.__mul__(a, b)

Gibt a * b für a und b als Zahlen zurück.

operator.matmul(a, b)

operator.__matmul__(a, b)

Gibt a @ b zurück.

Hinzugefügt in Version 3.5.

operator.neg(obj)

operator.__neg__(obj)

Gibt obj negiert zurück (-obj).

operator.or_(a, b)

operator.__or__(a, b)

Gibt die bitweise ODER-Verknüpfung von a und b zurück.

operator.pos(obj)

operator.__pos__(obj)

Gibt obj positiv zurück (+obj).

operator.pow(a, b)

operator.__pow__(a, b)

Gibt a ** b für a und b als Zahlen zurück.

operator.rshift(a, b)

operator.__rshift__(a, b)

Gibt a um b nach rechts verschoben zurück.

operator.sub(a, b)

operator.__sub__(a, b)

Gibt a - b zurück.

operator.truediv(a, b)

operator.__truediv__(a, b)

Gibt a / b zurück, wobei 2/3 .66 und nicht 0 ist. Dies wird auch als „echte“ Division bezeichnet.

operator.xor(a, b)

operator.__xor__(a, b)

Gibt die bitweise exklusive ODER-Verknüpfung von a und b zurück.

Operationen, die mit Sequenzen (einige auch mit Mappings) arbeiten, umfassen

operator.concat(a, b)

operator.__concat__(a, b)

Gibt a + b für a und b als Sequenzen zurück.

operator.contains(a, b)

operator.__contains__(a, b)

Gibt das Ergebnis des Tests b in a zurück. Beachten Sie die vertauschten Operanden.

operator.countOf(a, b)

Gibt die Anzahl der Vorkommen von b in a zurück.

operator.delitem(a, b)

operator.__delitem__(a, b)

Entfernt den Wert von a am Index b.

operator.getitem(a, b)

operator.__getitem__(a, b)

Gibt den Wert von a am Index b zurück.

operator.indexOf(a, b)

Gibt den Index des ersten Vorkommens von b in a zurück.

operator.setitem(a, b, c)

operator.__setitem__(a, b, c)

Setzt den Wert von a am Index b auf c.

operator.length_hint(obj, default=0)

Gibt eine geschätzte Länge für das Objekt obj zurück. Versucht zuerst, seine tatsächliche Länge zurückzugeben, dann eine Schätzung mit object.__length_hint__() und gibt schließlich den Standardwert zurück.

Hinzugefügt in Version 3.4.

Die folgende Operation arbeitet mit aufrufbaren Objekten

operator.call(obj, /, *args, **kwargs)

operator.__call__(obj, /, *args, **kwargs)

Gibt obj(*args, **kwargs) zurück.

Hinzugefügt in Version 3.11.

Das Modul operator definiert auch Werkzeuge für allgemeine Attribut- und Elementabfragen. Diese sind nützlich, um schnelle Feldextraktoren als Argumente für map(), sorted(), itertools.groupby() oder andere Funktionen zu erstellen, die ein Funktionsargument erwarten.

operator.attrgetter(attr)

operator.attrgetter(*attrs)

Gibt ein aufrufbares Objekt zurück, das attr aus seinem Operanden abruft. Wenn mehr als ein Attribut angefordert wird, wird ein Tupel von Attributen zurückgegeben. Die Attributnamen können auch Punkte enthalten. Zum Beispiel

• Nach f = attrgetter('name') gibt der Aufruf f(b) b.name zurück.

• Nach f = attrgetter('name', 'date') gibt der Aufruf f(b) (b.name, b.date) zurück.

• Nach f = attrgetter('name.first', 'name.last') gibt der Aufruf f(b) (b.name.first, b.name.last) zurück.

Entspricht

def attrgetter(*items):
    if any(not isinstance(item, str) for item in items):
        raise TypeError('attribute name must be a string')
    if len(items) == 1:
        attr = items[0]
        def g(obj):
            return resolve_attr(obj, attr)
    else:
        def g(obj):
            return tuple(resolve_attr(obj, attr) for attr in items)
    return g

def resolve_attr(obj, attr):
    for name in attr.split("."):
        obj = getattr(obj, name)
    return obj

operator.itemgetter(item)

operator.itemgetter(*items)

Gibt ein aufrufbares Objekt zurück, das item aus seinem Operanden mithilfe der Methode __getitem__() des Operanden abruft. Wenn mehrere Elemente angegeben sind, wird ein Tupel von Lookup-Werten zurückgegeben. Zum Beispiel

• Nach f = itemgetter(2) gibt der Aufruf f(r) r[2] zurück.

• Nach g = itemgetter(2, 5, 3) gibt der Aufruf g(r) (r[2], r[5], r[3]) zurück.

Entspricht

def itemgetter(*items):
    if len(items) == 1:
        item = items[0]
        def g(obj):
            return obj[item]
    else:
        def g(obj):
            return tuple(obj[item] for item in items)
    return g

Die Elemente können jeder Typ sein, der von der Methode __getitem__() des Operanden akzeptiert wird. Wörterbücher akzeptieren jeden hashbaren Wert. Listen, Tupel und Strings akzeptieren einen Index oder einen Slice

>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1, 3, 5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2, None))('ABCDEFG')
'CDEFG'
>>> soldier = dict(rank='captain', name='dotterbart')
>>> itemgetter('rank')(soldier)
'captain'

Beispiel für die Verwendung von itemgetter() zum Abrufen spezifischer Felder aus einem Tupel-Datensatz

>>> inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
>>> getcount = itemgetter(1)
>>> list(map(getcount, inventory))
[3, 2, 5, 1]
>>> sorted(inventory, key=getcount)
[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

operator.methodcaller(name, /, *args, **kwargs)

Gibt ein aufrufbares Objekt zurück, das die Methode name seines Operanden aufruft. Wenn zusätzliche Argumente und/oder Schlüsselwortargumente angegeben werden, werden diese ebenfalls an die Methode übergeben. Zum Beispiel

• Nach f = methodcaller('name') gibt der Aufruf f(b) b.name() zurück.

• Nach f = methodcaller('name', 'foo', bar=1) gibt der Aufruf f(b) b.name('foo', bar=1) zurück.

Entspricht

def methodcaller(name, /, *args, **kwargs):
    def caller(obj):
        return getattr(obj, name)(*args, **kwargs)
    return caller

Operatoren zu Funktionen zuordnen

Diese Tabelle zeigt, wie abstrakte Operationen den Operator-Symbolen in der Python-Syntax und den Funktionen im Modul operator entsprechen.

Operation	Syntax	Funktion
Addition	a + b	add(a, b)
Verkettung	seq1 + seq2	concat(seq1, seq2)
Containment-Test	obj in seq	contains(seq, obj)
Division	a / b	truediv(a, b)
Division	a // b	floordiv(a, b)
Bitweises UND	a & b	and_(a, b)
Bitweises Exklusiv-ODER	a ^ b	xor(a, b)
Bitweise Inversion	~ a	invert(a)
Bitweises ODER	a | b	or_(a, b)
Potenzierung	a ** b	pow(a, b)
Identität	a is b	is_(a, b)
Identität	a is not b	is_not(a, b)
Identität	a is None	is_none(a)
Identität	a is not None	is_not_none(a)
Indizierte Zuweisung	obj[k] = v	setitem(obj, k, v)
Indizierte Löschung	del obj[k]	delitem(obj, k)
Indizierung	obj[k]	getitem(obj, k)
Linksschieben	a << b	lshift(a, b)
Modulo	a % b	mod(a, b)
Multiplikation	a * b	mul(a, b)
Matrixmultiplikation	a @ b	matmul(a, b)
Negation (Arithmetik)	- a	neg(a)
Negation (Logisch)	not a	not_(a)
Positiv	+ a	pos(a)
Rechtsschieben	a >> b	rshift(a, b)
Slice-Zuweisung	seq[i:j] = values	setitem(seq, slice(i, j), values)
Slice-Löschung	del seq[i:j]	delitem(seq, slice(i, j))
Slicing	seq[i:j]	getitem(seq, slice(i, j))
String-Formatierung	s % obj	mod(s, obj)
Subtraktion	a - b	sub(a, b)
Wahrheitstest	obj	truth(obj)
Ordnung	a < b	lt(a, b)
Ordnung	a <= b	le(a, b)
Gleichheit	a == b	eq(a, b)
Differenz	a != b	ne(a, b)
Ordnung	a >= b	ge(a, b)
Ordnung	a > b	gt(a, b)

In-Place-Operatoren

Viele Operationen haben eine "In-Place"-Version. Im Folgenden sind Funktionen aufgeführt, die einen primitiveren Zugriff auf In-Place-Operatoren bieten als die übliche Syntax; zum Beispiel ist die Anweisung x += y äquivalent zu x = operator.iadd(x, y). Anders ausgedrückt bedeutet z = operator.iadd(x, y) die zusammengesetzte Anweisung z = x; z += y.

In diesen Beispielen ist zu beachten, dass beim Aufruf einer In-Place-Methode die Berechnung und die Zuweisung in zwei separaten Schritten durchgeführt werden. Die unten aufgeführten In-Place-Funktionen führen nur den ersten Schritt aus, nämlich den Aufruf der In-Place-Methode. Der zweite Schritt, die Zuweisung, wird nicht gehandhabt.

Für unveränderliche Ziele wie Strings, Zahlen und Tupel wird der aktualisierte Wert berechnet, aber nicht der Eingabevariable zugewiesen

>>> a = 'hello'
>>> iadd(a, ' world')
'hello world'
>>> a
'hello'

Für veränderliche Ziele wie Listen und Wörterbücher führt die In-Place-Methode die Aktualisierung durch, so dass keine nachfolgende Zuweisung erforderlich ist

>>> s = ['h', 'e', 'l', 'l', 'o']
>>> iadd(s, [' ', 'w', 'o', 'r', 'l', 'd'])
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> s
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

operator.iadd(a, b)

operator.__iadd__(a, b)

a = iadd(a, b) ist äquivalent zu a += b.

operator.iand(a, b)

operator.__iand__(a, b)

a = iand(a, b) ist äquivalent zu a &= b.

operator.iconcat(a, b)

operator.__iconcat__(a, b)

a = iconcat(a, b) ist äquivalent zu a += b für Sequenzen a und b.

operator.ifloordiv(a, b)

operator.__ifloordiv__(a, b)

a = ifloordiv(a, b) ist äquivalent zu a //= b.

operator.ilshift(a, b)

operator.__ilshift__(a, b)

a = ilshift(a, b) ist äquivalent zu a <<= b.

operator.imod(a, b)

operator.__imod__(a, b)

a = imod(a, b) ist äquivalent zu a %= b.

operator.imul(a, b)

operator.__imul__(a, b)

a = imul(a, b) ist äquivalent zu a *= b.

operator.imatmul(a, b)

operator.__imatmul__(a, b)

a = imatmul(a, b) ist äquivalent zu a @= b.

Hinzugefügt in Version 3.5.

operator.ior(a, b)

operator.__ior__(a, b)

a = ior(a, b) ist äquivalent zu a |= b.

operator.ipow(a, b)

operator.__ipow__(a, b)

a = ipow(a, b) ist äquivalent zu a **= b.

operator.irshift(a, b)

operator.__irshift__(a, b)

a = irshift(a, b) ist äquivalent zu a >>= b.

operator.isub(a, b)

operator.__isub__(a, b)

a = isub(a, b) ist äquivalent zu a -= b.

operator.itruediv(a, b)

operator.__itruediv__(a, b)

a = itruediv(a, b) ist äquivalent zu a /= b.

operator.ixor(a, b)

operator.__ixor__(a, b)

a = ixor(a, b) ist äquivalent zu a ^= b.