Python Functools 模块

2024 年 8 月 29 日 | 阅读 19 分钟

functools 模块是 Python 标准库中包含的，它为使用高阶函数（返回函数或将另一个函数作为参数的函数）提供了基本功能。您可以使用这些功能重用或增强函数或可调用对象的实用性，而无需重写它们。这简化了构建可重用和可维护代码的过程。

functools 模块在当前稳定版本 Python 3.8 系列中有 11 个函数，尽管其中一些函数在以前或以后的版本中可能无法访问或工作方式不同。它们如下：

reduce()
lru_cache()
partial()
partialmethod()
singledispatch()
singledispatchmethod()
cached_property()
total_ordering()
update_wrapper()
wraps()
cmp_to_key()

Reduce()

我们将从一个经典函数开始。reduce(function, sequence) 函数接受一个函数和一个可迭代对象。它以累积方式从左到右将提供的函数应用于可迭代对象的所有成员，然后返回一个单一值。

简单地说，它首先将参数函数应用于可迭代对象的前两项，此初始调用返回的值成为函数的第一个参数，而可迭代对象的第三个元素成为第二个参数。这种方法一直持续到可迭代对象用尽。

lru_cache()

lru_cache() 是一个装饰器，它将一个函数包装在一个记忆化的可调用对象中，该对象最多保存一个函数调用的结果，并在再次使用相同输入调用该函数时返回存储的值。当一个昂贵的或 I/O 绑定的函数重复使用相同参数调用时，它可以节省时间。

它主要采用两种数据结构：一个字典用于将函数的参数映射到其输出，一个链表用于跟踪函数的调用历史。

LRU Cache 的全称是 Least-Recently-Used Cache（最近最少使用缓存），它指的是当达到最大条目数时，会淘汰最近最少使用的元素。如果将 maxsize 设置为 None，则禁用 LRU 功能；如果 typed 为 True，则 LRU 功能会分别缓存不同数据类型的参数，例如，f(3) 和 f(3.0) 将分别缓存。

通常，LRU 缓存只应在需要重用先前计算的值时使用。因此，缓存每次调用都会产生不同可变对象的函数并不是一个好主意。函数的 positional 和 keyword 输入也必须是可哈希的，因为需要一个字典来缓存结果。

partial()

偏函数是已经分配了一些输入参数的派生函数。如果一个函数接受两个参数，比如“a”和“b”，则可以从中构建一个以“a”作为预填充参数的偏函数，然后可以仅以“b”作为参数调用它。Functool 中的 partial() 方法用于构造偏函数/对象，这是一个重要的特性，因为它允许：

复制具有某些已设置参数的现有函数。
以良好文档的方式创建现有函数的新版本。

偏函数还具有可用于跟踪偏函数和对象的有价值的特性。其中一些是：

args - 返回偏函数的预分配位置参数。
keywords - 返回偏函数的预分配关键字参数。
func - 返回父函数的名称及其位置。

partialmethod()

partialmethod() 方法提供了一个新的偏方法描述符，它类似于 partial，但旨在用作方法规范而不是可调用方法。你可以将其视为方法的 partial()。

singledispatch()

在详细介绍此函数之前，首先回顾两个关键概念至关重要：

第一个是通用函数，它是由许多函数组成的，这些函数都为不同的类型执行相同的任务。分派算法确定在调用期间将使用哪个实现。

第二个是单分派，它是一种通用函数分派，其中实现由单个参数的类型决定。

考虑到这一点，functool 中的 singledispatch 装饰器将一个基本函数转换为一个通用函数，其行为由其第一个参数的类型决定。用通俗易懂的话来说，它用于函数重载。

singledispatchmethod()

它是一个装饰器，其工作方式与 @singledispatch 相同，但用于方法而不是函数。

cached_property()

cached_property() 装饰器将类方法转换为属性，其值仅计算一次，然后在其实例的整个生命周期中作为普通属性进行缓存，正如其名称所示。除了缓存功能外，它与 @property 类似。它对于通常在功能上是永久但计算成本高的实例属性非常有用。

total_ordering()

给定一个定义一个或多个富比较排序方法（等价于、=、>、>= 和 ==）的类，例如 __lt__()、__le__()、__gt__()、__ge__() 或 __eq__()。您可以定义一些比较方法，@total_ordering 将根据您提供的定义提供其余方法。类中包含 __eq__() 方法至关重要。

