您的位置:

python装饰器领域博主的简单介绍

本文目录一览:

Python之装饰器简介

python函数式编程之装饰器

1.开放封闭原则

简单来说,就是对扩展开放,对修改封闭。

在面向对象的编程方式中,经常会定义各种函数。一个函数的使用分为定义阶段和使用阶段,一个函数定义完成以后,可能会在很多位置被调用。这意味着如果函数的定义阶段代码被修改,受到影响的地方就会有很多,此时很容易因为一个小地方的修改而影响整套系统的崩溃,所以对于现代程序开发行业来说,一套系统一旦上线,系统的源代码就一定不能够再改动了。然而一套系统上线以后,随着用户数量的不断增加,一定会为一套系统扩展添加新的功能。

此时,又不能修改原有系统的源代码,又要为原有系统开发增加新功能,这就是程序开发行业的开放封闭原则,这时就要用到装饰器了。

相关推荐:《Python视频教程》

2.什么是装饰器??

装饰器,顾名思义,就是装饰,修饰别的对象的一种工具。

所以装饰器可以是任意可调用的对象,被装饰的对象也可以是任意可调用对象。

3.装饰器的作用

在不修改被装饰对象的源代码以及调用方式的前提下为被装饰对象添加新功能。

原则:

1.不修改被装饰对象的源代码

2.不修改被装饰对象的调用方式

目标:

为被装饰对象添加新功能。

推荐 8 个炫酷的 Python 装饰器

1、 lru_cache

这个装饰器来自functools模块。该模块包含在标准库中,非常易于使用。它还包含比这个装饰器更酷的功能,但这个装饰器是非常受人喜欢的。此装饰器可用于使用缓存加速函数的连续运行。当然,这应该在使用时记住一些关于缓存的注意事项,但在通用使用情况下,大多数时候这个装饰器都是值得使用的。

2、JIT

JIT是即时编译的缩写。通常每当我们在Python中运行一些代码时,发生的第一件事就是编译。这种编译会产生一些开销,因为类型被分配了内存,并存储为未分配但已命名的别名,使用即时编译,我们在执行时才进行编译。

在很多方面,我们可以将其视为类似于并行计算的东西,其中Python解释器同时处理两件事以节省时间。Numba JTI编译器因将这一概念提到Python中而闻名,可以非常轻松地调用此装饰器,并立即提高代码的性能。Numba包提供了JIT装饰器,它使运行更密集的软件变得更加容易,而不必进入C。

3、do_twice

do_twice装饰器的功能与它的名字差不多。此装饰器可用于通过一次调用运行两次函数,对调试特别有用。它可以用于测量两个不同迭代的功能。

4、count_calls

count_calls装饰器可用于提供有关函数在软件中使用多少次的信息。与do_twice一样,对调试也特别有用。

5、dataclass

为了节省编写类的时间,推荐使用dataclass装饰器。这个装饰器可用于快速编写类中常见的标准方法,这些方法通常会在我们编写的类中找到。

6、singleton

singleton是一个单例装饰器。通常,单例装饰器是由用户自己编写的,实际上并不是导入的。

7、use_unit

在科学计算中经常派上用场的一种装饰器是use_unit装饰器。此装饰器可用于更改返回结果的表示单位。这对于那些不想在数据中添加度量单位但仍希望人们知道这些单位是什么的人很有用。这个装饰器可不是在任何模块中真正有用,但它是非常常见的,对科学应用程序非常有用。

「低门槛 手把手」python 装饰器(Decorators)原理说明

本文目的是由浅入深地介绍python装饰器原理

装饰器(Decorators)是 Python 的一个重要部分

其功能是, 在不修改原函数(类)定义代码的情况下,增加新的功能

为了理解和实现装饰器,我们先引入2个核心操作:

在这个例子中,函数hi的形参name,默认为'world'

在函数内部,又定义了另一个函数 howdoyoudo,定义这个函数时,将形参name作为新函数的形参name2的默认值。

