Python 标准库中最有用的装饰器

ST7789P3初始化配置 【代码】ST7789P3初始化配置。 阅读详情

众所周知,Python 语言灵活、简洁,对程序员友好,但在性能上有点不太令人满意,这一点通过一个递归的求斐波那契额函数就可以说明:


def
fib(
n):


if
n
<=
1:


return
n


return
fib(
n
-
1)
+
fib(
n
-
2)


1.

2.

3.

4.

在我的 MBP 上计算 fib(40) 花费了 33 秒:

import
time




def
main():


start
=
time
.
time()


result
=
fib(
40)


end
=
time
.
time()


cost
=
end
-
start


print(
f
"{result = } {cost = :.4f}")




if
__name__
==
'__main__':


main()


1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

但是,假如使用标准库中的这个装饰器,那结果完全不一样 

from
functools
import
lru_cache




@lru_cache


def
fib(
n):


if
n
<=
1:


return
n


return
fib(
n
-
1)
+
fib(
n
-
2)


1.

2.

3.

4.

5.

6.

7.

这次的结果是 0 秒,你没看错,我保留了 4 位小数,后面的忽略了。

提升了多少倍?我已经计算不出来了。

为什么 lru_cache 装饰器这么牛逼,它到底做了什么事情?今天就来聊一聊这个最有用的装饰器。

如果看过计算机操作系统的话,你对 LRU 一定不会陌生,这就是著名的最近最久未使用缓存淘汰算法。

而 lru_cache 就是这个算法的具体实现。(这个算法可是面试经常考的哦,有的面试官要求现场手写代码)

现在,我们来看一个 lru_cache 的源代码,其中的英文注释,我已经为你翻译为中文:

def
lru_cache(
maxsize
=
128,
typed
=
False):


""
"LRU 缓存装饰器




如果
*
maxsize
*
是
None,
将不会淘汰缓存,缓存大小也不做限制




如果
*
typed
*
是
True,
不同类型的参数将独立做缓存,比如
f(
3.0)
and
f(
3)
将认为是不同的函数调用而缓存在两个缓存节点上。




函数的参数必须可以被
hash




查看缓存信息使用的是命名元组 (
hits,
misses,
maxsize,
currsize)


查看缓存信息:user_func
.
cache_info()
.
清理缓存信息:user_func
.
cache_clear()
.




LRU
算法:
http:
//en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)




""
"




#
lru_cache
的内部实现是线程安全的




if
isinstance(
maxsize,
int):


#
负数转换为
0


if
maxsize
<
0:


maxsize
=
0


elif
callable(
maxsize)
and
isinstance(
typed,
bool):


#如果被装饰的函数(user_function)直接通过
maxsize
参数传入


user_function,
maxsize
=
maxsize,
128


wrapper
=
_lru_cache_wrapper(
user_function,
maxsize,
typed,
_CacheInfo)


return
update_wrapper(
wrapper,
user_function)


elif
maxsize
is
not
None:


raise
TypeError(


'Expected first argument to be an integer, a callable, or None')




def
decorating_function(
user_function):


wrapper
=
_lru_cache_wrapper(
user_function,
maxsize,
typed,
_CacheInfo)


return
update_wrapper(
wrapper,
user_function)




return
decorating_function


1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

12.

13.

14.

15.

16.

17.

18.

19.

20.

21.

22.

23.

24.

25.

26.

27.

28.

29.

30.

31.

32.

33.

34.

35.

36.

这里面有两个参数,一个是 maxsize,表示缓存的大小,当传入负数时,自动设置为 0,如果不传入 maxsize,或者设置为 None,表示缓存没有大小限制,此时没有缓存淘汰。还有一个是 type,当 type 传入 True 时,不同的参数类型会当作不同的 key 存到缓存当中。

接下来,lru_cache 的核心在这个函数上 ​​_lru_cache_wrapper​​,建议有感情的阅读、背诵并默写。我们来看下它的源代码

def
_lru_cache_wrapper(
user_function,
maxsize,
typed,
_CacheInfo):


#
所有
lru
cache
实例共享的常量:


sentinel
=
object()
#
用来表示缓存未命中的唯一对象


make_key
=
_make_key
#
build
a
key
from
the
function
arguments


PREV,
NEXT,
KEY,
RESULT
=
0,
1,
2,
3
#
names
for
the
link
fields




cache
= {}


hits
=
misses
=
0


full
=
False


cache_get
=
cache
.
get
#
绑定函数来获取缓存中
key
的值


cache_len
=
cache
.
__len__
#
绑定函数获取缓存大小


lock
=
RLock()
#
因为链表上的更新是线程不安全的


