导航:首页 > 编程语言 > pythoncache装饰器

pythoncache装饰器

发布时间:2022-04-30 17:16:47

1. 怎么样去理解 python 中的装饰器

可以理解成用@符号把“购买”这个两个字像用口香糖粘在了物品名称上一样,这回有点像“装饰”的意思了吧。

机器人看到@的标签,就会按@里的动作来执行。

defGoumai(Dongxi):
defDongzuo():
print('询价')
Dongxi()
print('购买成功!')
returnDongzuo

@Goumai
defZhu():
print('猪')
@Goumai
defDaxiang():
print('大象')
@Goumai
defChangjinglu():
print('长颈鹿')
Zhu()
Daxiang()
Changjinglu()

2. Python中的装饰器是作什么用的在哪可以找到这些教程。

装饰器是Python语法糖的一种,可以用来简化代码,让代码更加简洁
装饰器的作用是在不改变函数代码和调用方式的前提下,为已有函数功能添加额外的功能。
可以通过装饰器对代码实现权限管理,用户验证,日志管理,缓存判断,参数检查等等。
以上内容均来自传智播客,自己可以去搜搜,很多课。

3. python装饰器的作用和功能

装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能

4. 什么是Python装饰器


所谓装饰器就是把函数包装一下,为函数添加一些附加功能,装饰器就是一个函数,参数为被包装的函数,返回包装后的函数:你可以试下:

defd(fp):
def_d(*arg,**karg):
print"dosthbeforefp.."
r=fp(*arg,**karg)
print"dosthafterfp.."
returnr
return_d
@d
deff():
print"callf"
#上面使用@d来表示装饰器和下面是一个意思
#f=d(f)
f()#调用f



5. Python装饰器是怎么实现的

简单来讲,可以不严谨地把Python的装饰器看做一个包装函数的函数。 比如,有一个函数: def func(): print 'func() run.' if '__main__' == __name__: func() 运行后将输出: func() run. 现在需要在函数运行前后打印一条日志

6. python装饰器有什么用

先来个形象比方

内裤可以用来遮羞,但是到了冬天它没法为我们防风御寒,聪明的人们发明了长裤,有了长裤后宝宝再也不冷了,装饰器就像我们这里说的长裤,在不影响内裤作用的前提下,给我们的身子提供了保暖的功效。

再回到我们的主题

装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

先来看一个简单例子:

def foo():
print('i am foo')

现在有一个新的需求,希望可以记录下函数的执行日志,于是在代码中添加日志代码:

def foo():
print('i am foo')
logging.info("foo is running")

bar()、bar2()也有类似的需求,怎么做?再写一个logging在bar函数里?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个函数:专门处理日志 ,日志处理完之后再执行真正的业务代码

def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()def bar():
print('i am bar')use_logging(bar)

逻辑上不难理解,
但是这样的话,我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构,之前执行业务逻辑时,执行运行bar(),但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢?当然有,答案就是装饰器。


简单装饰器
def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapperdef bar():
print('i am bar')bar = use_logging(bar)bar()

函数use_logging就是装饰器,它把执行真正业务方法的func包裹在函数里面,看起来像bar被use_logging装饰了。在这个例子中,函数进入和退出时
,被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作


def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper@use_loggingdef foo():
print("i am foo")@use_loggingdef bar():
print("i am bar")bar()

如上所示,这样我们就可以省去bar =
use_logging(bar)这一句了,直接调用bar()即可得到想要的结果。如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。


带参数的装饰器

装饰器还有更大的灵活性,例如带参数的装饰器:在上面的装饰器调用中,比如@use_logging,该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator@use_logging(level="warn")def foo(name='foo'):
print("i am %s" % name)foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我
们使用@use_logging(level="warn")调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。


类装饰器

再来看看类装饰器,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法,当使用 @ 形式将装饰器附加到函数上时,就会调用此方法。


class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps

