Python 的 functools 模块可以说主要是为函数式编程而设计，用于增强函数功能。

functools.partial

用于创建一个偏函数，它用一些默认参数包装一个可调用对象，返回结果是可调用对象，并且可以像原始对象一样对待，这样可以简化函数调用。实际上 partial 相当于一个高阶函数，其大致的实现如下（实际在标准库中它是用 C 实现的）：

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

一个简单的使用示例：

from functools import partial

def add(x, y):
    return x + y

add_y = partial(add, 3)  # add_y 是一个新的函数
add_y(4)

一个很实用的例子：

def json_serial_fallback(obj):
    """JSON serializer for objects not serializable by default json code"""
    if isinstance(obj, (datetime.datetime, datetime.date)):
        return str(obj)
    if isinstance(obj, bytes):
        return obj.decode("utf-8")
    raise TypeError ("%s is not JSON serializable" % obj)

json_dumps = partial(json.dumps, default=json_serial_fallback)

可以在 json_serial_fallback 函数中添加类型判断来指定如何 json 序列化一个 Python 对象

functools.update_wrapper

用 partial 包装的函数是没有 __name__ 和 __doc__，这使得依赖于这些属性的代码可能无法正常工作。update_wrapper 可以拷贝被包装函数的 __name__、__module__、__doc__ 和 __dict__ 属性到新的封装函数中去，其实现也非常简单：

WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__doc__')
WRAPPER_UPDATES = ('__dict__',)

def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):

    for attr in assigned:
        setattr(wrapper, attr, getattr(wrapped, attr))
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))

    return wrapper

update_wrapper 主要用在装饰器函数中，以确保被装饰的保留原理的属性。示例：

def wrap(func):
    def call_it(*args, **kwargs):
        print "calling", func.__name__
        return func(*args, **kwargs)
    return call_it

@wrap
def hello():
    print "hello"


from functools import update_wrapper

def wrap2(func):
    def call_it(*args, **kwargs):
        print "calling", func.__name__
        return func(*args, **kwargs)
    return update_wrapper(call_it, func)

@wrap2
def hello2():
    print "hello2"


# Script starts from here

if __name__ == '__main__':
    print hello.__name__  # call_it
    print hello2.__name__  # hello2

functool.wraps

wraps 函数是为了在装饰器中方便的拷贝被装饰函数的签名，而对 update_wrapper 做的一个包装，其实现如下：

def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):

    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

示例：

from functools import wraps

def wrap3(func):
    @wraps(func)
    def call_it(*args, **kwargs):
        print "calling", func.__name__
        return func(*args, **kwargs)
    return call_it

@wrap3
def hello3(func):
    print "hello3"

print hello3.__name__  # hello3

functools.reduce

在 Python2 中等同于内建函数 reduce，但是在 Python3 中内建的 reduce 函数被移除，只能使用 functools.reduce。该函数的作用是将一个序列归纳为一个输出，其原型如下：

reduce(function, sequence, startValue)

使用示例：

>>> def foo(x, y):
...     return x + y
...
>>> l = range(1, 10)
>>> reduce(foo, l)
45
>>> reduce(foo, l, 10)
55

functools.cmp_to_key

在 list.sort 和 内建函数 sorted 中都有一个 key 参数，这个参数用来指定取元素的什么值进行比较，例如按字符串元素的长度进行比较：

>>> x = ['hello','abc','iplaypython.com']
>>> x.sort(key=len)
>>> x
['abc', 'hello', 'iplaypython.com']

也就是说排序时会先对每个元素调用 key 所指定的函数，然后再排序。同时，sorted 和 list.sort 还提供了 cmp 参数来指定如何比较两个元素，但是在 Python 3 中该参数被去掉了。cmp_to_key 函数就是用来将老式的比较函数转化为 key 函数。用到 key 参数的函数还有 sorted(), min(), max(), heapq.nlargest(), itertools.groupby() 等。

functools.total_ordering

这个一个类装饰器，如果一个类实现了 __lt__、__le__、__gt__、__ge__ 这些方法中的至少一个，该装饰器会自动实现其他几个方法。示例：

from functools import total_ordering

@total_ordering
class Student:
    def __init__(self, firstname, lastname):
        self.firstname = firstname
        self.lastname = lastname

    def __eq__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))

    def __lt__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))

print dir(Student)

stu = Student("Huoty", "Kong")
stu2 = Student("Huoty", "Kong")
stu3 = Student("Qing", "Lu")

print stu == stu2
print stu > stu3

输出结果：

['__doc__', '__eq__', '__ge__', '__gt__', '__init__', '__le__', '__lt__', '__module__']
True
False

functools.lru_cache

这个装饰器是在 Python3 中新加的，在 Python2 中如果想要使用可以安装第三方库 functools32。该装饰器用于缓存函数的调用结果，对于需要多次调用的函数，而且每次调用参数都相同，则可以用该装饰器缓存调用结果，从而加快程序运行。示例：

from functools import lru_cache

@lru_cache(None)
def add(x, y):
    print("calculating: %s + %s" % (x, y))
    return x + y

print(add(1, 2))
print(add(1, 2))  # 直接返回缓存信息
print(add(2, 3))

输出结果：

calculating: 1 + 2
3
3
calculating: 2 + 3
5

由于该装饰器会将不同的调用结果缓存在内存中，因此需要注意内存占用问题，避免占用过多内存，从而影响系统性能。

functools.singledispatch

单分发器，Python 3.4 新增，用于实现泛型函数，由一个单一参数的类型来决定调用哪个函数。示例：

@singledispatch
def fun(arg, verbose=False):
    if verbose:
        print("Let me just say", end=" ")
    print(arg)


@fun.register(int)
def _(arg, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)


@fun.register(list)
def _(arg, verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)


fun("Hello world.")
fun(18)
fun(["a", "b"])

输出：

Hello world.
18
0 a
1 b

一个还可以支持多个泛型：

@fun.register(float)
@fun.register(Decimal)
def _(arg, verbose=False):
    print(arg)

fun.registry 中保存了所有的泛型函数，使用 fun.registry[float] 或者 fun.dispatch(float) 可以获取相应的函数:

>>> fun.registry
mappingproxy({int: <function singledispatch._>,
              float: <function singledispatch._>,
              list: <function singledispatch._>,
              object: <function singledispatch.fun>,
              decimal.Decimal: <function singledispatch._>})
>>> fun.dispatch(float)
<function singledispatch._>
>>> fun.registry[int]
<function singledispatch._>