This document is for an old version of Python that is no longer supported. You should upgrade and read the Python documentation for the current stable release.

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