operator模块是python中内置的操作符函数接口，它定义了一些算术和比较内置操作的函数。operator模块是用c实现的，所以执行速度比python代码快。
逻辑操作
|
1
2
3
4
5
6
7
8
9
10
11
12
|
from operator import *a = [1, 2, 3]b = aprint 'a =', aprint 'b =', bprintprint '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) |
打印结果：
|
1
2
3
4
5
6
|
a = [1, 2, 3]b = [1, 2, 3]not_(a) : Falsetruth(a) : Trueis_(a, b) : Trueis_not(a, b): False |
可以通过结果知道，operator的一些操作函数与原本的运算是相同的。
比较操作符
operator提供丰富的比较操作。
|
1
2
3
4
5
6
7
8
|
a = 3b = 5print 'a =', aprint 'b =', bprintfor func in (lt, le, eq, ne, ge, gt): print '{0}(a, b):'.format(func.__name__), func(a, b) |
打印结果
|
1
2
3
4
5
6
7
8
9
|
a = 3b = 5lt(a, b): Truele(a, b): Trueeq(a, b): Falsene(a, b): Truege(a, b): Falsegt(a, b): False |
这些函数等价于<、<=、==、>=和>的表达式语法。
算术操作符
处理数字的算术操作符也得到支持。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
a, b, c, d = -1, 2, -3, 4print 'a =', aprint 'b =', bprint 'c =', cprint '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) |
打印结果
|
1
2
3
4
5
6
7
8
9
10
11
|
a = -1b = 2c = -3d = 4Positive/Negative:abs(a): 1neg(a): 1neg(b): -2pos(a): -1pos(b): 2 |
abs返回值得绝对值，neg返回(-obj), pos返回(+obj)。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
a = -2b = 5.0print 'a =', aprint 'b =', b print '\nArithmetic'print 'add(a, b) :', add(a, b)print 'div(a, b) :', div(a, b)print 'floordiv(a, b) :', floordiv(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 'truediv(a, b) :', truediv(a, b) |
打印结果
|
1
2
3
4
5
6
7
8
9
10
11
12
|
a = -2b = 5.0Arithmeticadd(a, b) : 3.0div(a, b) : -0.4floordiv(a, b) : -1.0mod(a, b) : 3.0 # 查看负数取模mul(a, b) : -10.0pow(a, b) : -32.0sub(a, b) : -7.0truediv(a, b) : -0.4 |
mod表示取模， mul 表示相乘，pow是次方, sub表示相减
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
a = 2b = 6print 'a =', aprint 'b =', bprint '\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) |
打印结果
|
1
2
3
4
5
6
7
8
9
10
|
a = 2b = 6Bitwise:and_(a, b) : 2invert(a) : -3lshift(a, b) : 128or_(a, b) : 6rshift(a, b) : 0xor(a, b) : 4 |
and 表示按位与, invert 表示取反操作, lshift表示左位移, or表示按位或, rshift表示右位移,xor表示按位异或。
原地操作符
即in-place操作， x += y 等同于 x = iadd(x, y), 如果复制给其他变量比如z = iadd(x, y)等同与z = x; z += y。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
a = 3b = 4c = [1, 2]d = ['a', 'b']print 'a =', aprint 'b =', bprint 'c =', cprint 'd =', dprinta = iadd(a, b)print 'a = iadd(a, b) =>', aprintc = iconcat(c, d)print 'c = iconcat(c, d) =>', c |
属性和元素的获取方法
operator模块最特别的特性之一就是获取方法的概念，获取方法是运行时构造的一些可回调对象，用来获取对象的属性或序列的内容，获取方法在处理迭代器或生成器序列的时候特别有用，它们引入的开销会大大降低lambda或Python函数的开销。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
from operator import *class MyObj(object): def __init__(self, arg): super(MyObj, self).__init__() self.arg = arg def __repr__(self): return 'MyObj(%s)' % self.argobjs = [MyObj(i) for i in xrange(5)]print "Object:", objsg = attrgetter("arg")vals = [g(i) for i in objs]print "arg values:", valsobjs.reverse()print "reversed:", objsprint "sorted:", sorted(objs, key=g) |
结果：
|
1
2
3
4
|
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)] |
属性获取方法类似于
|
1
|
lambda x, n='attrname':getattr(x,nz） |
元素获取方法类似于
|
1
|
lambda x,y=5:x[y] |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from operator import *l = [dict(val=-1*i) for i in xrange(4)]print "dictionaries:", lg = itemgetter("val")vals = [g(i) for i in l]print "values: ", valsprint "sorted:", sorted(l, key=g)l = [(i,i*-2) for i in xrange(4)]print "tuples: ", lg = itemgetter(1)vals = [g(i) for i in l]print "values:", valsprint "sorted:", sorted(l, key=g) |
结果如下：
|
1
2
3
4
5
6
|
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)] |
除了序列之外，元素获取方法还适用于映射。
结合操作符和定制类
operator模块中的函数通过相应操作的标准Python接口完成工作，所以它们不仅适用于内置类型，还适用于用户自定义类型。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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) |
结果如下所示：
|
1
2
|
TrueMyObj(3) |
类型检查
operator 模块还包含一些函数用来测试映射、数字和序列类型的API兼容性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
from operator import *class NoType(object): passclass MultiType(object): def __len__(self): return 0 def __getitem__(self, name): return "mapping" def __int__(self): return 0o = NoType()t = MultiType()for func in [isMappingType, isNumberType, isSequenceType]: print "%s(o):" % func.__name__, func(o) print "%s(t):" % func.__name__, func(t) |
结果如下：
|
1
2
3
4
5
6
|
isMappingType(o): FalseisMappingType(t): TrueisNumberType(o): FalseisNumberType(t): TrueisSequenceType(o): FalseisSequenceType(t): True |
但是这些测试并不完善，因为借口没有严格定义。
获取对象方法
使用methodcaller可以获取对象的方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
from operator import methodcallerclass Student(object): def __init__(self, name): self.name = name def getName(self): return self.namestu = Student("Jim")func = methodcaller('getName')print func(stu) # 输出Jim |
还可以给方法传递参数：
|
1
2
3
4
5
6
7
8
|
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 |
