Python之functools、装饰器应用、实现lru功能缓存

最新推荐文章于 2025-02-13 01:28:56 发布
原创 最新推荐文章于 2025-02-13 01:28:56 发布 · 603 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #缓存 #functools #装饰器 #lru

本文深入探讨Python的functools模块，包括偏函数、lru_cache装饰器的原理及应用，自定义缓存系统，命令分发器的实现，以及装饰器在日志、监控等场景的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

这里是一段防爬虫文本，请读者忽略。
本文原创首发于优快云，作者IDYS
博客首页：https://blog.youkuaiyun.com/weixin_41633902/
本文链接：https://blog.youkuaiyun.com/weixin_41633902/article/details/108038071
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

写在开头的话

  • 请记住：实践是掌握知识的最快方法
  • 如果你只是怀着看看的态度去快速浏览文章，而不去认认真真的把文章里面讲的任何一个知识点去实践一遍，那么你永远也掌握不了它
  • 生命不息，折腾不止！

Python之functools

00. functools模块

  • partial方法

    • 偏函数，把函数部分的参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一 个新的函数并返回
    • 从partial生成的新函数，是对原函数的封装

  • 代码演示1

import functools


def add(x, y):
    print("x={}\ty={}".format(x,y))
    return x + y


add1 = functools.partial(add, 1, 2)
print(add1())

add2 = functools.partial(add, y=1)
print(add2(10))

add3 = functools.partial(add, x=1)
print(add3(y=10))

add4 = functools.partial(add, 10)
print(add4(20))
  • 运行结果
x=1	y=2
3
x=10	y=1
11
x=1	y=10
11
x=10	y=20
30

  • 代码演示2
import functools
import inspect


def add(x, y) -> int:
    return x + y


newadd = functools.partial(add, y=5)  # 相当于提前在函数中放了一个参数 y = 5
print(newadd(7))
print(newadd(7, y=6))
print(newadd(y=10, x=6))


print(inspect.signature(newadd))
  • 运行结果
12
13
16
(x, *, y=5) -> int

  • 代码演示3
import functools
import inspect

def add(x, y, *args):
    print(args)
    return x + y


add1 = functools.partial(add, 1, 2, 3, 4, 5, 6, 7)
print(add1(20, 50, 90))

add2 = functools.partial(add, 1)
add2(12, 45, 67, 78)

sig = inspect.signature(add2)
print(sig)
print(sig.parameters)
print(sig.return_annotation)
for key, value in sig.parameters.items():
    print(key, value.annotation)
    print(value.annotation is value.empty)
  • 运行结果
(3, 4, 5, 6, 7, 20, 50, 90)
3
(45, 67, 78)
(y, *args)
OrderedDict([('y', <Parameter "y">), ('args', <Parameter "*args">)])
<class 'inspect._empty'>
y <class 'inspect._empty'>
True
args <class 'inspect._empty'>
True

  • partial函数本质

def partial(func, *args, **keywords):  # partial 源码
    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


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


foo = partial(add, 4)
print(foo(5))
  • 运行结果
9

01. functools模块的 lru_cache 装饰器

  • @functools.lru_cache(maxsize=128, typed=False)
  • Least-recently-used装饰器。lru，最近最少使用。cache缓存
  • 如果maxsize设置为None，则禁用LRU功能，并且缓存可以无限制增长。当maxsize是二的幂 时，LRU功能执行得最好
  • 如果typed设置为True，则不同类型的函数参数将单独缓存。例如，f(3)和f(3.0)将被视为具有不同结果的不同调用

  • 演示
import functools
import time


@functools.lru_cache()
def add(x, y):
    time.sleep(3)
    return x + y


if __name__ == "__main__":
    print(add(1, 2))
    print(add(1, 2.0))  # 没有等待
    print(add(1, y=2))
    print(add(y=2, x=1))
    print(add(x=1, y=2))
    print(add(1, 2))  # 没有等待
  • 运行结果