因此,在函数内部调用howdoyoudo()时,将以调用hi时的实参为默认值,但也可以给howdoyoudo输入其他参数。

上面的例子运行后输出结果为:

这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念,但其实没必要给它取一个多专业的名字。我们知道闭包是 函数内的函数 就可以了

当我们进行 def 的时候,我们在做什么?

这时,hi函数,打印一个字符串,同时返回一个字符串。

但hi函数本身也是一个对象,一个可以执行的对象。执行的方式是hi()。

这里hi和hi()有本质区别,

hi 代表了这个函数对象本身

hi() 则是运行了函数,得到函数的返回值。

作为对比,可以想象以下代码

此时也是b存在,可以正常使用。

我们定义2个函数,分别实现自加1, 自乘2,

再定义一个函数double_exec,内容是将某个函数调用2次

在调用double_exec时,可以将函数作为输入传进来

输出结果就是

7

27

同样,也可以将函数作为输出

输出结果为

6

10

有了以上两个核心操作,我们可以尝试构造装饰器了。

装饰器的目的: 在不修改原函数(类)定义代码的情况下,增加新的功能

试想一下,现在有一个原函数

在不修改原函数定义代码的情况下,如果想进行函数内容的添加,可以将这个函数作为一个整体,添加到这样的包裹中:

我们定义了一个my_decorator函数,这个函数进行了一种操作:

对传入的f,添加操作(运行前后增加打印),并把添加操作后的内容连同运行原函数的内容,一起传出

这个my_decorator,定义了一种增加前后打印内容的行为

调用my_decorator时,对这个行为进行了操作。

因此,new_function是一个在original_function上增加了前后打印行为的新函数

这个过程被可以被称作装饰。

这里已经可以发现,装饰器本身对于被装饰的函数是什么,是不需要考虑的。装饰器本身只定义了一种装饰行为,这个行为是通过装饰器内部的闭包函数()进行定义的。

运行装饰前后的函数,可以清晰看到装饰的效果

我们复现一下实际要用装饰器的情况,我们往往有一种装饰器,想应用于很多个函数,比如

此时,如果我们想给3个print函数都加上装饰器,需要这么做

实际调用的时候,就需要调用添加装饰器的函数名了

当然,也可以赋值给原函数名

这样至少不需要管理一系列装饰前后的函数。

同时,在不需要进行装饰的时候,需要把

全部删掉。

事实上,这样并不方便,尤其对于更复杂的装饰器来说

为此,python提供了一种简写方式

这个定义print1函数前的@my_decorator,相当于在定义完print1后,自动直接运行了

不论采用@my_decorator放在新函数前,还是显示地重写print1 = my_decorator(print1),都会存在一个问题:

装饰后的函数,名字改变了(其实不止名字,一系列的索引都改变了)

输出结果为:

这个现象的原因是,装饰行为本身,是通过构造了一个新的函数(例子中是wrap_func函数)来实现装饰这个行为的,然后把这个修改后的函数赋给了原函数名。

这样,会导致我们预期的被装饰函数的一些系统变量(比如__name__)发生了变化。

对此,python提供了解决方案:

经过这个行为后,被装饰函数的系统变量问题被解决了

输出结果为

刚才的例子都比较简单,被装饰的函数是没有参数的。如果被装饰的函数有参数,只需要在定义装饰行为时(事实上,这个才更通用),增加(*args, **kwargs)描述即可

之前的描述中可以感受到,对于例子中的装饰行为(前后加打印),函数被装饰后,本质上是调用了新的装饰函数wrap_func。

因此,如果原函数需要有输入参数传递,只需要在wrap_func(或其他任意名字的装饰函数)定义时,也增加参数输入(*args, **kwargs),并将这些参数,原封不动地传给待装饰函数f。

这种定义装饰行为的方式更具有普遍性,忘记之前的定义方式吧

我们试一下

输出

