operator — Standardoperatorer som funktioner

Källkod: Lib/operator.py

---

Modulen operator exporterar en uppsättning effektiva funktioner som motsvarar de inbyggda operatorerna i Python. Till exempel är operator.add(x, y) likvärdig med uttrycket x+y. Många funktionsnamn är de som används för specialmetoder, utan de dubbla understrykningarna. För bakåtkompatibilitet har många av dessa en variant med de dubbla understrykningarna. Varianterna utan de dubbla understrykningarna föredras för tydlighetens skull.

Funktionerna är indelade i kategorier som utför objektjämförelser, logiska operationer, matematiska operationer och sekvensoperationer.

Funktionerna för objektjämförelse är användbara för alla objekt och har fått sina namn efter de jämförelseoperatorer som de stöder:

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)

Utför ”rika jämförelser” mellan a och b. Specifikt är lt(a, b) likvärdigt med a < b, le(a, b) likvärdigt med a <= b, eq(a, b) likvärdigt med a == b, ne(a, b) likvärdigt med a != b, gt(a, b) likvärdigt med a > b och ge(a, b) likvärdigt med a >= b. Observera att dessa funktioner kan returnera vilket värde som helst, som kan eller inte kan tolkas som ett booleskt värde. Se Jämförelser för mer information om rika jämförelser.

De logiska operationerna är också allmänt tillämpliga på alla objekt och stöder sanningstest, identitetstest och booleska operationer:

operator.not_(obj)

operator.__not__(obj)

Returnerar resultatet av not obj. (Observera att det inte finns någon __not__()-metod för objektinstanser; endast tolkens kärna definierar denna operation. Resultatet påverkas av metoderna __bool__() och __len__())

operator.truth(obj)

Returnerar True om obj är sann, och False annars. Detta är likvärdigt med att använda bool-konstruktören.

operator.is_(a, b)

Returnerar a är b. Testar objektets identitet.

operator.is_not(a, b)

Returnerar a är inte b. Testar objektets identitet.

operator.is_none(a)

Returnerar a är ingen. Testar objektets identitet.

Tillagd i version 3.14.

operator.is_not_none(a)

Returnerar a är inte None. Testar objektets identitet.

Tillagd i version 3.14.

De matematiska och bitvisa operationerna är de mest omfattande:

operator.abs(obj)

operator.__abs__(obj)

Returnerar det absoluta värdet av obj.

operator.add(a, b)

operator.__add__(a, b)

Returnerar a + b, för a och b tal.

operator.and_(a, b)

operator.__and__(a, b)

Returnerar det bitvisa och av a och b.

operator.floordiv(a, b)

operator.__floordiv__(a, b)

Returnera a // b.

operator.index(a)

operator.__index__(a)

Returnerar a omvandlad till ett heltal. Motsvarar a.__index__().

Ändrad i version 3.10: Resultatet har alltid den exakta typen int. Tidigare kunde resultatet ha varit en instans av en underklass av int.

operator.inv(obj)

operator.invert(obj)

operator.__inv__(obj)

operator.__invert__(obj)

Returnerar den bitvisa inversen av talet obj. Detta är likvärdigt med ~obj.

operator.lshift(a, b)

operator.__lshift__(a, b)

Returnera a vänsterförskjutet med b.

operator.mod(a, b)

operator.__mod__(a, b)

Returnera a % b.

operator.mul(a, b)

operator.__mul__(a, b)

Returnera a * b, för a och b tal.

operator.matmul(a, b)

operator.__matmul__(a, b)

Returnera a @ b.

Tillagd i version 3.5.

operator.neg(obj)

operator.__neg__(obj)

Returnerar obj negerad (-obj).

operator.or_(a, b)

operator.__or__(a, b)

Returnerar det bitvisa eller av a och b.

operator.pos(obj)

operator.__pos__(obj)

Returnera obj positiv (+obj).

operator.pow(a, b)

operator.__pow__(a, b)

Returnera a ** b, för a och b tal.

operator.rshift(a, b)

operator.__rshift__(a, b)

Returnera a högerförskjutet med b.

operator.sub(a, b)

operator.__sub__(a, b)

Returnera a - b.

operator.truediv(a, b)

operator.__truediv__(a, b)

Returnera a / b där 2/3 är 0,66 i stället för 0. Detta kallas också ”sann” division.

operator.xor(a, b)

operator.__xor__(a, b)

Returnerar bitvis exklusivt eller av a och b.