3
3
3
3
3
3

  • 项目演示2
dict_test = dict(x=123, y=234, z=890)
dict_test1 = dict(y=234, x=123, z=890)
print(dict_test)

sorted_item = sorted(dict_test.items())
sorted_item1 = sorted(dict_test1.items())

print(sorted_item)
print(sorted_item1)
test_zero = tuple()
print(test_zero)
for item in dict_test.items():
    test_zero += item
print(test_zero)
  • 运行结果
{'x': 123, 'y': 234, 'z': 890}
[('x', 123), ('y', 234), ('z', 890)]
[('x', 123), ('y', 234), ('z', 890)]
()
('x', 123, 'y', 234, 'z', 890)

  • lru_cache装饰器通过一个字典缓存被装饰函数的调用和返回值

  • 斐波那契数列递归方法的改造

import functools


@functools.lru_cache()
def fbin(n):
    if n < 2:
        return n
    else:
        return fbin(n -1) + fbin(n -2)


if __name__ == "__main__":
    print(fbin(100))
  • lru_cache装饰器应用
    • 使用前提
      • 同样的函数参数一定得到同样的结果
      • 函数执行时间很长，且要多次执行
    • 本质是函数调用的参数=>返回值
    • 缺点
      • 不支持缓存过期，key无法过期、失效
      • 不支持清除操作
      • 不支持分布式，是一个单机的缓存
    • 适用场景，单机上需要空间换时间的地方，可以用缓存来将计算变成快速的查询

02. 利用装饰器写一个 lru(least-recently-used)的缓存系统

  • 要求：
    • 写一个缓存系统
    • 对缓存过的函数的值不用继续求值，直接得出结果
    • 对缓存中的数，设置超时时间，如果缓存中某个数的时间超过了设定的时间，那么则在缓存中清除这个数
    • 利用装饰器来实现这个功能

  • 代码实现
import inspect
import functools
import time
import datetime


def logger(duration):  # 装饰器传入的时间
    def _logger(fn):
        local_cache = {}   # 设置缓存

        @functools.wraps(fn)  # 属性复制，保持函数原有的属性
        def wrapper(*args, **kwargs):
            def expired_clear(my_local_cache):  # 缓存过期清除
                dict_remove = list()
                for cache_key, cache_value in my_local_cache.items():
                    if datetime.datetime.now().timestamp() - cache_value[1] > duration:
                        dict_remove.append(cache_key)
                for dict_k in dict_remove:
                    my_local_cache.pop(dict_k)
                print(my_local_cache)  # 主要是为了测试而添加，实际应该删除这行代码。但是为了直观的看到缓存过期清理功能。所以添加这一行
            expired_clear(local_cache)

            def make_key(key_fn):  # 设置函数表示符，达到命中
                sig = inspect.signature(key_fn)
                sig_par = sig.parameters
                sig_par_key_tuple = tuple(sig_par.keys())
                compare_dict = dict()
                for index, a_value in enumerate(args):
                    compare_dict[sig_par_key_tuple[index]] = a_value
                compare_dict.update(kwargs)
                for k in sig_par.keys():
                    if k not in compare_dict.keys():
                        compare_dict[k] = sig_par[k].default
                dict_key = tuple(sorted(compare_dict.items()))
                return dict_key
            key = make_key(fn)
            if key not in local_cache:   # 看传入的函数，是否已经存在于缓存当中，如果存在。那么就直接得出值。不存在则计算存入缓存当中
                ret = fn(*args, **kwargs)
                local_cache[key] = (ret, datetime.datetime.now().timestamp())
            else:
                local_cache[key] = (local_cache[key][0], datetime.datetime.now().timestamp())
            return local_cache[key][0]  # 返回函数的值
        return wrapper
    return _logger


@logger(6)   # 装饰器修饰
def add(x=11, y=10):
    time.sleep(3)
    return x + y


