python 函数 装饰器的使用方法

一、装饰器 

首先,我们要了解到什么是开放封闭式原则?

    软件一旦上线后,对修改源代码是封闭的,对功能的扩张是开放的,所以我们应该遵循开放封闭的原则。

  也就是说:我们必须找到一种解决方案,能够在不修改一个功能源代码以及调用方式的前提下,为其加上新功能。

总结:原则如下:

  1、不修改源代码

  2、不修改调用方式

目的:在遵循1和2原则的基础上扩展新功能。

二、什么是装饰器?

器:指的是工具,

装饰:指的是为被装饰对象添加新功能。

完整的含义:装饰器即在不修改装饰对象源代码与调用方式的前提下,为被装饰器对象添加新功能的一种函数,这个函数的特殊之处就在于它的返回值也是一个函数。

一般而言,我们想要拓展原来函数的代码,直接的办法就是侵入代码里面修改,例如:

1 import time
2 def index():
3     start_time=time.time()
4     time.sleep(3)
5     print(‘hello word‘)
6     stop_time=time.time()
7     print(‘run time is %s‘%(stop_time-start_time))
8
9 index()

###输出:

hello word
run time is 3.000171422958374

  以上代码就是让你过三秒才打印‘hello word’,下面我们要再添加一个新功能,和上面的功能一样,但是要传参数进去,过5秒输出结果。

修改1:

 1 import  time
 2 def index():
 3     time.sleep(3)
 4     print(‘hello word‘)
 5
 6 def home(name):
 7     time.sleep(5)
 8     print(‘welcome %s to home page‘%name)
 9
10 def wrapper(func):
11     start_time=time.time()
12     func(‘haolo‘)
13     stop_time=time.time()
14     print(‘run time is %s‘%(stop_time-start_time))
15
16
17 wrapper(home)

###输出:

welcome haolo to home page
run time is 5.000286102294922

这样写感觉还是不怎么好,而且我们还修改了函数的调用方式,很不符合规矩。所以我们还是换一种方式来修改它。通过装饰器的方式。

修改2

 1 import time
 2 def index():
 3     time.sleep(3)
 4     print(‘hello word‘)
 5
 6 def home(name):
 7     time.sleep(5)
 8     print(‘welcome to %s‘%name)
 9
10 def outter(func):  # func为最原始的inde 和home
11     def warpper():
12         start_time=time.time()
13         func(‘yuan‘)
14         stop_time=time.time()
15         print(stop_time-start_time)
16     return warpper
17
18 home=outter(home) ###home这个变量名是新赋值的,把原来的home给覆盖了。
19 home()

###输出:

welcome to yuan
5.000286102294922

这种方式虽然满足了不修改源代码和不修改调用方式的条件,但还是不能够实现两个函数同时运行的功能,说到底还是不行,我们还得想个方式出来。就是让他们两个同时运行。这时,我又想到了上节课所学的知识,就是*args和**kargs,用两个函数通过可变参数形式来实现内嵌函数的形式传入,所以它支持运行是构建参数列表,这对于以上两次不能解决的办法是最有效的。下面我们来试试,看到底能不能成功。

方式3:

 1 import time
 2 def index():
 3     time.sleep(3)
 4     print(‘hello word‘)
 5
 6 def home(name):
 7     time.sleep(5)
 8     print(‘welcome %s to home page‘%name)
 9
10 def timmer(func):   #func为最原始的home
11     def warpper(*args,**kwargs):
12         start_time=time.time()
13         res=func(*args,**kwargs)  #调用了最原始的home
14         stop_time=time.time()
15         print(stop_time-start_time)
16         return res
17     return warpper
18
19 index=timmer(index) #为最新的index = wrapper
20 home=timmer(home)  #为最新的home = wrapper
21
22 home(name=‘yuan‘)  #wrapper=(‘yuan‘)
23 index()  #wrapper

###输出:

welcome yuan to home page
5.000285863876343
hello word
3.000171661376953

看吧,很快就实现了两个功能并用,而且我们还没有修改原始代码,还有调用方式。

其实很简单,我只是用了一个无参装饰器的模板,这个模板可以说是万能的,在以后很多的函数代码都可以用这种方式来套用。

模板:

1 def outer(func):
2     def inner(*args,**kwargs):
3         res=func(*args,**kwargs)
4         return res
5     return inner

