9.9. operator — Opérateurs standards en tant que fonctions

The operator module exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, operator.add(x, y) is equivalent to the expression x+y. The function names are those used for special class methods; variants without leading and trailing __ are also provided for convenience.

The functions fall into categories that perform object comparisons, logical operations, mathematical operations, sequence operations, and abstract type tests.

Les fonctions de comparaison s’appliquent à tous les objets, et leur nom vient des opérateurs de comparaison qu’elles implémentent :

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)

Perform « rich comparisons » between a and b. Specifically, lt(a, b) is equivalent to a < b, le(a, b) is equivalent to a <= b, eq(a, b) is equivalent to a == b, ne(a, b) is equivalent to a != b, gt(a, b) is equivalent to a > b and ge(a, b) is equivalent to a >= b. Note that unlike the built-in cmp(), these functions can return any value, which may or may not be interpretable as a Boolean value. See Comparaisons for more information about rich comparisons.

Nouveau dans la version 2.2.

En général, les opérations logiques s’appliquent aussi à tous les objets et implémentent les tests de vérité, d’identité et les opérations booléennes :

operator.not_(obj)

operator.__not__(obj)

Return the outcome of not obj. (Note that there is no __not__() method for object instances; only the interpreter core defines this operation. The result is affected by the __nonzero__() and __len__() methods.)

operator.truth(obj)

Renvoie True si obj est vrai, et False dans le cas contraire. Équivaut à utiliser le constructeur de bool.

operator.is_(a, b)

Renvoie a is b. Vérifie si les deux paramètres sont le même objet.

Nouveau dans la version 2.3.

operator.is_not(a, b)

Renvoie a is not b. Vérifie si les deux paramètres sont deux objets distincts.

Nouveau dans la version 2.3.

Les opérations mathématiques ou bit à bit sont les plus nombreuses :

operator.abs(obj)

operator.__abs__(obj)

Renvoie la valeur absolue de obj.

operator.add(a, b)

operator.__add__(a, b)

Renvoie a + b où a et b sont des nombres.

operator.and_(a, b)

operator.__and__(a, b)

Renvoie le et bit à bit de a et b.

operator.div(a, b)

operator.__div__(a, b)

Return a / b when __future__.division is not in effect. This is also known as « classic » division.

operator.floordiv(a, b)

operator.__floordiv__(a, b)

Renvoie a // b.

Nouveau dans la version 2.2.

operator.index(a)

operator.__index__(a)

Renvoie a converti en entier. Équivaut à a.__index__().

Nouveau dans la version 2.5.

operator.inv(obj)

operator.invert(obj)

operator.__inv__(obj)

operator.__invert__(obj)

Renvoie l’inverse bit à bit du nombre obj. Équivaut à ~obj.

Nouveau dans la version 2.0: The names invert() and __invert__().

operator.lshift(a, b)

operator.__lshift__(a, b)

Renvoie le décalage de b bits vers la gauche de a.

operator.mod(a, b)

operator.__mod__(a, b)

Renvoie``a % b``.

operator.mul(a, b)

operator.__mul__(a, b)

Renvoie a * b où a et b sont des nombres.

operator.neg(obj)

operator.__neg__(obj)

Renvoie l’opposé de obj (-obj).

operator.or_(a, b)

operator.__or__(a, b)

Renvoie le ou bit à bit de a et b.

operator.pos(obj)

operator.__pos__(obj)

Renvoie la valeur positive de obj (+obj).

operator.pow(a, b)

operator.__pow__(a, b)

Renvoie a ** b où a et b sont des nombres.

Nouveau dans la version 2.3.

operator.rshift(a, b)

operator.__rshift__(a, b)

Renvoie le décalage de b bits vers la droite de a.

operator.sub(a, b)

operator.__sub__(a, b)

Renvoie a - b.

operator.truediv(a, b)

operator.__truediv__(a, b)

Return a / b when __future__.division is in effect. This is also known as « true » division.

Nouveau dans la version 2.2.

operator.xor(a, b)

operator.__xor__(a, b)

Renvoie le ou exclusif bit à bit de a et b.

Les opérations sur séquences (et pour certaines, sur correspondances) sont :

operator.concat(a, b)

operator.__concat__(a, b)

Renvoie a + b où a et b sont des séquences.

operator.contains(a, b)

operator.__contains__(a, b)

Renvoie le résultat du test b in a. Notez que les opérandes sont inversées.

Nouveau dans la version 2.0: The name __contains__().

operator.countOf(a, b)

Renvoie le nombre d’occurrences de b dans a.

operator.delitem(a, b)

operator.__delitem__(a, b)

Renvoie la valeur de a à l’indice b.

operator.delslice(a, b, c)

operator.__delslice__(a, b, c)

Delete the slice of a from index b to index c-1.

Obsolète depuis la version 2.6: This function is removed in Python 3.x. Use delitem() with a slice index.

operator.getitem(a, b)

operator.__getitem__(a, b)

Renvoie la valeur de a à l’indice b.