print(add())
print(add(11))
print(add(11, 10))
print(add(11, y=10))
print(add(y=10, x=11))
print(add(x=11, y=10))
print(add(34))
print(add(45))
print(add(12))
  • 运行结果
{}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
21
{(('x', 11), ('y', 10)): (21, 1597545428.264142)}
44
{(('x', 11), ('y', 10)): (21, 1597545428.264142), (('x', 34), ('y', 10)): (44, 1597545431.264453)}
55
{(('x', 34), ('y', 10)): (44, 1597545431.264453), (('x', 45), ('y', 10)): (55, 1597545434.264718)}
22

03. 写一个命令分发器

  • 将某个函数注册到对应的某一个命令
  • 如果命令对应的函数重复，则报错
  • 提供注销命令的功能，如果注销对应命名没有则报错
  • 如果输入没有注册的命令，那么则提示该命令没有找到

  • 代码演示

def reg_dispatcher():
    command = {}

    def reg(name):
        def _reg(fn):
            if name in command.keys():
                error = "{} is repeated ".format(name)
                raise Exception(error)
            else:
                command.setdefault(name, fn)
            return fn
        return _reg

    def default():
        print("your command is not founded")

    def dispatcher():
        while True:
            cmd = input(">>")
            if cmd.strip() == "quit":
                break
            command.get(cmd.strip(), default)()

    def cancel(name):
        if name not in command.keys():
            error = "the command name is not founded "
            raise Exception(error)
        else:
            command.pop(name)
    return reg, dispatcher, cancel


reg, dispatcher, cancel = reg_dispatcher()


@reg("welcome")  # pywel = reg("welcome")(pywel)
def py_wel():
    print("welcome to python")


@reg("go")
def go_prin():
    print("go out")


cancel("go")

print(py_wel.__doc__)
dispatcher()
  • 运行结果
>>welcome
welcome to python
>>go
your command is not founded
>>


04. 装饰器的用途

  • 装饰器是AOP面向切面编程Aspect Oriented Programming的思想体现
  • 面向对象往往需要通过继承或者组合依赖等方式调用一些功能，这些功能的代码往往可能在多个类中出现，例如logger。这样会造成代码的重复，增加了耦合。logger的改变影响所有使用它的类或方法
  • 而AOP在需要的类或者方法上切下，前后的切入点可以加入增强的功能，让调用者和被调用者解耦
  • 这是一种不修改原来的业务代码，给程序动态添加功能的的技术，例如logger函数功能就是对业务函数增加日志的，而业务函数中应该把与业务无关的日志功能剥离干净

05. 装饰器应用场景

  • 日志、监控、权限、设计、参数检查、路由等处理
  • 这些功能与业务功能无关，很多业务都需要的公共功能，所以独立出来，需要的时候对目标对象增强。

写在最后的话：

  • 无论每个知识点的难易程度如何，我都会尽力将它描绘得足够细致
  • 欢迎关注我的优快云博客，IDYS’BLOG
  • 持续更新内容：
    linux基础 | 数据通信（路由交换，WLAN） | Python基础 | 云计算
  • 如果你有什么疑问，或者是难题。欢迎评论或者私信我。你若留言，我必回复！
  • 虽然我现在还很渺小，但我会做好每一篇内容。谢谢关注！