使用装饰器极大地复用了代码,但是他有一个缺点就是原函数的元信息不见了,比如函数的docstring、__name__、参数列表,先看例子:

装饰器

def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数

@loggeddef f(x):
"""does some math"""
return x + x * x

该函数完成等价于:


def f(x):
"""does some math"""
return x + x * xf = logged(f)

不难发现,函数f被with_logging取代了,当然它的docstring,__name__就是变成了with_logging函数的信息了。

print f.__name__ # prints 'with_logging'print f.__doc__ # prints None

这个问题就比较严重的,好在我们有functools.wraps,wraps本身也是一个装饰器,它能把原函数的元信息拷贝到装饰器函数中,这使得装饰器函数也有和原函数一样的元信息了。

from functools import wrapsdef logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging@loggeddef f(x):
"""does some math"""
return x + x * xprint f.__name__ # prints 'f'print f.__doc__ # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

装饰器的顺序
@a@b@cdef f ():

等效于


f = a(b(c(f)))

7. python装饰器是什么意思

装饰器是程序开发中经常会用到的一个功能,用好了装饰器,开发效率如虎添翼,所以这也是Python面试中必问的问题,但对于好多小白来讲,这个功能 有点绕,自学时直接绕过去了,然后面试问到了就挂了,因为装饰器是程序开发的基础知识,这个都 不会,别跟人家说你会Python, 看了下面的文章,保证你学会装饰器。

1、先明白这段代码

####第一波####

deffoo():

print'foo'

foo#表示是函数

foo()#表示执行foo函数

####第二波####

deffoo():

print'foo'

foo=lambdax:x+1

foo()#执行下面的lambda表达式,而不再是原来的foo函数,因为函数foo被重新定义了

2、需求来了

初创公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:

###############基础平台提供的功能如下###############

deff1():

print'f1'

deff2():

print'f2'

deff3():

print'f3'

deff4():

print'f4'

###############业务部门A调用基础平台提供的功能###############

f1()

f2()

f3()

f4()

###############业务部门B调用基础平台提供的功能###############

f1()

f2()

f3()

f4()

目前公司有条不紊的进行着,但是,以前基础平台的开发人员在写代码时候没有关注验证相关的问题,即:基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。

老大把工作交给 Low B,他是这么做的:

跟每个业务部门交涉,每个业务部门自己写代码,调用基础平台的功能之前先验证。诶,这样一来基础平台就不需要做任何修改了。

当天Low B 被开除了…

老大把工作交给 Low BB,他是这么做的:

###############基础平台提供的功能如下###############

deff1():

#验证1

#验证2

#验证3

print'f1'

deff2():

#验证1

#验证2

#验证3

print'f2'

deff3():

#验证1

#验证2

#验证3

print'f3'

deff4():

#验证1

#验证2

#验证3

print'f4'

###############业务部门不变###############

###业务部门A调用基础平台提供的功能###

f1()

f2()

f3()

f4()

###业务部门B调用基础平台提供的功能###

f1()

f2()

f3()

f4()

过了一周 Low BB 被开除了…

老大把工作交给 Low BBB,他是这么做的:

只对基础平台的代码进行重构,其他业务部门无需做任何修改

###############基础平台提供的功能如下###############

defcheck_login():

#验证1

#验证2

#验证3

pass

deff1():

check_login()

print'f1'

deff2():

check_login()

print'f2'

deff3():

check_login()

print'f3'

deff4():

check_login()

print'f4'

老大看了下Low BBB 的实现,嘴角漏出了一丝的欣慰的笑,语重心长的跟Low BBB聊了个天:

老大说:

写代码要遵循开发封闭原则,虽然在这个原则是用的面向对象开发,但是也适用于函数式编程,简单来说,它规定已经实现的功能代码不允许被修改,但可以被扩展,即:

8. python装饰器具体是怎么工作的

