Yurttas/PL/SL/python/docs/core-python-programming/doc/20/lib/module-operator.html
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
1if 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
ina. 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
-1to 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)
See About this document... for information on suggesting changes.