Python 中的 operator 模块和 functools 模块主要用于函数式编程
operator 模块
1）算术运算符函数
函数式编程中，经常需要把算术运算符当作函数使用，例如求阶乘
使用 lambda 的例子
from functools import reduce
def fact(n):
return reduce(lambda a, b: a * b, range(1, n+1))
使用 operator 模块的例子
from functools import reduce
from operator import mul
def fact(n):
return reduce(mul, range(1, n+1))
operator 模块位多个运算符提供了对应的函数，从而避免了写 lambda 表达式，形式上更简洁，类似的还有 add、sub 等函数
2）itemgetter
itemgetter 函数用于从序列中（根据索引）或者映射类型中（根据键）读取元素
>>> from operator import itemgetter
>>>
>>>
>>> a = ['h', 'e', 'l', 'l', 'o']
>>> b = (2, 3, 4)
>>> c = range(5)
>>> f = itemgetter(1) # 区索引为 1 位置的值
>>> f(a)
'e'
>>> f(b)
3
>>> f(c)
1
>>> d = {'name': 'hhh', 'age': 18}
>>> f = itemgetter('name') # 取键为 name 的元素
>>> f(d)
'hhh'
itemgetter 返回的是一个可调用对象，其参数是序列或者映射类型
itemgetter 多用于作为高阶函数的参数
>>> users = [{'name': '犬夜叉', 'age': 100}, {'name': '戈薇', 'age': 14}, {'name': '珊瑚', 'age': 20},{'name': '弥勒', 'age': 22}]
>>> users.sort(key=itemgetter('age')) # 按年龄排序
>>> print(users)
[{'name': '戈薇', 'age': 14}, {'name': '珊瑚', 'age': 20}, {'name': '弥勒', 'age': 22}, {'name': '犬夜叉', 'age': 100}]
事实上，itemgetter 不仅支持序列和映射类型，还支持任何实现了 __getitem__ 方法的类
如果 itemgetter 传入多个参数，返回的结果会是一个元组
>>> a = [1, 2, 3, 4, 5]
>>> f = itemgetter(0, -1)
>>> f(a)
(1, 5)
3）attrgetter
attrgetter 与 itemgetter 作用类似，它根据名称提取对象的属性
>>> from collections import namedtuple
>>> from operator import attrgetter
>>> profile = namedtuple('Profile', ['name', 'age', 'hobby'])
>>>
>>> profile
<class '__main__.Profile'>
>>> quanyecha = profile(name='犬夜叉', age=100, hobby='坐下')
>>> f = attrgetter('name', 'age')
>>>
>>> f(quanyecha)
('犬夜叉', 100)
可以看到 attrgetter 跟 itemgetter 几乎一样，也可以传入多个参数获取元组
attragettter 还可以传入带 . 的参数，attrgetter 会深入嵌套对象，获取指定的属性
>>> profile = namedtuple('Profile', ['name', 'age', 'spouse'])
>>>
>>> gewei = profile(name='戈薇', age=14, spouse='犬夜叉')
>>> quanyecha = profile(name='犬夜叉', age=100, spouse=gewei)
>>>
>>> get_spouse_name = attrgetter('spouse.name')
>>> get_spouse_age = attrgetter('spouse.age')
>>>
>>> get_spouse_name(quanyecha)
'戈薇'
>>> get_spouse_age(quanyecha)
14
functools 模块
functools 模块提供了一系列高阶函数，最常见的是 reduce ，除了 reduce ，还有 partial 函数比较有用
1）reduce
reduce 用于把某个操作连续运用到序列的元素上，累计之前的结果，把一系列归约成一个值
>>> from functools import reduce
>>> from operator import add
>>> reduce(add, range(100))
4950
2）partial
partial 用于部分应用一个函数，部分应用指基于一个函数创建一个新的可调用对象，把原函数的某些参数固定
先来看一个简单的例子
>>> from functools import partial
>>> from operator import mul
>>> from functools import partial
>>> triple = partial(mul, 3)
>>> triple(6)
18
>>> list(map(triple, range(1,10)))
[3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> triple.func
<built-in function mul>
>>>
>>> triple.args
(3,)
其中 mul 函数接收两个参数，partial(mul, 3) 返回一个可调用对象，把 mul 函数的第一个参数固定为 3，这样之后再调用这个可调用对象就只需要传入一个参数
下面来看一个笔画排序的例子
class Stroke:
"""汉字笔画排序"""
@classmethod
def get_stroke_order(cls, chars: str):
"""获取排序"""
return tuple(cls.stroke.get(i, math.inf) for i in chars)
@classmethod
def compare(cls, a: tuple, b: tuple):
for a_i, b_i in itertools.zip_longest(a, b, fillvalue=0):
if a_i < b_i:
return -1
elif a_i > b_i:
return 1
else:
pass
return 0
@classmethod
def compare_by_stroke(cls, x, y, key: Callable):
a = key(x)
b = key(y)
return cls.compare(a, b)
@classmethod
def sort_by_stroke(cls, obj: Iterable, key: Callable):
cmp = functools.partial(cls.compare_by_stroke, key=key)
return sorted(obj, key=functools.cmp_to_key(cmp))
Stroke 的使用方式为
>>> pprint(p)
[{'age': 19, 'name': '陈世美', 'score': 29},
{'age': 18, 'name': '张大千', 'score': 27},
{'age': 29, 'name': '林强', 'score': 34},
{'age': 56, 'name': '王大志', 'score': 21},
{'age': 34, 'name': '王大', 'score': 32},
{'age': 67, 'name': '王大福', 'score': 13}]
>>>
>>> for i in p:
... i['order'] = Stroke.get_stroke_order(i['name'])
>>> q = Stroke.sort_by_stroke(p, lambda x: x['order'])
上面的例子里把 cls.compare_by_stroke 函数的 key 参数固定住，返回一个可调用对象，再通过可调用对象作为 sorted 函数的 key 来排序
个人认为 partial 函数的作用在于定制化，先写一个通用的函数，然后根据实际需要固定这个函数里的某些参数得到新的可调用对象
补充说一下，上面的 cmp_to_key 是一种兼容的做法，Python3 不支持比较函数，再一些接受 key 的函数中（例如 sorted，sort，min，max），key 仅仅支持一个参数，就无法实现两个参数之间的比较，采用 cmp_to_key，可以接受两个参数，将两个参数做处理，转换成一个参数，就可以应用于 key 关键字之后
>>> from functools import cmp_to_key
>>> l = ['2', '3', '1', '10', 8]
>>> sorted(l, key=cmp_to_key(lambda x,y:int(x)-int(y)))
['1', '2', '3', 8, '10']