3.8 operator -- Standard operators as functions.
Keywords: lib

# 3.8 `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)
`__invert__` (o)
  Return the inverse of 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)