# 3.4 Built-in Module `operator`

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)
  Return a `+` b, for a and b numbers.

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

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

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

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

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

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

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

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

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

`neg` (o)
  Return o negated.

`__neg__` (o)
  Return o negated.

`pos` (o)
  Return o positive.

`__pos__` (o)
  Return o positive.

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

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

`inv` (o)
  Return the inverse of o.

`__inv__` (o)
  Return the inverse of o.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`setslice` (a, b, c, v)
  Set the slice of a from index b to index c`-1` to the sequence 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)
  Delete the slice of a from index b to index c`-1`.

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