这里需要注意的是,如果按照以下的方式定义装饰器

那么以下语句将不会执行

因为装饰后实际的函数wrap_func(虽然名字被改成了原函数,系统参数也改成了原函数),运行到return f(*args, **kwargs) 的时候已经结束了

因为装饰器my_decorator本身也是可以输入的,因此,只需要在定义装饰器时,增加参数,并在后续函数中使用就可以了,比如

此时装饰器已经可以有输入参数了

输出

你可能发现,为什么不用简写版的方法了

因为以上代码会报错!!

究其原因,虽然

等价于

但是,

并不等价于

这本身和@语法有关,使用@my_decorator时,是系统在应用一个以单个函数作为参数的闭包函数。即,@是不能带参数的。

但是你应该发现了,之前的@wraps(f)不是带参数了吗?请仔细观察以下代码

通过一层嵌套,my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator),但因为my_decorator对my_decorator_with_parma来说是一个闭包,my_decorator_with_parma是可以带参数的。(这句话真绕)

通过以上的定义,我们再来看

可以这么理解,my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数,同时,因为my_decorator_with_parma可以传参,参数实际上是参与了my_decorator的(因为my_decorator对my_decorator_with_parma是闭包), my_decorator_with_parma(msg='yusheng') 全等于 一个有参数参加的my_decorator

因此,以上代码等价于有参数msg传递的

比较绕,需要理解一下,或者干脆强记这种范式:

以上范式包含函数的输入输出、装饰器的输入,可以应对大部分情况了。

实验一下:

输出

以上是一个log装饰器,利用datetime统计了函数的耗时,

并且,装饰器可以进行输出文件操作,如果给出了文件路径,则输出文件,否则就打印。

利用这个装饰器,可以灵活地进行耗时统计

不设置输出文件地址,则打印。运行结果为:

也可以输出到文件

输出结果为

同时在当前目录生成了一个test.log 文件,内容为:

以上的装饰器都是以函数形式出现的,但我们可以稍做改写,将装饰器以类的形式实现。

这个装饰器类Log 上个例子里的装饰器函数log功能是一样的,同时,这个装饰器类还可以作为基类被其他继承,进一步增加功能。

原文

如何理解Python装饰器

理解Python中的装饰器

@makebold

@makeitalic

def say():

return "Hello"

打印出如下的输出:

biHelloi/b

你会怎么做?最后给出的答案是:

def makebold(fn):

def wrapped():

return "b" + fn() + "/b"

return wrapped

def makeitalic(fn):

def wrapped():

return "i" + fn() + "/i"

return wrapped

@makebold

@makeitalic

def hello():

return "hello world"

print hello() ## 返回 bihello world/i/b

现在我们来看看如何从一些最基础的方式来理解Python的装饰器。英文讨论参考Here。

装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

1.1. 需求是怎么来的?

装饰器的定义很是抽象,我们来看一个小例子。

def foo():

print 'in foo()'

foo()

这是一个很无聊的函数没错。但是突然有一个更无聊的人,我们称呼他为B君,说我想看看执行这个函数用了多长时间,好吧,那么我们可以这样做:

import time

def foo():

start = time.clock()

print 'in foo()'

end = time.clock()

print 'used:', end - start

foo()

很好,功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了,他对另一个叫foo2的函数产生了更浓厚的兴趣。

怎么办呢?如果把以上新增加的代码复制到foo2里,这就犯了大忌了~复制什么的难道不是最讨厌了么!而且,如果B君继续看了其他的函数呢?

1.2. 以不变应万变,是变也

还记得吗,函数在Python中是一等公民,那么我们可以考虑重新定义一个函数timeit,将foo的引用传递给他,然后在timeit中调用foo并进行计时,这样,我们就达到了不改动foo定义的目的,而且,不论B君看了多少个函数,我们都不用去修改函数定义了!

import time

def foo():

print 'in foo()'

def timeit(func):