root
= []
#
循环双向链表的根节点


root[:]
= [
root,
root,
None,
None]
#
初始化根节点的前后指针都指向它自己




if
maxsize
==
0:




def
wrapper(
*
args,
**
kwds):


#
没有缓存,仅更新统计信息


nonlocal
misses


misses
+=
1


result
=
user_function(
*
args,
**
kwds)


return
result




elif
maxsize
is
None:




def
wrapper(
*
args,
**
kwds):


#
仅仅排序,不考虑排序和缓存大小限制


nonlocal
hits,
misses


key
=
make_key(
args,
kwds,
typed)


result
=
cache_get(
key,
sentinel)


if
result
is
not
sentinel:


hits
+=
1


return
result


misses
+=
1


result
=
user_function(
*
args,
**
kwds)


cache[
key]
=
result


return
result




else:




def
wrapper(
*
args,
**
kwds):


#
大小有限制,并跟踪最近使用的缓存


nonlocal
root,
hits,
misses,
full


key
=
make_key(
args,
kwds,
typed)


with
lock:


link
=
cache_get(
key)


if
link
is
not
None:


#
缓存命中,将命中的缓存移动到循环双向链表的头部


link_prev,
link_next,
_key,
result
=
link


link_prev[
NEXT]
=
link_next


link_next[
PREV]
=
link_prev


last
=
root[
PREV]


last[
NEXT]
=
root[
PREV]
=
link


link[
PREV]
=
last


link[
NEXT]
=
root


hits
+=
1


return
result


misses
+=
1


result
=
user_function(
*
args,
**
kwds)


with
lock:


if
key
in
cache:


#
走到这里说明
key
已经放在了缓存,且锁已经释放了,链表已经更新了,这里什么也不需要做了,最后只需要返回计算的结果就可以了。


pass


elif
full:


#
如果缓存满了,
使用最老的根节点来存储新节点就可以了,链表上不需要删除(是不是很聪明)


oldroot
=
root


oldroot[
KEY]
=
key


oldroot[
RESULT]
=
result


root
=
oldroot[
NEXT]


oldkey
=
root[
KEY]


oldresult
=
root[
RESULT]


root[
KEY]
=
root[
RESULT]
=
None




#
最后,我们需要从缓存中清除这个
key,因为它已经无效了。


del
cache[
oldkey]


#
新值放入缓存


cache[
key]
=
oldroot


else:


#
如果没有满,将新的结果放入循环双向链表的头部


last
=
root[
PREV]


link
= [
last,
root,
key,
result]


last[
NEXT]
=
root[
PREV]
=
cache[
key]
=
link


#
使用
cache_len
绑定方法而不是
len()
函数,后者可能会被包装在
lru_cache
本身中


full
= (
cache_len()
>=
maxsize)


return
result




def
cache_info():


""
"报告缓存统计信息"
""


with
lock:


return
_CacheInfo(
hits,
misses,
maxsize,
cache_len())




def
cache_clear():


""
"清理缓存信息"
""


nonlocal
hits,
misses,
full


with
lock:


cache
.
clear()


root[:]
= [
root,
root,
None,
None]


hits
=
misses
=
0


full
=
False




wrapper
.
cache_info
=
cache_info


wrapper
.
cache_clear
=
cache_clear


return
wrapper


1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

12.

13.

14.

15.

16.

17.

18.

19.

20.

21.

22.

23.

24.

25.

26.

27.

28.

29.

30.

31.

32.

33.

34.

35.

36.

37.

38.

39.

40.

41.

42.

43.

44.

45.

46.

47.

48.

49.

50.

51.

52.

53.

54.

55.

56.

57.

58.

59.

60.

61.

62.

63.

64.

65.

66.

67.

68.

69.

70.

71.

72.

73.

74.

75.

76.

77.

78.

79.

80.

81.

82.

83.

84.

85.

86.

87.

88.

89.

90.

91.

92.

93.

94.

95.

96.

97.

98.

99.

100.

101.

102.

103.

104.

如果我写的注释你都看明白了,那也不用看我下面的废话了,如果还有点不太明白,我啰嗦几句,也许你就明白了。

第一、所谓缓存,用的仍然是内存,为了快速存取,用的就是一个 hash 表,也就是 Python 的字典,都是在内存里的操作。


cache
= {}


1.

第二、如果 maxsize == 0,就相当于没有使用缓存,每调用一次,未命中数就 + 1,代码逻辑是这样的:


def
wrapper(
*
args,
**
kwds):


nonlocal
misses


misses
+=
1
#
未命中数


result
=
user_function(
*
args,
**
kwds)


return
result


1.

2.

3.