例如，如果您想创建一个比较不同数字的类。几乎肯定需要实现所有丰富的比较方法。然而，由于这可能既乏味又不必要，您可以只实现 __eq__ 和 __gt__ 方法，并依靠 @total_ordering 来填补空白。

update_wrapper()

它使包装器函数的元数据看起来像被包装的函数。对于偏函数，update_wrapper(partial, parent) 将更新偏函数的文档(doc)和名称(name)以匹配父函数。

wraps()

它只是在被装饰函数上调用 update_wrapper() 的一个快捷方式。它与调用 partial(update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated, wrapped=wrapped) 相同。

cmp_to_key();

它将旧式比较函数转换为键函数。任何接受两个参数、比较它们并返回小于为负数、相等为零或大于为正数的可调用对象都被称为比较函数。operator.itemgetter() 键函数是接受一个参数并返回另一个值用作排序键的可调用对象的一个示例。sorted()、min()、max() 和 itertools.groupby 等工具使用键函数()。

cmp_to_key() 主要用作 Python 2 脚本与比较函数的过渡辅助。

让我们看看代码

代码

# A sample program to understand the use case scenario of various functions which are offered by this Python module,  in this program we have written a class in which you have separate functions out of which some of the functions or the main caller functions represent the various use case scenarios of the different functions which are provided by this Python module.  these different functions are used to represent a particular use case scenario of these functions but the uses of these functions can vary according to the need or requirement of the user.  the functions which are actually called to showcase the scenario actually calling the inbuilt functions of this module that actually implements the functionality of those functions 

#All the required functions are imported from the package so that we can use those functions at the later section of the code
from functools import lru_cache, singledispatch
from time import time
from functools import singledispatchmethod
from functools import reduce
import sys
from functools import partial

# this is a sample class in which you have a number of the function representing different use case in areas of the multiple methods which are provided by this module,  each function if required prompts the user for the appropriate input and perform the respective calculations on the provided data and prints the output.
class my_functools_class:

	#  a sample constructor is written that can be used to initialize the class variable of the above-written class.
	def __init__(self):
		pass

	#  this is the first function that explains how we can use the least recently used cache registers to actually change our sequential execution of code to parallel execution. In this function, we are calling two different functions the first function that we are calling is implemented with the inbuilt least recently used cache register functionality with the use of this inbuilt function the code execution time is reduced drastically whereas on the other hand side we are calling another function which is not using this inbuilt functionality so in the other function which we are calling the execution time will be much greater as compared to the first one. Both of these called functions are performing the operation of calculating the Fibonacci series the difference between both of these functions is that the first function is implemented with the inbuilt least recently used cache register functionality whereas, on the other hand, the second function is just a normal function.  both of these functions are also making use of recursion.  the user is asked for each of these functions for how many iterations he wants to run.  on entering the number of iterations the calculations are performed and the specific time difference is also displayed between the time taken by both of these functions.
	def use_lru_cache(self):
		start_time = time()
		result = 0
		print("For how many iterations you want to calculate::")
		iters = int(input())
		for i in range(iters):
			result = result + self.calculate_with_lru_cache(i)
		print("Function with lru_cache took {} seconds to calculate fibonacci for {} iterations.".format(
    	    start_time-time(), iters))

		start_time = time()
		result = 0
		for i in range(iters):
			result = result + self.calculate_without_lru_cache(i)
		print("Function without lru_cache took {} seconds to calculate fibonacci for {} iterations.".format(
    	    start_time-time(), iters))


#This is a function that is making the use of the least recently used cache resistor functionality which is provided by this Python module,  with the help of this functionality the code execution time is reduced drastically we can observe this reduction in time when printing the time taken by this function to calculate the Fibonacci series. 
	@lru_cache(maxsize=128)
	def calculate_with_lru_cache(self, num):
		if num <= 1:
			return num
		else:
			return(self.calculate_with_lru_cache(num-1) + self.calculate_with_lru_cache(num-2))


# Where is on the other hand side this is a simple function that is simply making the use of recursion to calculate the Fibonacci series since there are no registers used in this function the time taken by this function to calculate the Fibonacci series is comparatively very high as compared to what we have seen in our last function.
	def calculate_without_lru_cache(self,num):
		if num <= 1:
			return num
		else:
			return(self.calculate_without_lru_cache(num-1) + self.calculate_without_lru_cache(num-2))