operator.getslice(a, b, c)

operator.__getslice__(a, b, c)

Return the slice of a from index b to index c-1.

Obsolète depuis la version 2.6: This function is removed in Python 3.x. Use getitem() with a slice index.

operator.indexOf(a, b)

Renvoie l’indice de la première occurrence de b dans a.

operator.repeat(a, b)

operator.__repeat__(a, b)

Obsolète depuis la version 2.7: Use __mul__() instead.

Return a * b where a is a sequence and b is an integer.

operator.sequenceIncludes(...)

Obsolète depuis la version 2.0: Use contains() instead.

Alias for contains().

operator.setitem(a, b, c)

operator.__setitem__(a, b, c)

Affecte c dans a à l’indice b.

operator.setslice(a, b, c, v)

operator.__setslice__(a, b, c, v)

Set the slice of a from index b to index c-1 to the sequence v.

Obsolète depuis la version 2.6: This function is removed in Python 3.x. Use setitem() with a slice index.

Example use of operator functions:

>>> # Elementwise multiplication
>>> map(mul, [0, 1, 2, 3], [10, 20, 30, 40])
[0, 20, 60, 120]

>>> # Dot product
>>> sum(map(mul, [0, 1, 2, 3], [10, 20, 30, 40]))
200

Many operations have an « in-place » version. The following functions provide a more primitive access to in-place operators than the usual syntax does; for example, the statement x += y is equivalent to x = operator.iadd(x, y). Another way to put it is to say that z = operator.iadd(x, y) is equivalent to the compound statement z = x; z += y.

operator.iadd(a, b)

operator.__iadd__(a, b)

a = iadd(a, b) is equivalent to a += b.

Nouveau dans la version 2.5.

operator.iand(a, b)

operator.__iand__(a, b)

a = iand(a, b) is equivalent to a &= b.

Nouveau dans la version 2.5.

operator.iconcat(a, b)

operator.__iconcat__(a, b)

a = iconcat(a, b) is equivalent to a += b for a and b sequences.

Nouveau dans la version 2.5.

operator.idiv(a, b)

operator.__idiv__(a, b)

a = idiv(a, b) is equivalent to a /= b when __future__.division is not in effect.

Nouveau dans la version 2.5.

operator.ifloordiv(a, b)

operator.__ifloordiv__(a, b)

a = ifloordiv(a, b) is equivalent to a //= b.

Nouveau dans la version 2.5.

operator.ilshift(a, b)

operator.__ilshift__(a, b)

a = ilshift(a, b) is equivalent to a <<= b.

Nouveau dans la version 2.5.

operator.imod(a, b)

operator.__imod__(a, b)

a = imod(a, b) is equivalent to a %= b.

Nouveau dans la version 2.5.

operator.imul(a, b)

operator.__imul__(a, b)

a = imul(a, b) is equivalent to a *= b.

Nouveau dans la version 2.5.

operator.ior(a, b)

operator.__ior__(a, b)

a = ior(a, b) is equivalent to a |= b.

Nouveau dans la version 2.5.

operator.ipow(a, b)

operator.__ipow__(a, b)

a = ipow(a, b) is equivalent to a **= b.

Nouveau dans la version 2.5.

operator.irepeat(a, b)

operator.__irepeat__(a, b)

Obsolète depuis la version 2.7: Use __imul__() instead.

a = irepeat(a, b) is equivalent to a *= b where a is a sequence and b is an integer.

Nouveau dans la version 2.5.

operator.irshift(a, b)

operator.__irshift__(a, b)

a = irshift(a, b) is equivalent to a >>= b.

Nouveau dans la version 2.5.

operator.isub(a, b)

operator.__isub__(a, b)

a = isub(a, b) is equivalent to a -= b.

Nouveau dans la version 2.5.

operator.itruediv(a, b)

operator.__itruediv__(a, b)

a = itruediv(a, b) is equivalent to a /= b when __future__.division is in effect.

Nouveau dans la version 2.5.

operator.ixor(a, b)

operator.__ixor__(a, b)

a = ixor(a, b) is equivalent to a ^= b.

Nouveau dans la version 2.5.

The operator module also defines a few predicates to test the type of objects; however, these are not all reliable. It is preferable to test abstract base classes instead (see collections and numbers for details).

operator.isCallable(obj)

Obsolète depuis la version 2.0: Use isinstance(x, collections.Callable) instead.

Returns true if the object obj can be called like a function, otherwise it returns false. True is returned for functions, bound and unbound methods, class objects, and instance objects which support the __call__() method.

operator.isMappingType(obj)

Obsolète depuis la version 2.7: Use isinstance(x, collections.Mapping) instead.

Returns true if the object obj supports the mapping interface. This is true for dictionaries and all instance objects defining __getitem__().

operator.isNumberType(obj)

Obsolète depuis la version 2.7: Use isinstance(x, numbers.Number) instead.

Returns true if the object obj represents a number. This is true for all numeric types implemented in C.

