【Python】operator模块

Python中operator模块提供了一套与 Python 的内置运算符对应的高效率函数。

不仅对应内置运算符，还可以获取方法。可优化涉及回调函数的运算性能，比lambda、Python函数的开销小、速度快。

import operator
 
[x for x in dir(operator) if not x.startswith('_')]
# 结果：
['abs', 'add', 'and_', 'attrgetter', 'call', 'concat', 'contains', 'countOf', 
'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand', 'iconcat',
 'ifloordiv', 'ilshift', 'imatmul', 'imod', 'imul', 'index', 'indexOf', 'inv', 
'invert', 'ior', 'ipow', 'irshift', 'is_', 'is_not', 'isub', 'itemgetter', 
'itruediv', 'ixor', 'le', 'length_hint', 'lshift', 'lt', 'matmul', 'methodcaller',
 'mod', 'mul', 'ne', 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift', 'setitem', 
'sub', 'truediv', 'truth', 'xor']

from operator import *

1、数学运算

注意：数字不可变。因此，原地运算符，会被计算，但不会被赋值，不改变原变量的数字。

注解：（假设8位二进制，最高位为符号位，负数用补码形式存储）

① 按位取反。inv(2)   结果：-3

2（二进制：00000010）：按位取反，则11111101（原码10000011，十进制：-3）。

② 左移。lshift(2,3)  结果：16

2（二进制：00000010）：左移3位，则00010000（十进制：16）。

③ 按位与。and_(2,3)   结果：2

2（二进制：00000010），3（二进制：00000011）：按位与，则00000010（十进制：2）。

按位与：1 & 1 = 1，1 & 0 = 0，0 & 0 = 0

按位或：1 | 1 = 1，1 | 0 = 1，0 | 0 = 0

按位异或：1 ^ 1 = 0，1 ^ 0 = 1，0 ^ 0 = 0

2、比较运算

lt：less than   小于

le：less than or equal to   小于等于

gt：greater than   大于

ge：greater than or equal to   大于等于

eq：equal to   等于

ne：not equal to   不等于​​​​​​​

3、逻辑运算

4、序列运算

注意：原地运算符中被赋值的序列需是可变的。若不可变的序列（字符串、元组），会计算但不会赋值，即不改变原序列。

add 和 iadd 也可以拼接序列，和concat结果相同。

5、3.11 新版功能

提供了快速访问对象的属性、获取序列元素、方法调用。

适合作为快速提取器（map, sorted, itertools.groupby等）的参数。

（5-1）attrgetter  【访问对象的属性】

• attrgetter(属性)(对象)：对象.属性，即获取对象的属性。
• attrgetter(属性1, 属性2 ...)(对象)：(对象.属性1, 对象.属性2,...)，即获取对象的多个属性，返回元组形式。

from operator import *
 
class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
p1 = People("Tom",18)
p2 = People("Jack",25)
 
get_age = attrgetter("age")
get_age(p1)                                   # 结果：18
get_age(p2)                                   # 结果：25
# 相当于         
p1.age                                        # 结果：18
p2.age                                        # 结果：25
         
get_all = attrgetter("name","age")
get_all(p1)                                   # 结果：('Tom', 18)
get_all(p2)                                   # 结果：('Jack', 25)
# 相当于
p1.name,p1.age                                # 结果：('Tom', 18)
p2.name,p2.age                                # 结果：('Jack', 25)
 
# attrgetter 比 lambda 速度快
list(map(get_age,[p1,p2]))                    # 结果：[18, 25]
# 相当于
list(map(lambda x:x.age,[p1,p2]))             # 结果：[18, 25]
 
list(map(get_all,[p1,p2]))                    # 结果：[('Tom', 18), ('Jack', 25)]
# 相当于  
list(map(lambda x:(x.name,x.age),[p1,p2]))    # 结果：[('Tom', 18), ('Jack', 25)]

（5-2）itemgetter  【获取序列的元素】

• itemgetter(下标)(序列) ：序列[下标]，即获取序列中下标对应的元素。
• itemgetter(slice(起始下标, 结束下标))(序列)：序列[起始下标:结束下标]，通过切片获取序列中的元素。
• itemgetter(下标1, 下标2, ...)(序列) ：(序列[下标1]，序列[下标2]，...)，即获取序列中多个下标对应的元素，返回元组形式。

from operator import *
 
a = "hello"
itemgetter(1)(a)                  # 结果：'e'
itemgetter(slice(1,4))(a)         # 结果：'ell'
itemgetter(1,2,4)(a)              # 结果：('e', 'l', 'o')

•  itemgetter(键)(字典) ：字典[键]，通过键获取字典中的值。
•  itemgetter(键1, 键2,...)(字典) ：(字典[键1], 字典[键2], ...)，通过多个键获取字典中的值，返回元组形式。

from operator import *
 
d = {'一季度':20,'二季度':50,'三季度':15,'四季度':35}
itemgetter('二季度')(d)                     # 结果：50
itemgetter('二季度','四季度')(d)            # 结果：(50, 35)

在sorted、map等使用时，itemgetter 比 lambda 速度快。

from operator import *
 
b = [("一季度",20),("二季度",50),("三季度",15),("四季度",35)]
# 按元组中下标为1的元素大小排序
sorted(b,key=itemgetter(1))       # 结果：[('三季度', 15), ('一季度', 20), ('四季度', 35), ('二季度', 50)]
# 相当于
sorted(b,key=lambda x:x[1])       # 结果：[('三季度', 15), ('一季度', 20), ('四季度', 35), ('二季度', 50)]
 
# 获取元组中下标为1的元素
list(map(itemgetter(1),b))        # 结果：[20, 50, 15, 35]
# 相当于
list(map(lambda x:x[1],b))        # 结果：[20, 50, 15, 35]

（5-3）methodcaller  【调用对象的方法】

• methodcaller(方法)(对象)：对象.方法()，即调用对象的方法。
• methodcaller(方法, 参数1, 参数2 ...)(对象)：对象.方法(参数1, 参数2,...)，即调用对象的方法，并传递参数。

from operator import *
 
class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def introduce(self):
        return f"我是{self.name}"
 
p1 = People("Tom",18)
 
intro = methodcaller("introduce")
intro(p1)                              # 结果：'我是Tom'
# 相当于
p1.introduce()                         # 结果：'我是Tom'