# 3.10 `operator` -- Standard operators as functions.

The `operator` module exports a set of functions implemented in C 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 `operator` module defines the following functions:

`add`(a, b)
`__add__`(a, b)
  Return a `+` b, for a and b numbers.

`sub`(a, b)
`__sub__`(a, b)
  Return a `-` b.

`mul`(a, b)
`__mul__`(a, b)
  Return a `*` b, for a and b numbers.

`div`(a, b)
`__div__`(a, b)
  Return a `/` b.

`mod`(a, b)
`__mod__`(a, b)
  Return a `%` b.

`neg`(o)
`__neg__`(o)
  Return o negated.

`pos`(o)
`__pos__`(o)
  Return o positive.

`abs`(o)
`__abs__`(o)
  Return the absolute value of o.

`inv`(o)
`invert`(o)
`__inv__`(o)
`__invert__`(o)
  Return the bitwise inverse of the number o. The names `invert()` and `__invert__()` were added in Python 2.0.

`lshift`(a, b)
`__lshift__`(a, b)
  Return a shifted left by b.

`rshift`(a, b)
`__rshift__`(a, b)
  Return a shifted right by b.

`and_`(a, b)
`__and__`(a, b)
  Return the bitwise and of a and b.

`or_`(a, b)
`__or__`(a, b)
  Return the bitwise or of a and b.

`xor`(a, b)
`__xor__`(a, b)
  Return the bitwise exclusive or of a and b.

`not_`(o)
`__not__`(o)
  Return the outcome of `not` o. (Note that there is no `__not__()` method for object instances; only the interpreter core defines this operation.)

`truth`(o)
  Return `1` if o is true, and 0 otherwise.

`concat`(a, b)
`__concat__`(a, b)
  Return a `+` b for a and b sequences.

`repeat`(a, b)
`__repeat__`(a, b)
  Return a `*` b where a is a sequence and b is an integer.

`contains`(a, b)
`__contains__`(a, b)
  Return the outcome of the test b `in` a. Note the reversed operands. The name `__contains__()` was added in Python 2.0.

`sequenceIncludes`(...)
  Deprecated since release 2.0. Use `contains()` instead.

  Alias for `contains()`.

`countOf`(a, b)
  Return the number of occurrences of b in a.

`indexOf`(a, b)
  Return the index of the first of occurrence of b in a.

`getitem`(a, b)
`__getitem__`(a, b)
  Return the value of a at index b.

`setitem`(a, b, c)
`__setitem__`(a, b, c)
  Set the value of a at index b to c.

`delitem`(a, b)
`__delitem__`(a, b)
  Remove the value of a at index b.

`getslice`(a, b, c)
`__getslice__`(a, b, c)
  Return the slice of a from index b to index c`-1`.

`setslice`(a, b, c, v)
`__setslice__`(a, b, c, v)
  Set the slice of a from index b to index c`-1` to the sequence v.

`delslice`(a, b, c)
`__delslice__`(a, b, c)
  Delete the slice of a from index b to index c`-1`.

The `operator` also defines a few predicates to test the type of objects. Note: Be careful not to misinterpret the results of these functions; only `isCallable()` has any measure of reliability with instance objects. For example:

      >>> class C:
      ...     pass
      ...
      >>> import operator
      >>> o = C()
      >>> operator.isMappingType(o)
      1

`isCallable`(o)
  Deprecated since release 2.0. Use the `callable()` built-in function instead.

  Returns true if the object o 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.

`isMappingType`(o)
  Returns true if the object o supports the mapping interface. This is true for dictionaries and all instance objects. Warning: There is no reliable way to test if an instance supports the complete mapping protocol since the interface itself is ill-defined. This makes this test less useful than it otherwise might be.

`isNumberType`(o)
  Returns true if the object o represents a number. This is true for all numeric types implemented in C, and for all instance objects. Warning: There is no reliable way to test if an instance supports the complete numeric interface since the interface itself is ill-defined. This makes this test less useful than it otherwise might be.

`isSequenceType`(o)
  Returns true if the object o supports the sequence protocol. This returns true for all objects which define sequence methods in C, and for all instance objects. Warning: There is no reliable way to test if an instance supports the complete sequence interface since the interface itself is ill-defined. This makes this test less useful than it otherwise might be.

Example: Build a dictionary that maps the ordinals from `0` to `256` to their character equivalents.

      >>> import operator
      >>> d = {}
      >>> keys = range(256)
      >>> vals = map(chr, keys)
      >>> map(operator.setitem, [d]*len(keys), keys, vals)

Subsections

- 3.10.1 Mapping Operators to Functions