#  this is a simple function that prints the division of two numbers which are of integer type and the return type of the result is of float type.  the only condition for calling this function is that both the parameters that are passed as arguments to  this function must be of integer type and after performing the division on these two input parameters the result is returned back as a floating value
	@singledispatchmethod
	def divide_the_numbers(self,number_1:int,number_2:int)->float:
	    return number_1/number_2

#  this function is a kind of exception handling for the above Return function which actually takes the input of two strings as a number and returns a string as output the main difference between the above Return function and this function is that the input parameters of the above Return function are of integer type and the input parameters of this functions are of string type and the returning value of the above Return function is a floating value whereas in this function the returning value is also a string
	@divide_the_numbers.register(str)
	def _(self,number_1:str,number_2:str)->str:
	    return f"{number_1}/{number_2}"


# this is the caller function for the above written to functions for the division operation in this function first of all we are calling the divide the numbers  function with integer parameters so we can see that the resultant value that is received is a floating value and that is printed to the use and after calling this we are calling the same function but now this time the parameters of the same function are of string type,  on passing the string parameters as input arguments to this function we can see that  the returning value of this function has been changed to a string value and we can verify this observation by comparing the result of both the function calls with different input parameters one with integer types and other with strings
	def use_single_dispatch(self):
		print("calling the divide function with the integer parameters( divide_the_numbers(6/4) ), the result is :: ")
		print(self.divide_the_numbers(6,4))
		print("calling the divide function with the string parameters( divide_the_numbers('12'/'7') ), the result is :: ")
		print(self.divide_the_numbers('12','7'))
  



# In this function we will see the usage of reduced functionality offered by this Python module in this function first of all the user is asked for the length of the list,  on entering the length of the list the user is asked for the elements of the list on entering all the elements of the list the user is printed with the list elements which the user has entered now we are using the reduce function to print the sum of all the elements of the entered list the resultant sum it stored in a variable and is printed to the user,  after calculating the sum of all the elements of a list next we are calculating the maximum element present in the entered list the resultant of the maximum element is stored in a variable and is printed to the user.  the point to be noted in this function is that for two different operations like the calculation of the sum of all the elements and finding the maximum element from the entered list we are using the same reduce function which is offered by the Python module just by changing the parameters to this same function we are getting different results for different operations 
	def use_reduce(self):
		print("Enter length of list ::")
		lens = int(input())
		list_obj = list()
		for _ in range(lens):
			list_obj.append(int(input()))

		print("entered list is {}".format(list_obj))

		print("Using reduce to find the sum of all the elements of the list:: ")
		resultant_sum = reduce(lambda x,y: x+y, list_obj)
		print("Result of the sum is {}".format(resultant_sum))
  
		print("Using reduce to find the maximum among all the elements of the list:: ")
		maxer = reduce(max, list_obj)
		print("Max element is {}".format(maxer))
  

# This is a simple function which accepts two string parameters where first parameter is occupation and the second parameter is the articles or gadgets used by that occupation,  and this function simply prints a string saying that a particular set off gadgets are used by this occupation
	def print_occupation_and_gadgets(self,occupation,used_gadgets):
		print("{} are used by the {}".format(used_gadgets,occupation))
	

# this is the caller function which represents a use case scenario of the partial function which is offered by this Python module,  so in this function, we are calling the above-written function which is having two string parameters,  so for calling this above-written function each time we have to pass to string variables but with the help of partial function or functionality which is offered by this Python module, we can fix one of the two input parameters which are required by this function.  in this function first of all were calling the power button function without the use of the partial function so in this case the user is asked for the occupation and the gadgets twice.  after this, we are calling the above-written function with the help of partial show with the help of partial first of all we are fixing the occupation parameter of the above-written functions,  so we are asking the user for the occupation only once and call this function is given two times by just taking the gadgets as the input device.  the main difference between needs to observe here is that during the first call we need to take input two times for both the occupation and gadgets,  whereas with the help of partial function we need to take input for the gadget twice but for occupation, only one input was good which we have fixed with the help of the partial function which is offered by this Python module. 
	def use_of_partial(self):
		print("Calling the function twice without the use of partial")
		for _ in range(2):
			print("Enter the occupation::")
			occ = input()
			print("Enter the gadgets used::")
			gads = input()
			self.print_occupation_and_gadgets(occ,gads)
		
		print("Calling the function twice with the use of partial")
		print("Enter the occupation::")
		occ = input()
		new_caller_obj = partial(self.print_occupation_and_gadgets,occ)
		for _ in range(2):
			print("Enter the gadgets used::")
			gads = input()
			new_caller_obj(gads)
   


