# 3.5 `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)
`__inv__` (o)
  Return the inverse of o.

`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__()` discipline 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)
`sequenceIncludes` (a, b)
  Return the outcome of the test b `in` a. Note the reversed operands.

`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`.

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)