Python性能加速器：掌握functools.lru_cache装饰器
windowshht的博客
07-26 864
lru_cache装饰器接受一个可选的maxsize参数，用于指定缓存的最大容量。当缓存项的数量超过这个值时，最久未被访问的缓存项将被移除。如果maxsize设置为None，则缓存大小将没有限制（但请注意，这可能会导致内存使用过多）。# 假设这里有一个复杂的计算过程是Python中一个非常实用的装饰器，它通过缓存函数结果的方式，能够显著提高那些重复计算相同输入值的函数的性能。本文详细介绍了lru_cache。
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
weixin_43646592的博客
02-22 5169
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
【Python模块】Python 缓存机制与 functools.lru_cache
weixin_37985288的博客
07-24 463
http://blog.konghy.cn/2016/04/20/python-cache/ 缓存是一种将定量数据【同一份数据需要多次使用的】加以保存以备迎合后续获取需求的处理方式，旨在加快数据获取的速度。 被 lru_cache 装饰的函数会有 cache_clear 和 cache_info 两个方法，分别用于清除缓存和查看缓存信息。以下为一个简单的 lru_cache 的使用效果： from...
Python - 装饰器实现缓存
anchenhe9360的博客
02-11 210
from functools import wraps def cache(func): cache = {} @wraps(func) def wrap(*args): if args not in cache: cache[args] = func(*args) return cache[args] ...
Python中的functools模块详解
海哥python的博客
02-25 2382
大家好，我是海鸽。函数被定义为一段代码，它接受参数，充当输入，执行涉及这些输入的一些处理，并根据处理返回一个值（输出）。当一个函数将另一个函数作为输入或返回另一个函数作为输出时，这些函数称为。函数式编程强调将函数作为头等对象。今天我们解读下 functools 库中用于创建和修改函数的几个高阶函数。functools模块是Python的标准库的一部分，它是为高阶函数而实现的，用于增强函数功能。 这些信息表明 模块提供了一系列用于处理函数和可调用对象的工具。以下是 模块中包含的主要方法的详细说明：: 一个
python——@functools.lru_cache修饰符简单使用
gy笨瓜的博客
12-14 1243
        使用functools.lru_cache修饰符的函数，简单的理解为保存多次执行结果，当传入某一参数的执行结果已经执行过，则不会再一次执行而是直接返回结果。 functools.lru_cache(maxsize=128, typed=False)接受两个参数:         maxsize:默认为128，表示保存使用functoo