分析线面的代码可以得出结论,可以复制代码后自行打断点进行调试
def task(weight=1): # 代码被执行的时候首先会到这里,执行装饰器
def decorator_func(func):
func.locust_task_weight = weight return func return decorator_func # 代码执行的这里的时候会返回来源函数,获取到来源函数的对象共装饰器使用@task(1)def test():
print(test)if __name__ == '__main__':
test()

9. 如何理解Python装饰器

装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

先来看一个简单例子:
def foo():
print('i am foo')

现在有一个新的需求,希望可以记录下函数的执行日志,于是在代码中添加日志代码:
def foo():
print('i am foo')
logging.info("foo is running")

bar()、bar2()也有类似的需求,怎么做?再写一个logging在bar函数里?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个函数:专门处理日志 ,日志处理完之后再执行真正的业务代码
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()

def bar():
print('i am bar')

use_logging(bar)

逻辑上不难理解,
但是这样的话,我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构,之前执行业务逻辑时,执行运行bar(),但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢?当然有,答案就是装饰器。

简单装饰器
def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper

def bar():
print('i am bar')

bar = use_logging(bar)
bar()

函数use_logging就是装饰器,它把执行真正业务方法的func包裹在函数里面,看起来像bar被use_logging装饰了。在这个例子中,函数进入和退出时
,被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

@use_logging
def foo():
print("i am foo")

@use_logging
def bar():
print("i am bar")

bar()

如上所示,这样我们就可以省去bar =
use_logging(bar)这一句了,直接调用bar()即可得到想要的结果。如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。

带参数的装饰器
装饰器还有更大的灵活性,例如带参数的装饰器:在上面的装饰器调用中,比如@use_logging,该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator

@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)

foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我
们使用@use_logging(level="warn")调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。

类装饰器
再来看看类装饰器,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法,当使用 @ 形式将装饰器附加到函数上时,就会调用此方法。

class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps
使用装饰器极大地复用了代码,但是他有一个缺点就是原函数的元信息不见了,比如函数的docstring、__name__、参数列表,先看例子:
装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数
@logged
def f(x):
"""does some math"""
return x + x * x

该函数完成等价于:

def f(x):
"""does some math"""
return x + x * x
f = logged(f)

不难发现,函数f被with_logging取代了,当然它的docstring,__name__就是变成了with_logging函数的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None

这个问题就比较严重的,好在我们有functools.wraps,wraps本身也是一个装饰器,它能把原函数的元信息拷贝到装饰器函数中,这使得装饰器函数也有和原函数一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

@logged
def f(x):
"""does some math"""
return x + x * x

print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'

内置装饰器
@staticmathod、@classmethod、@property
装饰器的顺序
@a
@b
@c
def f ():

等效于

f = a(b(c(f)))

10. python有缓存模块吗

从Python 3.2开始,可以使用functools库中的装饰器@lru_cache。这是最近使用过的缓存,所以其中的项目没有到期时间,但作为快速入侵,它非常有用。
from functools import lru_cache

@lru_cache(maxsize=256)def f(x):
return x*xfor x in range(20):
print f(x)for x in range(20):
print f(x)

阅读全文

与pythoncache装饰器相关的资料

热点内容
什么app能看财经新闻 浏览:39
数学奇迹神奇运算法 浏览:359
大厂的程序员的水平如何 浏览:700
遗传算法入门经典书籍 浏览:878
源码炮台脚本 浏览:620
在位编辑命令 浏览:347
曲式分析基础教程pdf 浏览:14
php生成静态html页面 浏览:964
怎么分割pdf 浏览:813
压缩垃圾报警器 浏览:629
小公司一般都用什么服务器 浏览:968
java获取时间gmt时间 浏览:821
为什么csgo一直连接不到服务器 浏览:504
安卓登ins需要什么 浏览:836
机器人算法的难点 浏览:226
全自动化编程 浏览:728
程序员高薪限制 浏览:693
压缩图片压缩 浏览:75
美国发明解压魔方 浏览:302
电脑怎么备案网上服务器 浏览:515