start = time.clock()

func()

end =time.clock()

print 'used:', end - start

timeit(foo)

看起来逻辑上并没有问题,一切都很美好并且运作正常!……等等,我们似乎修改了调用部分的代码。原本我们是这样调用的:foo(),修改以后变成了:timeit(foo)。这样的话,如果foo在N处都被调用了,你就不得不去修改这N处的代码。或者更极端的,考虑其中某处调用的代码无法修改这个情况,比如:这个函数是你交给别人使用的。

1.3. 最大限度地少改动!

既然如此,我们就来想想办法不修改调用的代码;如果不修改调用代码,也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo,但是timeit似乎带有一个参数……想办法把参数统一吧!如果timeit(foo)不是直接产生调用效果,而是返回一个与foo参数列表一致的函数的话……就很好办了,将timeit(foo)的返回值赋值给foo,然后,调用foo()的代码完全不用修改!

#-*- coding: UTF-8 -*-

import time

def foo():

print 'in foo()'

# 定义一个计时器,传入一个,并返回另一个附加了计时功能的方法

def timeit(func):

# 定义一个内嵌的包装函数,给传入的函数加上计时功能的包装

def wrapper():

start = time.clock()

func()

end =time.clock()

print 'used:', end - start

# 将包装后的函数返回

return wrapper

foo = timeit(foo)

foo()

这样,一个简易的计时器就做好了!我们只需要在定义foo以后调用foo之前,加上foo = timeit(foo),就可以达到计时的目的,这也就是装饰器的概念,看起来像是foo被timeit装饰了。在在这个例子中,函数进入和退出时需要计时,这被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言,像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里,能减少大量重复代码。面向切面编程还有相当多的术语,这里就不多做介绍,感兴趣的话可以去找找相关的资料。

这个例子仅用于演示,并没有考虑foo带有参数和有返回值的情况,完善它的重任就交给你了 :)

上面这段代码看起来似乎已经不能再精简了,Python于是提供了一个语法糖来降低字符输入量。

import time

def timeit(func):

def wrapper():

start = time.clock()

func()

end =time.clock()

print 'used:', end - start

return wrapper

@timeit

def foo():

print 'in foo()'

foo()

重点关注第11行的@timeit,在定义上加上这一行与另外写foo = timeit(foo)完全等价,千万不要以为@有另外的魔力。除了字符输入少了一些,还有一个额外的好处:这样看上去更有装饰器的感觉。

-------------------

要理解python的装饰器,我们首先必须明白在Python中函数也是被视为对象。这一点很重要。先看一个例子:

def shout(word="yes") :

return word.capitalize()+" !"

print shout()

# 输出 : 'Yes !'

# 作为一个对象,你可以把函数赋给任何其他对象变量

scream = shout

# 注意我们没有使用圆括号,因为我们不是在调用函数

# 我们把函数shout赋给scream,也就是说你可以通过scream调用shout

print scream()

# 输出 : 'Yes !'

# 还有,你可以删除旧的名字shout,但是你仍然可以通过scream来访问该函数

del shout

try :

print shout()

except NameError, e :

print e

#输出 : "name 'shout' is not defined"

print scream()

# 输出 : 'Yes !'

我们暂且把这个话题放旁边,我们先看看python另外一个很有意思的属性:可以在函数中定义函数:

def talk() :

# 你可以在talk中定义另外一个函数

def whisper(word="yes") :

return word.lower()+"...";

# ... 并且立马使用它

print whisper()

# 你每次调用'talk',定义在talk里面的whisper同样也会被调用

talk()

# 输出 :

# yes...

# 但是"whisper" 不会单独存在:

try :

print whisper()

except NameError, e :

print e

#输出 : "name 'whisper' is not defined"*

函数引用

从以上两个例子我们可以得出,函数既然作为一个对象,因此:

1. 其可以被赋给其他变量

2. 其可以被定义在另外一个函数内