lru
TuxedoLinux的博客
02-19 582
LRU(Least Recently Used) 最近最久未使用算法，是多数缓存系统当内存受限时自动清理旧数据的常用常用算法之一。当Redis使用内存达到配置maxmemory时，Redis会根据配置的policy进行数据置换处理，其中策略包括如下：noenviction（不清除）allkeys-lru（从所有数据集选择最近最少用）volatile-lru（从设置过期时间的数据集选择最近最少用）a...
Python functools.lru_cache 实现高速缓存及其原理 源码解析
wei_bo_cai的博客
08-08 2892
Python functools.lru_cache 实现高速缓存及其原理
@functools.lru_cache装饰器缓存机制实现文件读取
weixin_50233450的博客
02-25 888
使用缓存机制，使相同入参的函数调用只执行一次。优化速率。文件读取。
Python实现：详解LRU缓存淘汰算法
梦子微信
11-19 744
大家好，今天我们和大家聊一个非常常用的算法，叫做LRU。 LRU的英文全称是Least Recently Used，也即最不经常使用。我们看着好像挺迷糊的，其实这个含义要结合缓存一起使用。对于工程而言，缓存是非常非常重要的机制，尤其是在当下的互联网应用环境当中，起到的作用非常重要。为了便于大家更好地理解，我们从缓存的机制开始说起。 缓存 缓存的英文是cache，最早其实指的是用于CPU和主存数据交互的。早年这块存储被称为高速缓存，最近已经听不到这个词了，不知道是不是淘汰了。因为缓存的读写速度要高于CPU低于
functools.lru_cahce()的用法 Python
weixin_43401055的博客
07-19 405
一、前言 在介绍functools.lru_cache()之前，我们需要了解lru。 LRU是Least Recently Used（最近最少使用算法）的缩写。 在python中，functools.lru_cache()是lru的实现，主要是用来做缓存，他能把相对耗时的函数结果进行保存，避免传入相同的参数重复计算。同时，缓存并不会无限增长，不用的缓存会被释放。 二、lru_cache()的结构： functools.lru_cache(maxsize=128, typed=False) 参数： maxs
LRU算法实现
fulin9452的博客
02-24 358
LRU（Least Recently Used），最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法面试常备，本文以JAVA初级实现。 LRU详情参考 百度、Wiki import java.util.HashMap; import java.util.Map; class LRUNode { String key; Object value; ...
【练习时长两年半也没记住的函数】functools.lru_cache() 装饰器的使用
Leafy's draft about ML
09-23 395
记录一下自己犯错之后吸取的方法
mysql lru_mysql 原理 ~ LRU 算法与buffer_pool
weixin_30195669的博客
01-19 144
一 简介:针对查询和事务的页在内存中的处理,是如何进行的二 LRU算法普通 :实现的是末尾淘汰法,当整个链表已满时,淘汰尾部,将新的数据页加入头部mysql_lru改进 : 分为两部分 1分为 yang和old,并不从LRU列表头部进行插入，而是从中间部位.对过期页实行末尾淘汰没有问题,2 针对新插入的数据页需要做二次判断1如果数据页保持1S以上时间,则推进到yang头部2如果数据页不能保持...
lru_cache缓存装饰器
RUN
01-10 255
import functools @functools.lru_cache(None) 可以用于自顶向下的一些递归的情况。
LRU、LFU 内存淘汰算法的设计与实现
x0919的博客
09-25 1056
LRU、LFU都是内存管理淘汰算法，内存管理是计算机技术中重要的一环，也是多数操作系统中必备的模块。应用场景：假设 给定你一定内存空间，需要你维护一些缓存数据，LRU、LFU就是在内存已经满了的情况下，如果再次添加新的数据，该淘汰哪些数据来留出新数据的内存空间？？？
functools.lru_cache
kakak_的博客
07-27 762
缓存是一种将定量数据加以保存以备迎合后续获取需求的处理方式，旨在加快数据获取的速度。 数据的生成过程可能需要经过计算，规整，远程获取等操作，如果是同一份数据需要多次使用，每次都重新生成会大大浪费时间。 所以，如果将计算或者远程请求等操作获得的数据缓存下来，会加快后续的数据获取需求。 @functools.lru_cache(maxsize=None, typed=False) LRU (Least Recently Used，最近最少使用) 算法本是一种缓存淘汰策略。主要用于找出内存中较久时间没有使用.
航空电子设备之集成模块化航空电子系统解析
最新发布
02-13 1654
大家好，这里是关于飞机航空电子设备的探讨。本文将深入了解航空电子设备，着重介绍集成模块化航空电子（Integrated Modular Avionics，IMA）概念。如今，航空电子技术取得了巨大进步，基于计算机的设备发展成果斐然，这使得将多种功能集成于一个系统成为可能，因此，我们今天聚焦于航空电子设备集成及其发展前景。
Python 缓存机制之functools.lru_cache
rs勿忘初心的博客
11-21 4659
说到缓存这个概念，我想大家应该都不陌生 ，以Redis和Memcache为代表的缓存应用基本成为了现在微服务架构的标配了。 事实上，并不是说要用缓存就必须部署Redis等服务，比如在以Python为开发语言的小型单体应用中，我们可以使用functools.lru_cache来实现缓存机制，当然也可以在这个基础上二次封装来满足自己的需求，比如加上缓存过期时间等。 首先，通过一个简单的例子以了解缓存机制的概念，如下代码所示，注意这里只是说下大概的机智，不需要采用这种方法，更优雅的方法是采用functools
pycache：Python中高级缓存装饰器的功能与应用
`functools.lru_cache`是Python标准库中一个非常出名的缓存装饰器，但该描述中提到的`_cache`更加强大，能处理一些`lru_cache`做不到的场景。 - **为什么使用_cache**: 通常，缓存用于减少计算开销，提升性能。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值