现在又有问题来了,我们调装饰器的时候,每调一次,又要把装饰器对象传进来,调一次又传一次,这样不会觉得很麻烦吗?那么我们又想到了一种方法,就是装饰器语法糖,在被装饰对象的上面加@timmer 用它来取代 index=timmer(index)
并且把返回值正常的返回给它。

 1 import time
 2 def timmer(func):   #func为最原始的home
 3     def warpper(*args,**kwargs):
 4         start_time=time.time()
 5         res=func(*args,**kwargs)  #调用了最原始的home
 6         stop_time=time.time()
 7         print(stop_time-start_time)
 8         return res
 9     return warpper
10
11 @timmer  #就是取代底下的 index=timmer(index)
12 def index():
13     time.sleep(3)
14     print(‘hello word‘)
15
16 @timmer #就是取代底下的home=timmer(home)   home(name=‘yuan‘)
17 def home(name):
18     time.sleep(5)
19     print(‘welcome %s to home page‘%name)
20
21 index()
22 home(‘liuyuan‘)

###输出;

hello word
3.000171661376953
welcome liuyuan to home page
5.000286102294922

注意:这里的timmer函数就是最原始的装饰器,它的参数就是一个函数,然后返回值也是一个函数。其中作为参数的这个函数index()hemo(name)就是在返回函数的wrapper()的内部执行。然后再这两个函数的前面加上@timmerindex()home(name)函数就相当于被注入了计时功能,现在只需要调用index()home(‘yuan’),它就已经变身为‘新功能更多的函数了。’

  所以这里的装饰器就像一个注入的符号:有了它,拓展了原来函数的功能既不需要侵入函数内更改代码,也不需要重复执行原函数。

用装饰器来实现认证功能:

 1 import time
 2 current_user={
 3     ‘username‘:None,
 4     #‘login_time‘:None
 5 }
 6
 7 def auth(func):
 8     # func = index
 9     def wrapper(*args,**kwargs):
10         if current_user[‘username‘]:
11             print(‘已经登录过了‘)
12             res=func(*args,**kwargs)
13             return res
14
15         uname = input(‘输入用户名:‘).strip()
16         pwd = input(‘密码:‘).strip()
17         if uname == ‘yuan‘ and pwd == ‘123‘:
18             print(‘登录成功‘)
19             current_user[‘username‘]=uname
20             res = func(*args,**kwargs)
21             return res
22         else:
23             print(‘用户名或密码错误‘)
24     return wrapper
25
26 @auth #index = auth(index)
27 def index():
28     time.sleep(1)
29     print(‘welcom to index page‘)
30
31 @auth
32 def home(name):
33     time.sleep(2)
34     print(‘welcome %s to home page‘%name)
35
36 input()
37 home(‘yuan‘)

有参数的装饰器来用于用户认证

 1 import time
 2 current_user={
 3     ‘username‘:None,
 4     # ‘login_time‘:None
 5 }
 6
 7 def auth(func):
 8     # func=index
 9     def wrapper(*args,**kwargs):
10         if current_user[‘username‘]:
11             print(‘已经登陆过了‘)
12             res=func(*args,**kwargs)
13             return res
14
15         uname=input(‘用户名>>: ‘).strip()
16         pwd=input(‘密码>>: ‘).strip()
17         if uname == ‘yuan‘ and pwd == ‘123‘:
18             print(‘登陆成功‘)
19             current_user[‘username‘]=uname
20             res=func(*args,**kwargs)
21             return res
22         else:
23             print(‘用户名或密码错误‘)
24     return wrapper
25
26 def timmer(func):
27     def wrapper(*args,**kwargs):
28         start_time=time.time()
29         res=func(*args,**kwargs)
30         stop_time=time.time()
31         print(stop_time-start_time)
32         return res
33     return wrapper
34
35 @timmer # timmer 统计的是auth+index的执行时间
36 @auth
37 def index():
38     time.sleep(1)
39     print(‘welcome to index page‘)
40     return 122
41
42 index()

叠加多个装饰器:

 1 import time
 2 current_user={
 3     ‘username‘:None,
 4     # ‘login_time‘:None
 5 }
 6
 7 def auth(func):
 8     # func=index
 9     def wrapper(*args,**kwargs):
10         if current_user[‘username‘]:
11             print(‘已经登陆过了‘)
12             res=func(*args,**kwargs)
13             return res
14
15         uname=input(‘用户名>>: ‘).strip()
16         pwd=input(‘密码>>: ‘).strip()
17         if uname == ‘egon‘ and pwd == ‘123‘:
18             print(‘登陆成功‘)
19             current_user[‘username‘]=uname
20             res=func(*args,**kwargs)
21             return res
22         else:
23             print(‘用户名或密码错误‘)
24     return wrapper
25
26 def timmer(func):
27     def wrapper(*args,**kwargs):
28         start_time=time.time()
29         res=func(*args,**kwargs)
30         stop_time=time.time()
31         print(stop_time-start_time)
32         return res
33     return wrapper
34
35 @timmer # timmer 统计的是auth+index的执行时间
36 @auth
37 def index():
38     time.sleep(1)
39     print(‘welcome to index page‘)
40     return 122
41
42 index()