4.

5.

第三、如果 maxsize == None,相当于缓存无限制,也就不需要考虑淘汰,这个实现非常简单,我们直接在函数中用一个字典就可以实现,比如说:

cache
= {}


def
fib(
n):




if
n
in
cache:


return
cache[
n]




if
n
<=
1:


return
n


result
=
fib(
n
-
1)
+
fib(
n
-
2)


cache[
n]
=
result


return
result


1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

运行时间:

 理解了这一点,在装饰器中,这段逻辑就不难看懂:

def
wrapper(
*
args,
**
kwds):


nonlocal
hits,
misses


key
=
make_key(
args,
kwds,
typed)


result
=
cache_get(
key,
sentinel)


if
result
is
not
sentinel:


hits
+=
1


return
result


misses
+=
1


result
=
user_function(
*
args,
**
kwds)


cache[
key]
=
result


return
result


1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

第四、真正的缓存淘汰算法。

为了实现缓存(键值对)的淘汰,我们需要对缓存按时间进行排序,这就需要用到链表,链表的头部是最新插入的,尾部是最老插入的,当缓存数量已经达到最大值时,我们删除最久未使用的链尾节点,为了不删除链尾,我们可以使用循环链表,当缓存满了,直接更新链尾节点赋值为新节点,并把它做为新的链头就可以了。

当缓存命中时,我们需要把这个节点移动到链表的头部,保证链表的头部是最近经常使用的,为了移动方便,我们需要双向链表。

双向循环链表在 Python 中实现,可以简单的这么写:

PREV,
NEXT,
KEY,
RESULT
=
0,
1,
2,
3
#
names
for
the
link
fields


root
= []
#
root
of
the
circular
doubly
linked
list


root[:]
= [
root,
root,
None,
None]
#
initialize
by
pointing
to
self


1.

2.

3.

可能有些朋友看不懂最后那行代码:​​root[:] = [root, root, None, None]​​,画个图你就理解了:

这些箭头指向的都是节点的内存地址,随着节点的增多,就是这个样子的:

对比这个图,再看源代码,就很容易看懂了。尤其是这块的代码逻辑,是面试常考的重点,如果你能手写出这样线程安全的 LRU 缓存淘汰算法,那无疑是非常优秀的。

其他 LRU 算法的实现

其他关于 LRU 算法的实现,我自己写了两个,可以看这里:

LRU 缓存淘汰算法-双链表+hash 表[1]

LRU 缓存淘汰算法-Python 有序字典[2]

最后的话

装饰器 lru_cache 的作用就是把函数的计算机结果保存下来,下次用的时候可以直接从 hash 表中取出,避免重复计算从而提升效率,简单点的,直接在函数中使用个字典就搞定了,复杂点的,请看 lru_cache 的代码实现。另一方面,递归函数慢的一个主要原因就是重复计算。

Python 标准库的源码,是学习编程最有营养的原料,当你有好奇心时,不妨去窥探一下源码,相信你有定会有新的收获。今天的分享就到这里,如果有收获的话,请点赞、在看、转发、关注,感谢你的支持。

PCIe中ACS知识小记 虚拟机内部的访问数据显而易见是带的GPA地址。而目前几乎所有的PCIe 设备都带ACS control,所以它们可以单独assign给不同的VM,但是随之而来的就是即使两个GPU同时assign给同一个VM,由于ACS的存在,他们之间也不会有真正的物理层面的P2P访问。每一个TLP都自带一个address(寻址类TLP),同时每一个endpoint,PCIe switch都自带一段BIOS配置的地址空间范围,一旦这个TLP的address落入某个设备的地址范围,那么这个TLP就属于这个设备并消费。 阅读详情

相关推荐

CANopen PDO 配置實戰:3步完成0x1800-0x1A00物件字典映射與事件觸發

本文详细解析CANopen PDO配置实战,通过3个关键步骤完成0x1800-0x1A00对象字典映射与事件触发设置。重点介绍COB-ID位域解析、映射参数配置及事件触发优化,帮助工程师实现工业自动化设备间毫秒级实时数据交换,提升系统通信效率。

weixin_33709609的博客 381

10个美妙的Python装饰器

10个美妙的Python装饰器 对Python编程语言中我最喜欢的一些装饰器的概述。 简介 关于Python编程语言的伟大之处在于,它在一个小包里装了所有的功能,这些功能非常有用。很多特性可以完全改变Python代码的功能,这使得该语言更加通用。此外,如果使用得当,这些功能中的一些可以起到缩短编写有效软件的时间的作用。Python的装饰器是一个很好的例子,它很好地完成了这些目标。 装饰器是快速编程宏,可以用来改变 Python 对象的行为。它们可以应用于类和函数,并且实际上可以做很多非常有趣的事情。装饰器可

