operator
— Opérateurs standards en tant que fonctions¶
Code source : Lib/operator.py
Le module operator
fournit un ensemble de fonctions correspondant aux opérateurs natifs de Python. Par exemple, operator.add(x, y)
correspond à l'expression x+y
. Les noms de la plupart de ces fonctions sont ceux utilisés par les méthodes spéciales, sans les doubles tirets bas. Pour assurer la rétrocompatibilité, la plupart de ces noms ont une variante avec les doubles tirets bas ; la forme simple est cependant à privilégier pour des raisons de clarté.
Les fonctions sont divisées en différentes catégories selon l'opération effectuée : comparaison entre objets, opérations logiques, opérations mathématiques ou opérations sur séquences.
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)¶
Effectue une « comparaison riche » entre a et b. Plus précisément,
lt(a, b)
équivaut àa < b
,le(a, b)
équivaut àa <= b
,eq(a, b)
équivaut àa == b
,ne(a, b)
équivaut àa != b
,gt(a, b)
équivaut àa > b
etge(a, b)
équivaut àa >= b
. Notez que ces fonctions peuvent renvoyer n'importe quelle valeur, convertible ou non en booléen. Voir Comparaisons pour plus d'informations sur les méthodes de comparaison riches.
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__bool__()
and__len__()
methods.)
- operator.truth(obj)¶
Renvoie
True
si obj est vrai, etFalse
dans le cas contraire. Équivaut à utiliser le constructeur debool
.
- operator.is_(a, b)¶
Renvoie
a is b
. Vérifie si les deux paramètres sont le même objet.
- operator.is_not(a, b)¶
Renvoie
a is not b
. Vérifie si les deux paramètres sont deux objets distincts.
Les opérations mathématiques ou bit à bit sont les plus nombreuses :
- operator.index(a)¶
- operator.__index__(a)¶
Renvoie a converti en entier. Équivaut à
a.__index__()
.Modifié dans la version 3.10: The result always has exact type
int
. Previously, the result could have been an instance of a subclass ofint
.
- operator.inv(obj)¶
- operator.invert(obj)¶
- operator.__inv__(obj)¶
- operator.__invert__(obj)¶
Renvoie l'inverse bit à bit du nombre obj. Équivaut à
~obj
.
- operator.lshift(a, b)¶
- operator.__lshift__(a, b)¶
Renvoie le décalage de b bits vers la gauche de a.
- operator.rshift(a, b)¶
- operator.__rshift__(a, b)¶
Renvoie le décalage de b bits vers la droite de a.
- operator.truediv(a, b)¶
- operator.__truediv__(a, b)¶
Renvoie
a / b
où 2/3 est 0.66 et non 0. Appelée aussi division « réelle ».
Les opérations sur séquences (et pour certaines, sur correspondances) sont :
- 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.
- operator.countOf(a, b)¶
Renvoie le nombre d’occurrences de b dans a.
- operator.indexOf(a, b)¶
Renvoie l'indice de la première occurrence de b dans a.
- operator.length_hint(obj, default=0)¶
Return an estimated length for the object obj. First try to return its actual length, then an estimate using
object.__length_hint__()
, and finally return the default value.Nouveau dans la version 3.4.
The following operation works with callables:
- operator.call(obj, /, *args, **kwargs)¶
- operator.__call__(obj, /, *args, **kwargs)¶
Return
obj(*args, **kwargs)
.Nouveau dans la version 3.11.
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'appelf(b)
renvoieb.name
.Avec
f = attrgetter('name', 'date')
, l'appelf(b)
renvoie(b.name, b.date)
.Après
f = attrgetter('name.first', 'name.last')
, l'appelf(b)
renvoie(b.name.first, b.name.last)
.
Équivalent à :
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)
Return a callable object that fetches item from its operand using the operand's
__getitem__()
method. If multiple items are specified, returns a tuple of lookup values. For example:Avec
f = itemgetter(2)
,f(r)
renvoier[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
The items can be any type accepted by the operand's
__getitem__()
method. Dictionaries accept any hashable value. Lists, tuples, and strings accept an index or a 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'
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) >>> 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)¶
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)
renvoieb.name()
.Avec
f = methodcaller('name', 'foo', bar=1)
,f(b)
renvoieb.name('foo', bar=1)
.
Équivalent à :
def methodcaller(name, /, *args, **kwargs): def caller(obj): return getattr(obj, name)(*args, **kwargs) return caller
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 |
|
|
Concaténation |
|
|
Test d'inclusion |
|
|
Division |
|
|
Division |
|
|
Et bit à bit |
|
|
Ou exclusif bit à bit |
|
|
Inversion bit à bit |
|
|
Ou bit à bit |
|
|
Exponentiation |
|
|
Identité |
|
|
Identité |
|
|
Affectation par index |
|
|
Suppression par index |
|
|
Indexation |
|
|
Décalage bit à bit gauche |
|
|
Modulo |
|
|
Multiplication |
|
|
Multiplication matricielle |
|
|
Opposé |
|
|
Négation (logique) |
|
|
Valeur positive |
|
|
Décalage bit à bit droite |
|
|
Affectation par tranche |
|
|
Suppression par tranche |
|
|
Tranche |
|
|
Formatage de chaînes de caractères |
|
|
Soustraction |
|
|
Test de véracité |
|
|
Ordre |
|
|
Ordre |
|
|
Égalité |
|
|
Inégalité |
|
|
Ordre |
|
|
Ordre |
|
|
Opérateurs en-place¶
Beaucoup d'opérations ont une version travaillant « en-place ». Les fonctions listées ci-dessous fournissent un accès plus direct aux opérateurs en-place que la syntaxe Python habituelle ; par exemple, l'expression statement x += y
équivaut à x = operator.iadd(x, y)
. Autrement dit, l'expression z = operator.iadd(x, y)
équivaut à l'expression composée z = x; z += y
.
Dans ces exemples, notez que lorsqu'une méthode en-place est appelée, le calcul et l'affectation sont effectués en deux étapes distinctes. Les fonctions en-place de la liste ci-dessous ne font que la première, en appelant la méthode en-place. La seconde étape, l'affectation, n'est pas effectuée.
Pour des paramètres non-mutables comme les chaînes de caractères, les nombres et les n-uplets, la nouvelle valeur est calculée, mais pas affectée à la variable d'entrée :
>>> a = 'hello'
>>> iadd(a, ' world')
'hello world'
>>> a
'hello'
Pour des paramètres mutables comme les listes et les dictionnaires, la méthode en-place modifiera la valeur, aucune affectation ultérieure n'est nécessaire :
>>> 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.iconcat(a, b)¶
- operator.__iconcat__(a, b)¶
a = iconcat(a, b)
équivaut àa += b
où a et b sont des séquences.