这也就是说,函数可以返回一个函数,看下面的例子:

def getTalk(type="shout") :

# 我们定义另外一个函数

def shout(word="yes") :

return word.capitalize()+" !"

def whisper(word="yes") :

return word.lower()+"...";

# 然后我们返回其中一个

if type == "shout" :

# 我们没有使用(),因为我们不是在调用该函数

# 我们是在返回该函数

return shout

else :

return whisper

# 然后怎么使用呢 ?

# 把该函数赋予某个变量

talk = getTalk()

# 这里你可以看到talk其实是一个函数对象:

print talk

#输出 : function shout at 0xb7ea817c

# 该对象由函数返回的其中一个对象:

print talk()

# 或者你可以直接如下调用 :

print getTalk("whisper")()

#输出 : yes...

还有,既然可以返回一个函数,我们可以把它作为参数传递给函数:

def doSomethingBefore(func) :

print "I do something before then I call the function you gave me"

print func()

doSomethingBefore(scream)

#输出 :

#I do something before then I call the function you gave me

#Yes !

这里你已经足够能理解装饰器了,其他它可被视为封装器。也就是说,它能够让你在装饰前后执行代码而无须改变函数本身内容。

手工装饰

那么如何进行手动装饰呢?

# 装饰器是一个函数,而其参数为另外一个函数

def my_shiny_new_decorator(a_function_to_decorate) :

# 在内部定义了另外一个函数:一个封装器。

# 这个函数将原始函数进行封装,所以你可以在它之前或者之后执行一些代码

def the_wrapper_around_the_original_function() :

# 放一些你希望在真正函数执行前的一些代码

print "Before the function runs"

# 执行原始函数

a_function_to_decorate()

# 放一些你希望在原始函数执行后的一些代码

print "After the function runs"

#在此刻,"a_function_to_decrorate"还没有被执行,我们返回了创建的封装函数

#封装器包含了函数以及其前后执行的代码,其已经准备完毕

return the_wrapper_around_the_original_function

# 现在想象下,你创建了一个你永远也不远再次接触的函数

def a_stand_alone_function() :

print "I am a stand alone function, don't you dare modify me"

a_stand_alone_function()

#输出: I am a stand alone function, don't you dare modify me

# 好了,你可以封装它实现行为的扩展。可以简单的把它丢给装饰器

# 装饰器将动态地把它和你要的代码封装起来,并且返回一个新的可用的函数。

a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)

a_stand_alone_function_decorated()

#输出 :

#Before the function runs

#I am a stand alone function, don't you dare modify me

#After the function runs

现在你也许要求当每次调用a_stand_alone_function时,实际调用却是a_stand_alone_function_decorated。实现也很简单,可以用my_shiny_new_decorator来给a_stand_alone_function重新赋值。

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)

a_stand_alone_function()

#输出 :

#Before the function runs

#I am a stand alone function, don't you dare modify me

#After the function runs

# And guess what, that's EXACTLY what decorators do !

装饰器揭秘

前面的例子,我们可以使用装饰器的语法:

@my_shiny_new_decorator

def another_stand_alone_function() :

print "Leave me alone"

another_stand_alone_function()

#输出 :

#Before the function runs

#Leave me alone

#After the function runs

当然你也可以累积装饰:

def bread(func) :

def wrapper() :

print "/''''''\"

func()

print "\______/"

return wrapper

def ingredients(func) :

def wrapper() :

print "#tomatoes#"

func()

print "~salad~"

return wrapper

def sandwich(food="--ham--") :

print food

sandwich()

#输出 : --ham--

sandwich = bread(ingredients(sandwich))

sandwich()

#outputs :

#/''''''\

# #tomatoes#

# --ham--

# ~salad~

#\______/

使用python装饰器语法:

@bread

@ingredients

def sandwich(food="--ham--") :

print food

sandwich()

#输出 :

#/''''''\

# #tomatoes#

# --ham--

# ~salad~

#\______/