Theoperator module exports a set of efficient functions corresponding tothe intrinsic operators of Python. For example,operator.add(x,y) isequivalent to the expressionx+y. The function names are those used forspecial class methods; variants without leading and trailing__ are alsoprovided for convenience.
The functions fall into categories that perform object comparisons, logicaloperations, mathematical operations and sequence operations.
The object comparison functions are useful for all objects, and are named afterthe rich comparison operators they support:
Perform “rich comparisons” betweena andb. Specifically,lt(a,b) isequivalent toa<b,le(a,b) is equivalent toa<=b,eq(a,b) is equivalent toa==b,ne(a,b) is equivalent toa!=b,gt(a,b) is equivalent toa>b andge(a,b) is equivalent toa>=b. Note that these functions can return any value, which mayor may not be interpretable as a Boolean value. SeeComparisons for more information about rich comparisons.
The logical operations are also generally applicable to all objects, and supporttruth tests, identity tests, and boolean operations:
Return the outcome ofnotobj. (Note that there is no__not__() method for object instances; only the interpreter core definesthis operation. The result is affected by the__bool__() and__len__() methods.)
ReturnTrue ifobj is true, andFalse otherwise. This isequivalent to using thebool constructor.
Returnaisb. Tests object identity.
Returnaisnotb. Tests object identity.
The mathematical and bitwise operations are the most numerous:
Returna converted to an integer. Equivalent toa.__index__().
Return the bitwise inverse of the numberobj. This is equivalent to~obj.
Returna/b where 2/3 is .66 rather than 0. This is also known as“true” division.
Operations which work with sequences (some of them with mappings too) include:
Return the outcome of the testbina. Note the reversed operands.
Return the number of occurrences ofb ina.
Return the index of the first of occurrence ofb ina.
Example: Build a dictionary that maps the ordinals from0 to255 totheir character equivalents.
>>>d={}>>>keys=range(256)>>>vals=map(chr,keys)>>>map(operator.setitem,[d]*len(keys),keys,vals)
Theoperator module also defines tools for generalized attribute and itemlookups. These are useful for making fast field extractors as arguments formap(),sorted(),itertools.groupby(), or other functions thatexpect a function argument.
Return a callable object that fetchesattr from its operand.If more than one attribute is requested, returns a tuple of attributes.The attribute names can also contain dots. For example:
Equivalent to:
defattrgetter(*items):ifany(notisinstance(item,str)foriteminitems):raiseTypeError('attribute name must be a string')iflen(items)==1:attr=items[0]defg(obj):returnresolve_attr(obj,attr)else:defg(obj):returntuple(resolve_attr(obj,attr)forattrinitems)returngdefresolve_attr(obj,attr):fornameinattr.split("."):obj=getattr(obj,name)returnobj
Return a callable object that fetchesitem from its operand using theoperand’s__getitem__() method. If multiple items are specified,returns a tuple of lookup values. For example:
Equivalent to:
defitemgetter(*items):iflen(items)==1:item=items[0]defg(obj):returnobj[item]else:defg(obj):returntuple(obj[item]foriteminitems)returng
The items can be any type accepted by the operand’s__getitem__()method. Dictionaries accept any hashable value. Lists, tuples, andstrings accept an index or a slice:
>>>itemgetter(1)('ABCDEFG')'B'>>>itemgetter(1,3,5)('ABCDEFG')('B', 'D', 'F')>>>itemgetter(slice(2,None))('ABCDEFG')'CDEFG'
Example of usingitemgetter() to retrieve specific fields from atuple record:
>>>inventory=[('apple',3),('banana',2),('pear',5),('orange',1)]>>>getcount=itemgetter(1)>>>list(map(getcount,inventory))[3, 2, 5, 1]>>>sorted(inventory,key=getcount)[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]
Return a callable object that calls the methodname on its operand. Ifadditional arguments and/or keyword arguments are given, they will be givento the method as well. For example:
Equivalent to:
defmethodcaller(name,*args,**kwargs):defcaller(obj):returngetattr(obj,name)(*args,**kwargs)returncaller
This table shows how abstract operations correspond to operator symbols in thePython syntax and the functions in theoperator module.
| Operation | Syntax | Function |
|---|---|---|
| Addition | a+b | add(a,b) |
| Concatenation | seq1+seq2 | concat(seq1,seq2) |
| Containment Test | objinseq | contains(seq,obj) |
| Division | a/b | truediv(a,b) |
| Division | a//b | floordiv(a,b) |
| Bitwise And | a&b | and_(a,b) |
| Bitwise Exclusive Or | a^b | xor(a,b) |
| Bitwise Inversion | ~a | invert(a) |
| Bitwise Or | a|b | or_(a,b) |
| Exponentiation | a**b | pow(a,b) |
| Identity | aisb | is_(a,b) |
| Identity | aisnotb | is_not(a,b) |
| Indexed Assignment | obj[k]=v | setitem(obj,k,v) |
| Indexed Deletion | delobj[k] | delitem(obj,k) |
| Indexing | obj[k] | getitem(obj,k) |
| Left Shift | a<<b | lshift(a,b) |
| Modulo | a%b | mod(a,b) |
| Multiplication | a*b | mul(a,b) |
| Negation (Arithmetic) | -a | neg(a) |
| Negation (Logical) | nota | not_(a) |
| Positive | +a | pos(a) |
| Right Shift | a>>b | rshift(a,b) |
| Slice Assignment | seq[i:j]=values | setitem(seq,slice(i,j),values) |
| Slice Deletion | delseq[i:j] | delitem(seq,slice(i,j)) |
| Slicing | seq[i:j] | getitem(seq,slice(i,j)) |
| String Formatting | s%obj | mod(s,obj) |
| Subtraction | a-b | sub(a,b) |
| Truth Test | obj | truth(obj) |
| Ordering | a<b | lt(a,b) |
| Ordering | a<=b | le(a,b) |
| Equality | a==b | eq(a,b) |
| Difference | a!=b | ne(a,b) |
| Ordering | a>=b | ge(a,b) |
| Ordering | a>b | gt(a,b) |
Many operations have an “in-place” version. Listed below are functionsproviding a more primitive access to in-place operators than the usual syntaxdoes; for example, thestatementx+=y is equivalent tox=operator.iadd(x,y). Another way to put it is to say thatz=operator.iadd(x,y) is equivalent to the compound statementz=x;z+=y.
In those examples, note that when an in-place method is called, the computationand assignment are performed in two separate steps. The in-place functionslisted below only do the first step, calling the in-place method. The secondstep, assignment, is not handled.
For immutable targets such as strings, numbers, and tuples, the updatedvalue is computed, but not assigned back to the input variable:
>>>a='hello'>>>iadd(a,' world')'hello world'>>>a'hello'
For mutable targets such as lists and dictionaries, the inplace methodwill perform the update, so no subsequent assignment is necessary:
>>>s=['h','e','l','l','o']>>>iadd(s,[' ','w','o','r','l','d'])['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']>>>s['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
10.2.functools — Higher-order functions and operations on callable objects
Enter search terms or a module, class or function name.
