GNU Info

(python2.1-lib.info)operator

---

Next: inspect Prev: UserString Up: Python Runtime Services

---

Enter node , (file) or (file)node

Standard operators as functions.
================================

This manual section was written by Skip Montanaro <skip@automatrix.com>.
All Python's standard operators as built-in 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(...)'
     _This is deprecated in Python 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)'
     _This is deprecated in Python 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)

Mapping Operators to Functions