operator.isSequenceType(obj)

Obsolète depuis la version 2.7: Use isinstance(x, collections.Sequence) instead.

Returns true if the object obj supports the sequence protocol. This returns true for all objects which define sequence methods in C, and for all instance objects defining __getitem__().

Le module operator définit aussi des fonctions pour la recherche générique d’attributs ou d’objets. Elles sont particulièrement utiles pour construire rapidement des accesseurs d’attributs à passer en paramètre à map(), sorted(), itertools.groupby() ou à toute autre fonction prenant une fonction en paramètre.

operator.attrgetter(attr)

operator.attrgetter(*attrs)

Renvoie un objet appelable qui récupère attr de son opérande. Si plus d’un attribut est demandé, renvoie un n-uplet d’attributs. Les noms des attributs peuvent aussi comporter des points. Par exemple :

• Avec f = attrgetter('name'), l’appel f(b) renvoie b.name.

• Avec f = attrgetter('name', 'date'), l’appel f(b) renvoie (b.name, b.date).

• Après f = attrgetter('name.first', 'name.last'), l’appel f(b) renvoie (b.name.first, b.name.last).

Équivalent à :

def attrgetter(*items):
    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

Nouveau dans la version 2.4.

Modifié dans la version 2.5: Added support for multiple attributes.

Modifié dans la version 2.6: Added support for dotted attributes.

operator.itemgetter(item)

operator.itemgetter(*items)

Renvoie un objet appelable qui récupère item de l’opérande en utilisant la méthode __getitem__(). Si plusieurs item sont passés en paramètre, renvoie un n-uplet des valeurs récupérées. Par exemple :

• Avec f = itemgetter(2), f(r) renvoie r[2].

• Avec g = itemgetter(2, 5, 3), g(r) renvoie (r[2], r[5], r[3]).

Équivalent à :

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

Les items en entrée peuvent être de n’importe quel type tant que celui-ci est géré par la méthode __getitem__() de l’opérande. Les dictionnaires acceptent toute valeur hachable. Les listes, n-uplets et chaînes de caractères acceptent un index ou une tranche :

>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1,3,5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2,None))('ABCDEFG')
'CDEFG'

Nouveau dans la version 2.4.

Modifié dans la version 2.5: Added support for multiple item extraction.

Exemple d’utilisation de itemgetter() pour récupérer des champs spécifiques d’un n-uplet :

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

operator.methodcaller(name[, args...])

Renvoie un objet appelable qui appelle la méthode name de son opérande. Si des paramètres supplémentaires et/ou des paramètres nommés sont donnés, ils seront aussi passés à la méthode. Par exemple :

• Avec f = methodcaller('name'), f(b) renvoie b.name().

• Avec f = methodcaller('name', 'foo', bar=1), f(b) renvoie b.name('foo', bar=1).

Équivalent à :

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

Nouveau dans la version 2.6.

9.9.1. Correspondances entre opérateurs et fonctions

Le tableau montre la correspondance entre les symboles des opérateurs Python et les fonctions du module operator.

Opération	Syntaxe	Fonction
Addition	a + b	add(a, b)
Concaténation	seq1 + seq2	concat(seq1, seq2)
Test d’inclusion	obj in seq	contains(seq, obj)
Division	a / b	div(a, b) (without __future__.division)
Division	a / b	truediv(a, b) (with __future__.division)
Division	a // b	floordiv(a, b)
Et bit à bit	a & b	and_(a, b)
Ou exclusif bit à bit	a ^ b	xor(a, b)
Inversion bit à bit	~ a	invert(a)
Ou bit à bit	a | b	or_(a, b)
Exponentiation	a ** b	pow(a, b)
Identité	a is b	is_(a, b)
Identité	a is not b	is_not(a, b)
Affectation par index	obj[k] = v	setitem(obj, k, v)
Suppression par index	del obj[k]	delitem(obj, k)
Indexation	obj[k]	getitem(obj, k)
Décalage bit à bit gauche	a << b	lshift(a, b)
Modulo	a % b	mod(a, b)
Multiplication	a * b	mul(a, b)
Opposé	- a	neg(a)
Négation (logique)	not a	not_(a)
Valeur positive	+ a	pos(a)
Décalage bit à bit droite	a >> b	rshift(a, b)
Sequence Repetition	seq * i	repeat(seq, i)
Affectation par tranche	seq[i:j] = values	setitem(seq, slice(i, j), values)
Suppression par tranche	del seq[i:j]	delitem(seq, slice(i, j))
Tranche	seq[i:j]	getitem(seq, slice(i, j))
Formatage de chaînes de caractères	s % obj	mod(s, obj)
Soustraction	a - b	sub(a, b)
Test de véracité	obj	truth(obj)
Ordre	a < b	lt(a, b)
Ordre	a <= b	le(a, b)
Égalité	a == b	eq(a, b)
Différence	a != b	ne(a, b)
Ordre	a >= b	ge(a, b)
Ordre	a > b	gt(a, b)