原文地址:https://www.cnblogs.com/lyox/p/8671098.html

时间: 2024-10-07 12:03:40

python 函数 装饰器的使用方法的相关文章

Python 函数装饰器入门

原文链接: --> A guide to Python's function decorators Python功能强劲,语法表现力强,尤其装饰器深深的吸引着我.在设计模式中,装饰器可以在不使用子类的情况下,动态的改变函数,方法以及类的功能.这个功能非常有用,特别在你想扩展函数的功能同时又不想改变原有的函数.的确,我们任意的实现装饰器设计模式,但是,python通过提供简单的语法和特性让装饰器的实现变的如此简单. 在本文中,我将用一组例子来深入浅入python 函数装饰器的功能,所有的例子都是在

python函数装饰器

学习装饰器前提需要了解高阶函数,函数嵌套,函数闭包 python函数装饰器,顾名思义就是装饰函数,为函数添加新功能的的一种方式. 为什么要使用装饰器呢? 因为函数在运行时,如果不使用装饰器对函数进行功能添加,需要修改函数源代码,这样修改无疑会增加程序的冗余和复杂性,也不便于程序员对其进行修改.使用装饰器,可以在不改变函数源代码和调用方式的前提下,使用语法糖@装饰器,对函数功能进行添加. 装饰器本质上就是一个函数. 我们使用一个简单的例子来实现: import time #这是一个装饰器函数名为t

python—函数装饰器

闭包 如果在一个内部函数(函数里的函数)里,对在外部作用域(但不是在全局作用域,可以理解为外层函数)的变量进行引用,那么内部函数就被认为是闭包. 例如: def outer(): x=10 # 这里x即为外部作用域变量 def inner(): print(x) return inner # inner函数被称为一个闭包 装饰器 写python代码一定要遵循开放封闭原则.即,可扩展功能,对源代码修改是封闭的.装饰是为函数和类指定管理代码的一种方式.装饰器本身的形式是处理其他的可调用对象的可调用的

python函数装饰器详解

基础:函数装饰器的表现方式 假如你已经定义了一个函数funcA(),在准备定义函数funcB()的时候,如果写成下面的格式: @funcA def funcB():... 表示用函数funcA()装饰函数funcB().当然,也可以认为是funcA包装函数funcB.它等价于: def funcB():... funcB = funcA(funcB) 也就是说,将函数funcB作为函数funcA的参数,funcA会重新返回另一个可调用的对象(比如函数)并赋值给funcB. 所以,funcA要想作

Python 函数装饰器和闭包

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 25.0px Helvetica } 装饰器基础知识 装饰器是可调用的对象,其参数是另一个函数(被装饰的函数). 装饰器可能会处理被装饰的函数,然后把它返回,或者将其替换成另一个函数或可调用对象. p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 15.0px Helvetica } 假如有个名为 decorate 的装饰器: @decorate def targ

Python函数--装饰器进阶

开放封闭原则 1.对扩展是开放的 为什么要对扩展开放呢? 我们说,任何一个程序,不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改.所以我们必须允许代码扩展.添加新功能. 2.对修改是封闭的 为什么要对修改封闭呢? 就像我们刚刚提到的,因为我们写的一个函数,很有可能已经交付给其他人使用了,如果这个时候我们对其进行了修改,很有可能影响其他已经在使用该函数的用户. 装饰器完美的遵循了这个开放封闭原则. *args,**kwargs def f1(*args,**kwargs):   接

python函数装饰器的使用

# -*- coding: utf-8 -*- ''' 使用语法糖@来装饰函数,相当于"myfunc = deco(myfunc)" 但发现deco函数只在第一次被调用,且myfunc函数在第一次后又被多调用了一次 ''' def deco(func): print("before myfunc() called.") func() print("after myfunc() called.") return func bool=0 @deco

python 函数装饰器

举个例子 def a_decorator(func): def wrapTheFunc(): print "before decorator" func() print "end decorator" return wrapTheFunc @a_decorator def a_func_need_decorator(): print "In a_func_need_decorator()" a_func_need_decorator() 输出 b

Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.