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

最新推荐文章于 2022-08-07 16:18:49 发布
泡芙MM
最新推荐文章于 2022-08-07 16:18:49 发布
阅读量626
点赞数 1
分类专栏： Python
Python 专栏收录该内容
6 篇文章 0 订阅
订阅专栏
                        
 [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.csdn.net/dapeng0802/article/details/50490283)
泡芙MM
关注
1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Python标准库]operator——内置操作符的函数接口

[Python标准库]operator——内置操作符的函数接口        作用：内置操作符的函数接口。        Python 版本：1.4 及以后版本        使用迭代器编程时，有时需要...
复制链接

扫一扫