Operationer som arbetar med sekvenser (vissa av dem även med mappningar) är t.ex:

operator.concat(a, b)

operator.__concat__(a, b)

Returnerar a + b för a- och b-sekvenser.

operator.contains(a, b)

operator.__contains__(a, b)

Returnerar resultatet av testet b i a. Notera de omvända operanderna.

operator.countOf(a, b)

Returnera antalet förekomster av b i a.

operator.delitem(a, b)

operator.__delitem__(a, b)

Ta bort värdet av a på index b.

operator.getitem(a, b)

operator.__getitem__(a, b)

Returnera värdet av a vid index b.

operator.indexOf(a, b)

Returnera index för den första förekomsten av b i a.

operator.setitem(a, b, c)

operator.__setitem__(a, b, c)

Ställ in värdet av a på index b till c.

operator.length_hint(obj, default=0)

Returnerar en uppskattad längd för objektet obj. Försök först att returnera dess faktiska längd, sedan en uppskattning med hjälp av object.__length_hint__(), och slutligen returnera standardvärdet.

Tillagd i version 3.4.

Följande operation arbetar med avropbara varor:

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

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

Returnera obj(*args, **kwargs).

Tillagd i version 3.11.

Modulen operator definierar också verktyg för generaliserade attribut- och objektuppslagningar. Dessa är användbara för att skapa snabba fältextraktorer som argument för map(), sorted(), itertools.groupby() eller andra funktioner som förväntar sig ett funktionsargument.

operator.attrgetter(attr)

operator.attrgetter(*attrs)

Returnerar ett anropsbart objekt som hämtar attr från sin operand. Om mer än ett attribut begärs, returneras en tupel av attribut. Attributnamnen kan också innehålla prickar. Till exempel: attr:

• Efter f = attrgetter('name') returnerar anropet f(b) b.name.

• Efter f = attrgetter('name', 'date') returnerar anropet f(b) (b.name, b.date).

• Efter f = attrgetter('name.first', 'name.last') returnerar anropet f(b) (b.name.first, b.name.last).

Motsvarar:

def attrgetter(*objekt):
    if any(not isinstance(item, str) for item in items):
        raise TypeError('attributnamnet måste vara en sträng')
    if len(items) == 1:
        attr = objekt[0]
        def g(obj):
            return resolve_attr(obj, attr)
    annat:
        def g(obj):
            return tuple(resolve_attr(obj, attr) for attr in items)
    returnerar g

def resolve_attr(obj, attr):
    för namn i attr.split("."):
        obj = getattr(obj, namn)
    returnera obj

operator.itemgetter(item)

operator.itemgetter(*items)

Returnerar ett anropbart objekt som hämtar item från sin operand med hjälp av operandens __getitem__()-metod. Om flera objekt anges returneras en tupel av uppslagsvärden. Exempelvis

• Efter f = itemgetter(2) returnerar anropet f(r) r[2].

• Efter g = itemgetter(2, 5, 3) returnerar anropet g(r) (r[2], r[5], r[3]).

Motsvarar:

def itemgetter(*items):
    if len(objekt) == 1:
        objekt = objekt[0]
        def g(obj):
            returnera obj[objekt]
    else:
        def g(obj):
            return tuple(obj[item] för item i items)
    returnera g

Objekten kan vara av vilken typ som helst som accepteras av operandens __getitem__()-metod. Ordböcker accepterar alla hashable-värden. Listor, tupler och strängar accepterar ett index eller en 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'

Exempel på användning av itemgetter() för att hämta specifika fält från en tuple-post:

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

Returnerar ett anropsbart objekt som anropar metoden namn på sin operand. Om ytterligare argument och/eller nyckelordsargument anges kommer de också att ges till metoden. Till exempel

• Efter f = methodcaller('name') returnerar anropet f(b) b.name().

• Efter f = methodcaller('name', 'foo', bar=1) returnerar anropet f(b) b.name('foo', bar=1).

Motsvarar:

def methodcaller(namn, /, *args, **kwargs):
    def caller(obj):
        return getattr(obj, namn)(*args, **kwargs)
    returnerar anropare

Mappning av operatorer till funktioner

Denna tabell visar hur abstrakta operationer motsvarar operatorssymboler i Pythons syntax och funktionerna i modulen operator.