qq_40523298的博客 2532

解决SolidWorks启动报错问题:SolidWorks2020显示无法获得下列许可 SolidWorks standard 期望的SolidWorks监控程序已经关闭(-97,121,0)

解决SolidWorks启动报错问题:SolidWorks2020显示无法获得下列许可 SolidWorks standard 期望的SolidWorks监控程序已经关闭(-97,121,0) 问题描述 打开SolidWorks2020时,显示SolidWorks2020显示无法获得下列许可 SolidWorks standard 期望的SolidWorks监控程序已经关闭(-97,121,0) (急需看模型的我心里万马奔腾…) 截图如下: 有问题咱就上 看了其他博主的回答,自己尝试了几个,发现出现了新的

qq_44606358的博客 7万+

python cache_python自带缓存lru_cache用法及扩展(详细)

​本篇博客将结合python官方文档和源码详细讲述lru_cache缓存方法是怎么实现, 它与redis缓存的区别是什么, 在使用时碰上functiontools.wrap装饰器时会发生怎样的变化,以及了解它给我们提供了哪些功能然后在其基础上实现我们自制的缓存方法my_cache。1. lru_cache的使用1.1 参数详解​以下是lru_cache方法的实现,我们看出可供我们传入的参数有2个m...

weixin_35858450的博客 2373

从零搭建基于OpenSpec的现代化UI自动化测试框架实战指南

UI自动化测试是软件质量保障的关键环节,其核心在于通过脚本模拟用户操作,对Web应用界面进行功能验证。其原理在于利用浏览器驱动工具(如Selenium、Playwright)提供的API,实现对页面元素的定位、交互与断言。一个设计良好的自动化框架能显著提升测试脚本的可维护性、可读性和执行稳定性,从而在持续集成、回归测试等场景中发挥巨大价值。本文聚焦于如何构建一个现代化的UI测试框架,通过整合OpenSpec架构规范、Pytest测试引擎与Playwright浏览器自动化工具,形成清晰的页面对象模型(POM)

weixin_28836989的博客 286

5个python常用的装饰器!

大家好呀,我是阿潘。首先,每个开发人员的目标都是让事情正常进行。慢慢地,我们担心可读性和可扩展性。这是我们第一次开始考虑装饰器的时候。装饰器是为函数提供额外行为的绝佳方式。使用装饰器,你会惊讶地发现可以减少代码重复并提高可读性。以下是我在几乎每个数据密集型项目中使用的五个最常用的方法。1.重试装饰器在数据科学项目和软件开发项目中,有很多我们依赖外部系统的情况。事情并不总是在我们的控制之中。当意外...

zero的博客 2186

MicroCap声学仿真介绍(三)-人耳的频率响应

这里需要注意的是,24mm我们会填为”24m”,这里的“m”是毫的意思,24m意思是24e-3,同理7.4mm我们可以填为7.4m,意思是7.4e-3。MicroCap声学库中,已内置“声源”模块和“管”模块,我们需要调用这两个模块,并用连接线将这两个模块连接到一起,完成仿真工作。上图中第一个图是在管的一端输入1Pa(94dBSPL)的信号,管的另一端的不同频率的声压大小的仿真结果。上述的结果跟我们的常识也是符合的。换言之,我们要仿真的目的是在管的一端加1pa的声压时,管的另一端不同频率下的声压分布。

山无忧的博客 1474

学会这12个Python装饰器,让你的代码更上一层楼

装饰器是一个重要的抽象思想,可以在不改变原始代码的情况下扩展代码。本文整理了项目中经常用到的12个装饰器,值得每一个Python开发者掌握。

略懂……略懂…… 8800

ZYNQ PL通过EMIO ETHE1外接PHY由GMII转RGMII

1,设置EMIO方式引出ETHE1 2,从GMII过度到RGMII GMII: 发送 gmii_tx_clk gmii_tx_d[7:0] gmii_tx_en gmii_tx_er 接收 gmii_rx_clk gmii_rx_d[7:0] gmii_rx_dv gmii_rx_er RGMII: 发送 tx_clk tx_d[3:0] tx_ctrl 接收 rx_clk rx_d[3:0] rx_ctrl 首先数据总线从时钟单边沿采样8bit转变为了双边沿采样4bit,从88E1

wangjie36的博客 1万+

【文献笔记】CVPR 2023|Attention-Based Point Cloud Edge Sampling

优点能够有效采出点云数据的边缘点分类任务性能优越不足没有设计出一个更好的上采样方法,导致分割任务的性能略低只考虑了边缘特征,没有利用其他几何特征。

