什么是functools?

functools 是一个 Python 内置模块，包含可以与其他函数交互的高阶函数。可以在Python官方网站找到完整的 functools 文档。

网站链接：
https://docs.python.org/3/library/functools.html

lru_缓存

当以相同的参数调用一个函数时，functools 模块中的这个装饰器将 n 次函数调用保存在缓存中，从而节省了大量时间。
为了演示，假设我们有一个非常大的函数，需要很长时间才能执行。在此示例中，函数a_heavy_operation()需要 3 秒才能执行。

import time

start = time.time()
def a_heavy_operation():
    time.sleep(3)
    return 11 + 22


print(a_heavy_operation())
print(a_heavy_operation())

print(time.time() - start)

# 输出
# 33 
#33 
#6.024240255355835

运行上述代码大约需要 6 秒。对于上述功能，我们将添加 lru 缓存。

import time
from functools import lru_cache

start = time.time()


@lru_cache()
def a_heavy_operation():
    time.sleep(3)
    return 11 + 22


print(a_heavy_operation())
print(a_heavy_operation())

print(time.time() - start)

# Output
# 33
# 33
# 3.0158064365386963

看看使用 lru 缓存如何使我们的代码运行得更快。Python 保存函数的缓存并检索缓存值，减少了我们的执行时间。

Wraps

在 functools 中使用 Wraps 来保留函数的细节。当我们装饰一个函数时，函数的信息就没有了。我们在装饰器包装函数上使用 @wraps 装饰器来防止这种情况。

看看这段代码就明白我的意思了。

from functools import lru_cache

def my_decorator(func):
    def log(*args, **kwargs):
        print("Running ")
        return func(*args, *kwargs)

    return log

@my_decorator
def add(a, b):
    """my beautiful doc"""
    return a + b

使用 -i 模式运行上面的代码，python -i file.py

>>> add(1,2)
Running 
3
>>> add(3,4)
Running 
7
>>> add.__name__
log
>>> add.__doc__
>>>

我们可以看到我们的装饰器在前面的示例中运行正常，因为它在每次运行时始终“运行”。但是，我们函数的信息已经丢失，无法返回名称或文档字符串。

我们有@wraps 来帮助我们解决这个问题。对代码进行以下更改。

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def log(*args, **kwargs):
        print("Running ")
        return func(*args, *kwargs)

    return log


@my_decorator
def add(a, b):
    """my beautiful doc"""
    return a + b

现在再次使用运行代码python -i file.py

>>> add(1,2) 
Running 
3       
>>> add.__name__
'add'
>>> add.__doc__
'my beautiful doc'
>>>

现在功能信息现在保存在我们的功能中。

singledispatch

要创建通用函数，可以使用 singledispatch。通用函数是那些对各种数据类型执行相同操作的函数。

假设我想创建一个函数，该函数从多种数据类型的可迭代对象中返回第一个值。

def return_first_element(data):
    if isinstance(data, list):
        print(data[0])
    elif isinstance(data, str):
        print(data.split()[0])
    elif isinstance(data, dict):
        print(list(data.values())[0] )
    else:
        print(print(data))

现在运行python -i file.py以交互模式运行代码。

>>> return_first_element({"Age":20, "Height": 180})
20
>>> return_first_element("Hello Mr Python")
Hello
>>> return_first_element([12,432,563])      
12
>>>

我们的功能是有效的，但它并不干净。不建议在 Python 中使用 if/elif/else 语句来创建泛型函数。那么，解决方案是什么？singledispatch，当然。

让我们对代码做一些修改。

from functools import singledispatch

@singledispatch
def return_first_el(data):
    return data


@return_first_el.register(list)
def _(data):
    return data[0]


@return_first_el.register(dict)
def _(data):
    return list(data.values())[0]


@return_first_el.register(str)
def _(data):
    return data.split()[0]

要检查结果，请使用python -i file.py在交互模式下再次运行代码。

>>> return_first_el({"Age":20, "Height": 180}) 
20 
>>> return_first_el("Hello Mr Python")              
'你好' 
>>> return_first_el([124, 765, 897])    
124 
>> > return_first_el({12,31,1})        
{1, 12, 31}

看看return_first_el当没有数据类型与“set”匹配时，我们的函数如何充当回退函数。

看看我们的代码现在干净多了；singledispatch 使得添加更多数据类型变得更容易，并且每个数据类型现在都有自己的位置，我们可以在其中对数据执行进一步的操作。

total_ordering

total_ordering 装饰器在面向对象编程中节省了大量时间。
考虑这个例子，下面的类声明了一个Man具有 name 和 age 属性以及 (=) __ eq__和 (<) __l t__ dunder 方法的类。

class Man:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, o):
        return self.age == o.age

    def __lt__(self, o):
        return self.age < o.age

让我们看看如果我们运行代码会发生什么。

>>> obj = Man("Vivek", 20)
>>> obj2 = Man("Alex", 24) 
>>> obj = obj
>>> obj == obj2
False
>>> obj < obj2
True
>>> obj >= obj2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>=' not supported between instances of 'Man' and 'Man'

我们的代码适用于 (==) 和 (<)，但当我们使用类中未定义的运算符时它不起作用。鉴于我们至少创建了一个运算符 dunder 方法和 __eq__ 方法，@total_ordering 为我们的类生成了、>、=、>= 和更多比较运算符。

让我们在类的正上方添加我们的装饰器。

from functools import total_ordering

@total_ordering
class Man:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, o):
        return self.age == o.age

    def __lt__(self, o):
        return self.age < o.age

现在再次以交互模式运行代码以查看结果

>>> o = Man("Vivek", 20) 
>>> b = Man("Alex", 24) 
>>> o == b 
False 
>>> o >= b   
False 
>>> o <= b 
True