[Python标准库]operator——内置操作符的函数接口

[Python标准库]operator——内置操作符的函数接口
        作用：内置操作符的函数接口。
        Python 版本：1.4 及以后版本
        使用迭代器编程时，有时需要为简单的表达式创建小函数。有些情况下，这些确实可以实现为 lambda 函数，不过对于某些操作根本不需要新函数。operator 模块定义了一些对应算术和比较内置操作的函数。
逻辑操作
        有一些函数可以用来确定一个值的相应 Boolean 值，将其取反来创建相反的 Boolean 值，以及比较对象查看它们是否相等。

from operator import *
 
a = -1
b = 5
 
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)

        not_() 后面有下划线，因为 not 是一个 Python 关键字。truth() 会应用 if 语句中测试一个表达式时所用的同样的逻辑。is_() 实现了 is 关键字使用的相同检查，is_not() 完成同样的测试，但返回相反的答案。
比较操作符
        所有富比较操作符都得到支持。

from operator import *
 
a = 1
b = 5.0
print 'a =', a
print 'b =', b
for func in (lt, le, eq, ne, ge, gt):
    print '%s(a, b):' % func.__name__, func(a, b)

        这些函数等价于使用 <、<=、==、>= 和 > 的表达式语法。
算术操作符
        处理数字值的算术操作符也得到支持。

from operator import *
 
a = -1
b = 5.0
c = 2
d = 6
 
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 '\nArithmetic:'
print 'add(a, b)     :', add(a, b)
print 'div(a, b)     :', div(a, b)
print 'div(d, c)     :', div(d, c)
print 'floordiv(a, b):', floordiv(a, b)
print 'floordiv(d, c):', floordiv(d, c)
print 'mod(a, b)     :', mod(a, b)
print 'mul(a, b)     :', mul(a, b)
print 'pow(c, d)     :', pow(c, d)
print 'sub(b, a)     :', sub(b, a)
print 'truediv(a, b) :', truediv(a, b)
print 'truediv(d, c) :', truediv(d, c)
 
print '\nBitwise:'
print 'and_(c, d)  :', and_(c, d)
print 'invert(c)   :', invert(c)
print 'lshift(c, d):', lshift(c, d)
print 'or_(c, d)   :', or_(c, d)
print 'rshift(d, c):', rshift(d, c)
print 'xor(c, d)   :', xor(c, d)

        有两个不同的除法操作符：floordiv()（Python 3.0 版本之前实现的整数除法）和 truediv()（浮点数除法）。
序列操作符
        处理序列的操作符可以划分为 4 组：建立序列、搜索元素、访问内容和从序列删除元素。

from operator import *
 
a = [ 1, 2, 3 ]
b = [ 'a', 'b', 'c' ]
 
print 'a =', a
print 'b =', b
 
print '\nConstructive:'
print '  concat(a, b):', concat(a, b)
print '  repeat(a, 3):', repeat(a, 3)
 
print '\nSearching:'
print '  contains(a, 1)  :', contains(a, 1)
print '  contains(b, "d"):', contains(b, "d")
print '  countOf(a, 1)   :', countOf(a, 1)
print '  countOf(b, "d") :', countOf(b, "d")
print '  indexOf(a, 5)   :', indexOf(a, 1)
 
print '\nAccess Items:'
print '  getitem(b, 1)            :', getitem(b, 1)
print '  getslice(a, 1, 3)        :', getslice(a, 1, 3)
print '  setitem(b, 1, "d")       :', setitem(b, 1, "d"),
print ', after b =', b
print '  setslice(a, 1, 3, [4, 5]):', setslice(a, 1, 3, [4, 5]),
print ', after a =', a
 
print '\nDestructive:'
print '  delitem(b, 1)    :', delitem(b, 1), ', after b =', b
print '  delslice(a, 1, 3):', delslice(a, 1, 3), ', after a=', a

        其中一些操作（如 setitem() 和 delitem()）会原地修改序列，而不返回任何值。
原地操作符
        除了标准操作符外，很多对象类型还通过一些特殊操作符（如 +=）支持“原地”修改。这些原地修改也有相应的等价函数。

from operator import *
 
a = -1
b = 5.0
c = [ 1, 2, 3]
d = [ 'a', 'b', 'c' ]
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 = oconcat(c, d) =>', c

        这些例子只展示了部分函数。
属性和元素“获取方法”
        operator 模块最特别的特性之一是获取方法（getter）的概念。获取方法是运行时构造的一些可回调对象，用来获取对象的属性或序列的内容。获取方法在处理迭代器或生成器序列时特别有用，它们引入的开销会大大低于 lambda 或 Python 函数的开销。

from operator import *
 
class MyObj(object):
    """example class for attrgetter"""
    def __init__(self, arg):
        super(MyObj, self).__init__()
        self.arg = arg
    def __repr__(self):
        return 'MyObj(%s)' % self.arg
 
l = [ MyObj(i) for i in xrange(5) ]
print 'objects   :', l
 
# Extract thr 'arg' value from each object
g = attrgetter('arg')
vals = [ g(i) for i in l ]
print 'arg values:', vals
 
# Sort using arg
l.reverse()
print 'reversed  :', l
print 'sorted    :', sorted(l, key=g)

        属性获取方法的工作类似于 lambda x, n='attrname':getattr(x, n);
        元素获取方法的工作类似于 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)
print
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)

        除了序列外，元素获取方法还适用于映射。
结合操作符和定制类
        operator 模块中的函数通过相应操作的标准 Python 接口完成工作，所以它们不仅适用于内置类型，还适用于用户定义的类。

from operator import *
 
class MyObj(object):
    """example class for attrgetter"""
    def __init__(self, val):
        super(MyObj, self).__init__()
        self.val = val
        return
    def __str__(self):
        return 'MyObj(%s)' % self.val
    def __lt__(self, other):
        """compare for less-than"""
        print 'Testing %s < %s' % (self, other)
        return self.val < other.val
    def __add__(self, other):
        """add values"""
        print 'Adding %s + %s' % (self, other)
        return MyObj(self.val + other.val)
a = MyObj(1)
b = MyObj(2)
 
print 'Comparison:'
print lt(a, b)
 
print '\nArithmetic:'
print add(a, b)

类型检查
        operator 模块还包含一些函数来测试映射、数字和序列的 API 兼容性。

from operator import *
 
class NoType(object):
    """Supports none of the type APIs"""
 
class MultiType(object):
    """Supports multiple type APIs"""
    def __len__(slef):
        return 0
    def __getitem__(slef, 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)

        这些测试并不完善，因为接口没有严格定义，不过通过这些测试，确实能让我们对支持哪些功能有所了解。

[添加链接描述](https://blog.youkuaiyun.com/dapeng0802/article/details/50490283)