m0_55908255的博客 322

Python 标准库中最有用的装饰器(1)

这里面有两个参数,一个是 maxsize,表示缓存的大小,当传入负数时,自动设置为 0,如果不传入 maxsize,或者设置为 None,表示缓存没有大小限制,此时没有缓存淘汰。还有一个是 type,当 type 传入 True 时,不同的参数类型会当作不同的 key 存到缓存当中。已经放在了缓存,且锁已经释放了,链表已经更新了,这里什么也不需要做了,最后只需要返回计算的结果就可以了。(img-cfTjD3GR-1713609085773)]缓存命中,将命中的缓存移动到循环双向链表的头部。

2401_84010865的博客 957

增距镜或中继镜选型

增距镜光路图

camerall 5248

Python 标准库中最有用的装饰器,2024年最新大厂的面试

这里面有两个参数,一个是 maxsize,表示缓存的大小,当传入负数时,自动设置为 0,如果不传入 maxsize,或者设置为 None,表示缓存没有大小限制,此时没有缓存淘汰。书籍的好处就在于权威和体系健全,刚开始学习的时候你可以只看视频或者听某个人讲课,但等你学完之后,你觉得你掌握了,这时候建议还是得去看一下书籍,看权威技术书籍也是每个程序员必经之路。已经放在了缓存,且锁已经释放了,链表已经更新了,这里什么也不需要做了,最后只需要返回计算的结果就可以了。今天就来聊一聊这个最有用的装饰器。

m0_60721860的博客 1013

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

2024年Python 标准库中最有用的装饰器,阿里nlp面试

不知道你们用的什么环境,我一般都是用的Python3.6环境和pycharm解释器,没有软件,或者没有资料,没人解答问题,都可以免费领取(包括今天的代码),过几天我还会做个视频教程出来,有需要也可以领取~给大家准备的学习资料包括但不限于:Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。

m0_60607971的博客 603

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Python 标准库中最有用的装饰器,Python开发视频教程

我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了,只是里面的项目比较多,水平也是参差不齐,大家可以挑自己能做的项目去练练。我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了,只是里面的项目比较多,水平也是参差不齐,大家可以挑自己能做的项目去练练。第一、所谓缓存,用的仍然是内存,为了快速存取,用的就是一个 hash 表,也就是 Python 的字典,都是在内存里的操作。

m0_61067876的博客 514

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Python 函数装饰器和闭包(标准库中的装饰器)

本章内容:Python 如何计算装饰器句法Python 如何判断变量是不是局部的闭包存在的原因和工作原理nonlocal 能解决什么问题掌握这些基础知识后,我们可以进一步探讨装饰器:实现行为良好的装饰器标准库中有用的装饰器实现一个参数化装饰器。

钢铁男儿 1079

python 装饰器有哪些_Python装饰器

一, 引用二, 基本概念问题1:装饰器是什么?解答:严格来说,装饰器只是语法糖, 装饰器是可调用的对象,可以像常规的可调用对象那样调用,特殊的地方是装饰器的参数是一个函数问题2:装饰器有什么特性?解答: 装饰器有2个特性,一是可以把被装饰的函数替换成其他函数, 二是可以在加载模块时候立即执行def decorate(func):print('running decorate', func)def ...

weixin_39870092的博客 1198

python常用的装饰器有_Python 标准库中的装饰器

题目描述1、简单举例Python标准库中的装饰器2、说说你用过的Python标准库中的装饰器1.首先,我们比较熟悉,也是比较常用的Python标准库提供的装饰器有:property,classmethod,staticmethod,functools.wraps四个。这四个的可考点比较多,这里将分别说明:首先先来说明functools.wraps,这个我们在之前翻译装饰器时已经谈到...

weixin_39895181的博客 511

Python学习笔记(1)装饰器、异常检测、标准库概览、面向对象

可以通过创建一个新的异常类来拥有自己的异常。

立志成为炼丹师? 1280

python常用的装饰器库_Python 标准库中的装饰器

题目描述1、简单举例Python标准库中的装饰器2、说说你用过的Python标准库中的装饰器1.首先,我们比较熟悉,也是比较常用的Python标准库提供的装饰器有:property,classmethod,staticmethod,functools.wraps四个。这四个的可考点比较多,这里将分别说明:首先先来说明functools.wraps,这个我们在之前翻译装饰器时已经谈到...

weixin_30940057的博客 393
上一篇: Python 循环语句
下一篇: Python 批量爬取猫咪图片实现千图成像
程序员孔乙己
博客等级 码龄5年 1191粉丝 81原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值