operator模块的作用
内置操作符的函数接口
使用迭代器编程时,有时需要为简单的表达式创建小函数。有些情况下,尽管这确认可以被实现为lambda函数,但某些操作根本不需要新函数。operator模块定义了一些函数,可以对应标准对象API中内置的算术,比较和其它操作。
1、逻辑操作示例
from operator import not_, truth, is_, is_not
a = -1
b = 5
print('a =', a)
print('b =', b)
print()
print('not_(a) :', not_(a)) # 判断是否为空
print('truth(a) :', truth(a)) # 判断对象为0或False,则返回False
print('is_(a, b) :', is_(a, b)) # 判断两个值是否相等,相等则返回True
print('is_not(a, b):', is_not(a, b)) # 判断两个值是否相等,相等则False
operator_boolean.py
运行效果
a = a
b = a
is_(a, b) : True
is_not(a, b): False
2、比较操作的示例
from operator import lt, le, eq, ne, ge, gt
a = 1
b = 5.0
print('a =', a)
print('b =', b)
for func in (lt, le, eq, ne, ge, gt):
print('{}(a, b): {}'.format(func.__name__, func(a, b)))
operator_comparisons.py
运行效果
a = 1
b = 5.0
lt(a, b): True
le(a, b): True
eq(a, b): False
ne(a, b): True
ge(a, b): False
gt(a, b): False
3、算术运算
from operator import abs, neg, pos, add, floordiv, mod, mul, sub, truediv, and_, or_, invert, lshift, rshift, xor
a = -1
b = 5.0
c = 2
d = 6
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)
print('正负数的运算:')
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('算术的运算:')
print('add(a, b) :', add(a, b)) # 加法
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)) # 取反运算
operator_math.py
运行效果
a = -1
b = 5.0
c = 2
d = 6
正负数的运算:
abs(a): 1
neg(a): 1
neg(b): -5.0
pos(a): -1
pos(b): 5.0
add(a, b) : 4.0
floordiv(a, b): -1.0
floordiv(d, c): 3
mod(a, b) : 4.0
mul(a, b) : -5.0
pow(c, d) : 64
sub(b, a) : 6.0
truediv(a, b) : -0.2
truediv(d, c) : 3.0
and_(c, d) : 2
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('\nSearching:')
print(' contains(a, 1) :', contains(a, 1)) # 判断a列表是否包含1
print(' contains(b, "d"):', contains(b, "d")) # 判断b列表是否包含d
print(' countOf(a, 1) :', countOf(a, 1)) # 获取a列表,1元素的个数
print(' countOf(b, "d") :', countOf(b, "d")) # 获取b列表,d元素的个数
print(' indexOf(a, 5) :', indexOf(a, 1)) # 在a列表中,1元素的下标位置
print('\nAccess Items:')
print(' getitem(b, 1) :',
getitem(b, 1)) # 获取b列表下标为1的元素
print(' getitem(b, slice(1, 3)) :',
getitem(b, slice(1, 3))) # 切片取元素
print(' setitem(b, 1, "d") :', end=' ')
setitem(b, 1, "d") # 在下标1设置元素d
print(b)
print(' setitem(a, slice(1, 3), [4, 5]):', end=' ')
setitem(a, slice(1, 3), [4, 5]) # 切片获取元素,并且修改元素
print(a)
print('\nDestructive:')
print(' delitem(b, 1) :', end=' ')
delitem(b, 1) # 删除下标为1的元素
print(b)
print(' delitem(a, slice(1, 3)):', end=' ')
delitem(a, slice(1, 3)) # 切片获取元素,并且删除
print(a)
operator_sequences.py
运行效果
a = [1, 2, 3]
b = ['a', 'b', 'c']
Constructive:
concat(a, b): [1, 2, 3, 'a', 'b', 'c']
Searching:
contains(a, 1) : True
contains(b, "d"): False
countOf(a, 1) : 1
countOf(b, "d") : 0
indexOf(a, 5) : 0
Access Items:
getitem(b, 1) : b
getitem(b, slice(1, 3)) : ['b', 'c']
setitem(b, 1, "d") : ['a', 'd', 'c']
setitem(a, slice(1, 3), [4, 5]): [1, 4, 5]
Destructive:
delitem(b, 1) : ['a', 'c']
delitem(a, slice(1, 3)): [1]
5、在原来的元素进行运算的示例
from operator import iadd, iconcat
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) # a += b ,相当于在原来的元素进行相加
print('a = iadd(a, b) =>', a)
print()
c = iconcat(c, d) # a += b,
print('c = iconcat(c, d) =>', c)
operator_inplace.py
运行效果
a = -1
b = 5.0
c = [1, 2, 3]
d = ['a', 'b', 'c']
a = iadd(a, b) => 4.0
c = iconcat(c, d) => [1, 2, 3, 'a', 'b', 'c']
6、类属性和元素的获取方法
from operator import *
class MyObj:
"""example class for attrgetter"""
def __init__(self, arg):
super().__init__()
self.arg = arg
def __repr__(self):
return 'MyObj({})'.format(self.arg)
l = [MyObj(i) for i in range(5)]
print('objects :', l)
# Extract the '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))
operator_attrgetter.py
运行效果
objects : [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)]
7、获取字典或元组的值或key,然后进行排序的示例(推荐)
from operator import itemgetter
l = [dict(val=-1 * i) for i in range(4)]
print('Dictionaries:')
print(' original:', 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 range(4)]
print('\nTuples:')
print(' original:', l)
g = itemgetter(1)
vals = [g(i) for i in l]
print(' values:', vals)
print(' sorted:', sorted(l, key=g))
operator_itemgetter.py
运行效果
Dictionaries:
original: [{'val': 0}, {'val': -1}, {'val': -2}, {'val': -3}]
values: [0, -1, -2, -3]
sorted: [{'val': -3}, {'val': -2}, {'val': -1}, {'val': 0}]
Tuples:
original: [(0, 0), (1, -2), (2, -4), (3, -6)]
values: [0, -2, -4, -6]
sorted: [(3, -6), (2, -4), (1, -2), (0, 0)]
8、进行类的比较和算术运算
from operator import *
class MyObj:
"""Example for operator overloading"""
def __init__(self, val):
super(MyObj, self).__init__()
self.val = val
def __str__(self):
return 'MyObj({})'.format(self.val)
def __lt__(self, other):
"""compare for less-than"""
print('Testing {} < {}'.format(self, other))
return self.val < other.val
def __add__(self, other):
"""add values"""
print('Adding {} + {}'.format(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_classes.py
运行效果
Comparison:
Testing MyObj(1) < MyObj(2)
True
Arithmetic:
Adding MyObj(1) + MyObj(2)
MyObj(3)