After writing the function definitions we have written the main function that is used to call all the above-written functions. An object of the above-written class is created which is used to call all the different functions written in this class.  first of all the user is printed with five options from which he can select which operation or functionality of this module he wants to test and observe,  on entering the appropriate choice the respective function is called with the help of the class object created,  similarly, this operation is performed in a recursive manner till the user wants to exit the code or there is some unhandled exception encountered.	
def main():
    class_obj = my_functools_class()
    while(True):
        print("Enter your choice according to the below-listed options::")
        print("1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().")
        print("2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().")
        print("3. To use the reduce() function understand the various use-cases of the reduce().")
        print("4. To use the partial() function and compare the usage of the functions with and without the partial().")
        print("5. To exit from the code execution.")
        menu_choice = input()
        menu_choice = int(menu_choice)
 
        if menu_choice == 1:
            class_obj.use_lru_cache()
        elif menu_choice == 2:
            class_obj.use_single_dispatch()
        elif menu_choice == 3:
            class_obj.use_reduce()
        elif menu_choice == 4:
            class_obj.use_of_partial()
        elif menu_choice == 5:
            sys.exit()
 
        print("To move ahead with code execution enter [y] else [n]")
        continue_or_exit = input()
 
        if continue_or_exit == 'y' or continue_or_exit == 'Y':
            pass
        elif continue_or_exit == 'n' or continue_or_exit == 'N':
            sys.exit()
 
 
if __name__ == '__main__':
    main()

输出

Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
1
For how many iterations do you want to calculate::
33
Function with lru_cache took -2.7494192123413086 seconds to calculate Fibonacci for 33 iterations.
Function without lru_cache took -1.7327818870544434 seconds to calculate Fibonacci for 33 iterations.
To move ahead with code execution enter [y] else [n]
y
Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
2
calling the divide function with the integer parameters( divide_the_numbers(6/4) ), the result is ::
1.5
calling the divide function with the string parameters( divide_the_numbers('12'/'7') ), the result is ::
12/7
To move ahead with code execution enter [y] else [n]
y
Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
3
Enter the length of the list::
5
100
234
665
230
874
entered list is [100, 234, 665, 230, 874]
Using reduce to find the sum of all the elements of the list::
The result of the sum is 2103
Using reduce to find the maximum among all the elements of the list::
Max element is 874
To move ahead with code execution enter [y] else [n]
y
Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
4
Calling the function twice without the use of partial
Enter the occupation::
Driver
Enter the gadgets used::
Cars
Cars are used by the Driver
Enter the occupation::
Electrician
Enter the gadgets used::
Screwdriver
Screwdrivers are used by the Electrician
Calling the function twice with the use of partial
Enter the occupation::
Teacher
Enter the gadgets used::
Books
Books are used by the Teacher
Enter the gadgets used::
Pens
Pens are used by the Teacher
To move ahead with code execution enter [y] else [n]
y
Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
3
Enter the length of the list::
4
87732
34853
3421
45214
entered list is [87732, 34853, 3421, 45214]
Using reduce to find the sum of all the elements of the list::
The result of the sum is 171220
Using reduce to find the maximum among all the elements of the list::
Max element is 87732
To move ahead with code execution enter [y] else [n]
y
Enter your choice according to the below-listed options::
1. To use the lru_cache() function and compare the time difference between the function with and without the lru_cache().
2. To use the singledispatch() function and compare the time usage of the functions with and without the singledispatch().
3. To use the reduce() function understand the various use-cases of the reduce().
4. To use the partial() function and compare the usage of the functions with and without the partial().
5. To exit from the code execution.
5

