The operator module is the built-in operator function interface in python. It defines some functions for arithmetic and comparison built-in operations. The operator module is implemented in C, so the execution speed is faster than Python code.
Logical operation
from operator import * a = [1, 2, 3] b = a print 'a =', a print 'b =', b print print 'not_(a) :', not_(a) print 'truth(a) :', truth(a) print 'is_(a, b) :', is_(a, b) print 'is_not(a, b) :', is_not(a, b)
Print result:
a = [1, 2, 3] b = [1, 2, 3] not_(a) : False truth(a) : True is_(a, b) : True is_not(a, b): False
You can know from the results that some operating functions of the operator are the same as the original operations.
Comparison operator
operator provides rich comparison operations.
a = 3 b = 5 print 'a =', a print 'b =', b print for func in (lt, le, eq, ne, ge, gt): print '{0}(a, b):'.format(func.__name__), func(a, b)
Print results
a = 3 b = 5 lt(a, b): True le(a, b): True eq(a, b): False ne(a, b): True ge(a, b): False gt(a, b): False
These functions are equivalent to <, < Expression syntax for =, ==, >=, and >.
Arithmetic operators
Arithmetic operators for working with numbers are also supported.
a, b, c, d = -1, 2, -3, 4 print 'a =', a print 'b =', b print 'c =', c print 'd =', d print '\nPositive/Negative:' print 'abs(a):', abs(a) print 'neg(a):', neg(a) print 'neg(b):', neg(b) print 'pos(a):', pos(a) print 'pos(b):', pos(b)
Print results
a = -1 b = 2 c = -3 d = 4 Positive/Negative: abs(a): 1 neg(a): 1 neg(b): -2 pos(a): -1 pos(b): 2
abs returns the absolute value, neg Return (-obj), pos returns (+obj).
a = -2 b = 5.0 print 'a =', a print 'b =', b print '\nArithmetic' print 'add(a, b) :', add(a, b) print 'p(a, b) :', p(a, b) print 'floorp(a, b) :', floorp(a, b) print 'mod(a, b) :', mod(a, b) print 'mul(a, b) :', mul(a, b) print 'pow(a, b) :', pow(a, b) print 'sub(a, b) :', sub(a, b) print 'truep(a, b) :', truep(a, b)
Print result
a = -2 b = 5.0 Arithmetic add(a, b) : 3.0 p(a, b) : -0.4 floorp(a, b) : -1.0 mod(a, b) : 3.0 # 查看负数取模 mul(a, b) : -10.0 pow(a, b) : -32.0 sub(a, b) : -7.0 truep(a, b) : -0.4
mod means taking modulus, mul means multiplying, pow is the power, sub means subtraction
a = 2 b = 6 print 'a =', a print 'b =', b print '\nBitwise:' print 'and_(a, b) :', and_(a, b) print 'invert(a) :', invert(a) print 'lshift(a, b) :', lshift(a, b) print 'or_(a, b) :', or_(a, b) print 'rshift(a, b) :', rshift(a, b) print 'xor(a, b) :', xor(a, b)
Print result
a = 2 b = 6 Bitwise: and_(a, b) : 2 invert(a) : -3 lshift(a, b) : 128 or_(a, b) : 6 rshift(a, b) : 0 xor(a, b) : 4
and It means bitwise AND, invert means negation operation, lshift means left shift, or means bitwise OR, rshift means right shift, and xor means bitwise XOR.
In-place operator
That is, in-place operation, x += y is equivalent to x = iadd(x, y), if copied to other variables such as z = iadd(x, y) is equivalent to z = x; z += y.
a = 3 b = 4 c = [1, 2] d = ['a', 'b'] print 'a =', a print 'b =', b print 'c =', c print 'd =', d print a = iadd(a, b) print 'a = iadd(a, b) =>', a print c = iconcat(c, d) print 'c = iconcat(c, d) =>', c
Getting methods for attributes and elements
One of the most special features of the operator module is the concept of getting methods, getting methods They are some callback objects constructed at runtime, used to obtain the properties of the object or the contents of the sequence. The acquisition methods are particularly useful when dealing with iterators or generator sequences. The overhead they introduce will greatly reduce the overhead of lambda or Python functions.
from operator import * class MyObj(object): def __init__(self, arg): super(MyObj, self).__init__() self.arg = arg def __repr__(self): return 'MyObj(%s)' % self.arg objs = [MyObj(i) for i in xrange(5)] print "Object:", objs g = attrgetter("arg") vals = [g(i) for i in objs] print "arg values:", vals objs.reverse() print "reversed:", objs print "sorted:", sorted(objs, key=g)
Result:
Object: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)] arg values: [0, 1, 2, 3, 4] reversed: [MyObj(4), MyObj(3), MyObj(2), MyObj(1), MyObj(0)] sorted: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]
The attribute acquisition method is similar to
lambda x, n='attrname':getattr(x,nz)
The element acquisition method is similar to
lambda x,y=5:x[y]
from operator import * l = [dict(val=-1*i) for i in xrange(4)] print "dictionaries:", l g = itemgetter("val") vals = [g(i) for i in l] print "values: ", vals print "sorted:", sorted(l, key=g) l = [(i,i*-2) for i in xrange(4)] print "tuples: ", l g = itemgetter(1) vals = [g(i) for i in l] print "values:", vals print "sorted:", sorted(l, key=g)
The results are as follows:
dictionaries: [{'val': 0}, {'val': -1}, {'val': -2}, {'val': -3}] values: [0, -1, -2, -3] sorted: [{'val': -3}, {'val': -2}, {'val': -1}, {'val': 0}] tuples: [(0, 0), (1, -2), (2, -4), (3, -6)] values: [0, -2, -4, -6] sorted: [(3, -6), (2, -4), (1, -2), (0, 0)]
In addition to sequences, element get methods also work with mappings.
Combining operators and custom classes
The functions in the operator module complete their work through the standard Python interface of the corresponding operation, so they are suitable not only for built-in types, but also for user-defined types type.
from operator import * class MyObj(object): def __init__(self, val): super(MyObj, self).__init__() self.val = val return def __str__(self): return "MyObj(%s)" % self.val def __lt__(self, other): return self.val < other.val def __add__(self, other): return MyObj(self.val + other.val) a = MyObj(1) b = MyObj(2) print lt(a, b) print add(a,b)
The result looks like this:
True MyObj(3)
Type check
The operator module also contains functions for testing API compatibility of mapping, numeric and sequence types.
from operator import * class NoType(object): pass class MultiType(object): def __len__(self): return 0 def __getitem__(self, name): return "mapping" def __int__(self): return 0 o = NoType() t = MultiType() for func in [isMappingType, isNumberType, isSequenceType]: print "%s(o):" % func.__name__, func(o) print "%s(t):" % func.__name__, func(t)
The results are as follows:
isMappingType(o): False isMappingType(t): True isNumberType(o): False isNumberType(t): True isSequenceType(o): False isSequenceType(t): True
But these tests are imperfect because of the excuse There is no strict definition.
Get the object method
Use methodcaller to get the method of the object.
from operator import methodcaller class Student(object): def __init__(self, name): self.name = name def getName(self): return self.name stu = Student("Jim") func = methodcaller('getName') print func(stu) # 输出Jim
You can also pass parameters to the method:
f=methodcaller('name', 'foo', bar=1) f(b) # return b.name('foo', bar=1) methodcaller方法等价于下面这个函数: def methodcaller(name, *args, **kwargs): def caller(obj): return getattr(obj, name)(*args, **kwargs) return caller
For more articles related to the use of operators in the operator module in Python, please pay attention to the PHP Chinese website!