Operation	Syntax	Funktion
Addition	a + b	add(a, b)
Sammanfogning	seq1 + seq2	concat(seq1, seq2)
Test av inneslutning	obj i seq	innehåller(seq, obj)
Division	a / b	truediv(a, b)
Division	a // b	floordiv(a, b)
Bitvis och	a & b	och_(a, b)
Bitvis exklusivt eller	a ^ b	xor(a, b)
Bitvis invertering	~ a	invert(a)
Bitvis eller	a | b	eller_(a, b)
Potens	a ** b	pow(a, b)
Identitet	”A är B	är_(a, b)
Identitet	”a är inte b	är_inte(a, b)
Identitet	a är ingen	is_none(a)
Identitet	a är inte None	is_not_none(a)
Indexerat uppdrag	obj[k] = v	setitem(obj, k, v)
Indexerad radering	del obj[k]	delitem(obj, k)
Indexering	obj[k]	getitem(obj, k)
Vänster skift	a << b	lshift(a, b)
Modulo	a % b	mod(a, b)
Multiplikation	a * b	mul(a, b)
Multiplikation av matriser	a @ b	matmul(a, b)
Negation (aritmetik)	- a	neg(a)
Negation (logisk)	inte en	not_(a)
Positiv	+ a	pos(a)
Höger skift	a >> b	rshift(a, b)
Uppgift om skiva	seq[i:j] = värden	setitem(seq, slice(i, j), värden)
Borttagning av skivor	del seq[i:j]	delitem(seq, slice(i, j))
Skivning	seq[i:j]	getitem(seq, slice(i, j))
Strängformatering	s % obj	mod(s, obj)
Subtraktion	a - b	sub(a, b)
Sanningstest	obj	Sanning(obj)
Ordning	a < b	lt(a, b)
Ordning	a <= b	le(a, b)
Jämlikhet	a == b	eq(a, b)
Skillnad	a != b	ne(a, b)
Ordning	a >= b	ge(a, b)
Ordning	a > b	gt(a, b)

Operatorer på plats

Många operationer har en ”in-place”-version. Nedan listas funktioner som ger en mer primitiv tillgång till in-place-operatorer än vad den vanliga syntaxen gör; till exempel är statement x += y ekvivalent med x = operator.iadd(x, y). Ett annat sätt att uttrycka det är att säga att z = operator.iadd(x, y) är ekvivalent med det sammansatta påståendet z = x; z += y.

Observera i dessa exempel att när en in-place-metod anropas utförs beräkningen och tilldelningen i två separata steg. De in-place-funktioner som listas nedan gör bara det första steget, anrop av in-place-metoden. Det andra steget, tilldelning, hanteras inte.

För oföränderliga mål som strängar, tal och tupler beräknas det uppdaterade värdet, men tilldelas inte tillbaka till inmatningsvariabeln:

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

För föränderliga mål som listor och lexikon kommer in-place-metoden att utföra uppdateringen, så ingen efterföljande tilldelning är nödvändig:

>>> 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) är likvärdigt med a += b.

operator.iand(a, b)

operator.__iand__(a, b)

a = iand(a, b) är likvärdigt med a &= b.

operator.iconcat(a, b)

operator.__iconcat__(a, b)

a = iconcat(a, b) är likvärdigt med a += b för a och b sekvenser.

operator.ifloordiv(a, b)

operator.__ifloordiv__(a, b)

a = ifloordiv(a, b) är ekvivalent med a //= b.

operator.ilshift(a, b)

operator.__ilshift__(a, b)

a = ilshift(a, b) är likvärdigt med a <<= b.

operator.imod(a, b)

operator.__imod__(a, b)

a = imod(a, b) är ekvivalent med a %= b.

operator.imul(a, b)

operator.__imul__(a, b)

a = imul(a, b) är likvärdigt med a *= b.

operator.imatmul(a, b)

operator.__imatmul__(a, b)

a = imatmul(a, b) är likvärdigt med a @= b.

Tillagd i version 3.5.

operator.ior(a, b)

operator.__ior__(a, b)

a = ior(a, b) är likvärdigt med a |= b.

operator.ipow(a, b)

operator.__ipow__(a, b)

a = ipow(a, b) är ekvivalent med a **= b.

operator.irshift(a, b)

operator.__irshift__(a, b)

a = irshift(a, b) är likvärdigt med a >>= b.

operator.isub(a, b)

operator.__isub__(a, b)

a = isub(a, b) är likvärdigt med a -= b.

operator.itruediv(a, b)

operator.__itruediv__(a, b)

a = itruediv(a, b) är ekvivalent med a /= b.

operator.ixor(a, b)

operator.__ixor__(a, b)

a = ixor(a, b) är ekvivalent med a ^= b.