一个示例程序，用于理解此 Python 模块提供的各种函数的用例场景，在此程序中，我们编写了一个类，其中包含单独的函数，其中一些函数或主调用函数表示此 Python 模块提供的不同函数的各种用例场景。这些不同的函数用于表示这些函数的特定用例场景，但这些函数的用途可以根据用户的需要或要求而变化。实际调用以展示场景的函数实际上调用了此模块的内置函数，这些函数实际实现了这些函数的功能。

让我们来看看 Python 中 Functools 模块的一些优点

缓存

让我们从 functools 模块最基本但最强大的函数开始。lru_cache、cache 和 cached_property 是缓存函数（也是装饰器）。第一个是 lru_cache，它提供了函数结果的最近最少使用缓存，换句话说，结果备忘录。如果您想要更精细的缓存，可以使用 typed=true 参数，它会单独缓存不同类型的参数。

一个名为 cache 的函数是 functools 中的另一个缓存装饰器。它是 lru_cache 的一个简单包装器，省略了 max_size 选项，使其更小，并且在它不需要逐出旧数据之后，它不需要逐出旧值。您还可以使用 cached_property，这是另一个用于缓存的装饰器。顾名思义，它用于缓存类属性结果。如果您的属性计算成本高昂且不可变，这尤其有利。cached_property 的优点是它只在查找时执行，允许我们更改属性。更新属性后，以前缓存的值将不会被使用；相反，将计算并缓存一个新值。清除缓存也是可能的；我们所要做的就是删除属性。

比较和排序

您可能已经知道，您可以使用 __lt__、__gt__ 或 __eq__ 在 Python 中实现比较运算符，例如 >= 或 ==。实现所有 __eq__、__lt__、__le__、__gt__ 或 __ge__ 函数可能会很痛苦。幸运的是，functools 模块提供了 @total_ordering 装饰器，它可以帮助我们解决这个问题——我们所要做的就是实现 __eq__ 和其余方法中的一个，装饰器将处理其余的工作。

重载

我们可能都曾被告知 Python 中不可能进行函数重载，但实际上使用 functools 模块中的两个函数：singledispatch 和/或 singledispatchmethod，很容易实现。这些方法有助于实现多重分派算法，该算法允许像 Python 这样的动态类型编程语言在运行时区分类型。

支持异步操作

我们都使用各种外部库和框架，其中许多都有需要我们传入回调函数的函数和接口，例如异步操作或事件监听器。这并不新鲜，但是如果我们除了回调函数之外还需要传入其他参数怎么办？这时 functools 就派上用场了。partial 很有用，因为它可以用来冻结函数的某些（或所有）参数，从而生成一个具有更简单函数签名的新对象。通常在读取文件时，我们希望遍历行，但在二进制数据的情况下，我们可能更喜欢遍历固定大小的记录。这可以通过编写一个 partial 可调用对象来实现，该对象读取定义的数据块并将其传递给 iter，iter 从中生成一个迭代器。然后，此迭代器执行读取方法，直到到达文件末尾，始终只接受 RECORD_SIZE 参数指定的数据。当文件末尾到达时，返回 sentinel 值 (b")，循环结束。

装饰器

我们已经在前面的部分讨论了几个装饰器，但没有讨论用于构造更多装饰器的装饰器。functools.wraps 就是这样一个装饰器。

所以，在这篇文章中，我们理解了 Python 中的 Functools 模块。

下一主题使用 Python 中的 gmplot 包绘制 Google 地图

Python Functools 模块

Reduce()

lru_cache()

partial()

partialmethod()

singledispatch()

singledispatchmethod()

cached_property()

total_ordering()

update_wrapper()

wraps()

cmp_to_key();

代码

缓存

比较和排序

重载

支持异步操作

装饰器

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

Python Functools 模块

Reduce()

lru_cache()

partial()

partialmethod()

singledispatch()

singledispatchmethod()

cached_property()

total_ordering()

update_wrapper()

wraps()

cmp_to_key();

代码

缓存

比较和排序

重载

支持异步操作

装饰器

相关帖子

Python pysftp 模块

使用 bcrypt 在 Python 中加密密码

如何在 Python 中执行单向 ANOVA

Python 中的积分微积分

如何使用地理定位 API 查找用户位置

Python PyGal 库

天气 API Python

使用 Flask、Connexion 和 SQLAlchemy 构建 Python REST API

Python 中的亲和数

Python Dash 模块

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器